lib/python/Components/config.py

   1 from enigma import getPrevAsciiCode
   2 from Tools.NumericalTextInput import NumericalTextInput
   3 from Tools.Directories import resolveFilename, SCOPE_CONFIG
   4 from Components.Harddisk import harddiskmanager
   5 from copy import copy as copy_copy
   6 from os import path as os_path
   7 from time import localtime, strftime
   8
   9 # ConfigElement, the base class of all ConfigElements.
  10
  11 # it stores:
  12 #   value    the current value, usefully encoded.
  13 #            usually a property which retrieves _value,
  14 #            and maybe does some reformatting
  15 #   _value   the value as it's going to be saved in the configfile,
  16 #            though still in non-string form.
  17 #            this is the object which is actually worked on.
  18 #   default  the initial value. If _value is equal to default,
  19 #            it will not be stored in the config file
  20 #   saved_value is a text representation of _value, stored in the config file
  21 #
  22 # and has (at least) the following methods:
  23 #   save()   stores _value into saved_value,
  24 #            (or stores 'None' if it should not be stored)
  25 #   load()   loads _value from saved_value, or loads
  26 #            the default if saved_value is 'None' (default)
  27 #            or invalid.
  28 #
  29 class ConfigElement:
  30         def __init__(self):
  31                 self.saved_value = None
  32                 self.last_value = None
  33                 self.save_disabled = False
  34                 self.__notifiers = None
  35                 self.__notifiers_final = None
  36                 self.enabled = True
  37                 self.callNotifiersOnSaveAndCancel = False
  38
  39         def getNotifiers(self):
  40                 if self.__notifiers is None:
  41                         self.__notifiers = [ ]
  42                 return self.__notifiers
  43
  44         notifiers = property(getNotifiers)
  45
  46         def getNotifiersFinal(self):
  47                 if self.__notifiers_final is None:
  48                         self.__notifiers_final = [ ]
  49                 return self.__notifiers_final
  50
  51         notifiers_final = property(getNotifiersFinal)
  52
  53         # you need to override this to do input validation
  54         def setValue(self, value):
  55                 self._value = value
  56                 self.changed()
  57
  58         def getValue(self):
  59                 return self._value
  60
  61         value = property(getValue, setValue)
  62
  63         # you need to override this if self.value is not a string
  64         def fromstring(self, value):
  65                 return value
  66
  67         # you can overide this for fancy default handling
  68         def load(self):
  69                 sv = self.saved_value
  70                 if sv is None:
  71                         self.value = self.default
  72                 else:
  73                         self.value = self.fromstring(sv)
  74
  75         def tostring(self, value):
  76                 return str(value)
  77
  78         # you need to override this if str(self.value) doesn't work
  79         def save(self):
  80                 if self.save_disabled or self.value == self.default:
  81                         self.saved_value = None
  82                 else:
  83                         self.saved_value = self.tostring(self.value)
  84                 if self.callNotifiersOnSaveAndCancel:
  85                         self.changed()
  86
  87         def cancel(self):
  88                 self.load()
  89                 if self.callNotifiersOnSaveAndCancel:
  90                         self.changed()
  91
  92         def isChanged(self):
  93                 sv = self.saved_value
  94                 if sv is None and self.value == self.default:
  95                         return False
  96                 return self.tostring(self.value) != sv
  97
  98         def changed(self):
  99                 if self.__notifiers:
 100                         for x in self.notifiers:
 101                                 x(self)
 102
 103         def changedFinal(self):
 104                 if self.__notifiers_final:
 105                         for x in self.notifiers_final:
 106                                 x(self)
 107
 108         def addNotifier(self, notifier, initial_call = True, immediate_feedback = True):
 109                 assert callable(notifier), "notifiers must be callable"
 110                 if immediate_feedback:
 111                         self.notifiers.append(notifier)
 112                 else:
 113                         self.notifiers_final.append(notifier)
 114                 # CHECKME:
 115                 # do we want to call the notifier
 116                 #  - at all when adding it? (yes, though optional)
 117                 #  - when the default is active? (yes)
 118                 #  - when no value *yet* has been set,
 119                 #    because no config has ever been read (currently yes)
 120                 #    (though that's not so easy to detect.
 121                 #     the entry could just be new.)
 122                 if initial_call:
 123                         notifier(self)
 124
 125         def disableSave(self):
 126                 self.save_disabled = True
 127
 128         def __call__(self, selected):
 129                 return self.getMulti(selected)
 130
 131         def onSelect(self, session):
 132                 pass
 133
 134         def onDeselect(self, session):
 135                 if not self.last_value == self.value:
 136                         self.changedFinal()
 137                         self.last_value = self.value
 138
 139 KEY_LEFT = 0
 140 KEY_RIGHT = 1
 141 KEY_OK = 2
 142 KEY_DELETE = 3
 143 KEY_BACKSPACE = 4
 144 KEY_HOME = 5
 145 KEY_END = 6
 146 KEY_TOGGLEOW = 7
 147 KEY_ASCII = 8
 148 KEY_TIMEOUT = 9
 149 KEY_NUMBERS = range(12, 12+10)
 150 KEY_0 = 12
 151 KEY_9 = 12+9
 152
 153 def getKeyNumber(key):
 154         assert key in KEY_NUMBERS
 155         return key - KEY_0
 156
 157 class choicesList: # XXX: we might want a better name for this
 158         LIST_TYPE_LIST = 1
 159         LIST_TYPE_DICT = 2
 160
 161         def __init__(self, choices, type = None):
 162                 self.choices = choices
 163                 if type is None:
 164                         if isinstance(choices, list):
 165                                 self.type = choicesList.LIST_TYPE_LIST
 166                         elif isinstance(choices, dict):
 167                                 self.type = choicesList.LIST_TYPE_DICT
 168                         else:
 169                                 assert False, "choices must be dict or list!"
 170                 else:
 171                         self.type = type
 172
 173         def __list__(self):
 174                 if self.type == choicesList.LIST_TYPE_LIST:
 175                         ret = [isinstance(x, tuple) and x[0] or x for x in self.choices]
 176                 else:
 177                         ret = self.choices.keys()
 178                 return ret or [""]
 179
 180         def __iter__(self):
 181                 if self.type == choicesList.LIST_TYPE_LIST:
 182                         ret = [isinstance(x, tuple) and x[0] or x for x in self.choices]
 183                 else:
 184                         ret = self.choices
 185                 return iter(ret or [""])
 186
 187         def __len__(self):
 188                 return len(self.choices) or 1
 189
 190         def __getitem__(self, index):
 191                 if self.type == choicesList.LIST_TYPE_LIST:
 192                         ret = self.choices[index]
 193                         if isinstance(ret, tuple):
 194                                 ret = ret[0]
 195                         return ret
 196                 return self.choices.keys()[index]
 197
 198         def index(self, value):
 199                 return self.__list__().index(value)
 200
 201         def __setitem__(self, index, value):
 202                 if self.type == choicesList.LIST_TYPE_LIST:
 203                         orig = self.choices[index]
 204                         if isinstance(orig, tuple):
 205                                 self.choices[index] = (value, orig[1])
 206                         else:
 207                                 self.choices[index] = value
 208                 else:
 209                         key = self.choices.keys()[index]
 210                         orig = self.choices[key]
 211                         del self.choices[key]
 212                         self.choices[value] = orig
 213
 214         def default(self):
 215                 choices = self.choices
 216                 if not choices:
 217                         return ""
 218                 if self.type is choicesList.LIST_TYPE_LIST:
 219                         default = choices[0]
 220                         if isinstance(default, tuple):
 221                                 default = default[0]
 222                 else:
 223                         default = choices.keys()[0]
 224                 return default
 225
 226 class descriptionList(choicesList): # XXX: we might want a better name for this
 227         def __list__(self):
 228                 if self.type == choicesList.LIST_TYPE_LIST:
 229                         ret = [isinstance(x, tuple) and x[1] or x for x in self.choices]
 230                 else:
 231                         ret = self.choices.values()
 232                 return ret or [""]
 233
 234         def __iter__(self):
 235                 return iter(self.__list__())
 236
 237         def __getitem__(self, index):
 238                 if self.type == choicesList.LIST_TYPE_LIST:
 239                         for x in self.choices:
 240                                 if isinstance(x, tuple):
 241                                         if x[0] == index:
 242                                                 return str(x[1])
 243                                 elif x == index:
 244                                         return str(x)
 245                         return str(index) # Fallback!
 246                 else:
 247                         return str(self.choices.get(index, ""))
 248
 249         def __setitem__(self, index, value):
 250                 if self.type == choicesList.LIST_TYPE_LIST:
 251                         i = self.index(index)
 252                         orig = self.choices[i]
 253                         if isinstance(orig, tuple):
 254                                 self.choices[i] = (orig[0], value)
 255                         else:
 256                                 self.choices[i] = value
 257                 else:
 258                         self.choices[index] = value
 259
 260 #
 261 # ConfigSelection is a "one of.."-type.
 262 # it has the "choices", usually a list, which contains
 263 # (id, desc)-tuples (or just only the ids, in case the id
 264 # will be used as description)
 265 #
 266 # all ids MUST be plain strings.
 267 #
 268 class ConfigSelection(ConfigElement):
 269         def __init__(self, choices, default = None):
 270                 ConfigElement.__init__(self)
 271                 self.choices = choicesList(choices)
 272
 273                 if default is None:
 274                         default = self.choices.default()
 275
 276                 self.default = self._value = self.last_value = default
 277                 self.changed()
 278
 279         def setChoices(self, choices, default = None):
 280                 self.choices = choicesList(choices)
 281
 282                 if default is None:
 283                         default = self.choices.default()
 284
 285                 if self.value not in self.choices:
 286                         self.value = default
 287
 288         def setValue(self, value):
 289                 if value in self.choices:
 290                         self._value = value
 291                 else:
 292                         self._value = self.default
 293                 self.changed()
 294
 295         def tostring(self, val):
 296                 return val
 297
 298         def getValue(self):
 299                 return self._value
 300
 301         def setCurrentText(self, text):
 302                 i = self.choices.index(self.value)
 303                 self.choices[i] = text
 304                 self.description[text] = text
 305                 self._value = text
 306
 307         value = property(getValue, setValue)
 308
 309         def getIndex(self):
 310                 return self.choices.index(self.value)
 311
 312         index = property(getIndex)
 313
 314         # GUI
 315         def handleKey(self, key):
 316                 nchoices = len(self.choices)
 317                 i = self.choices.index(self.value)
 318                 if key == KEY_LEFT:
 319                         self.value = self.choices[(i + nchoices - 1) % nchoices]
 320                 elif key == KEY_RIGHT:
 321                         self.value = self.choices[(i + 1) % nchoices]
 322                 elif key == KEY_HOME:
 323                         self.value = self.choices[0]
 324                 elif key == KEY_END:
 325                         self.value = self.choices[nchoices - 1]
 326
 327         def selectNext(self):
 328                 nchoices = len(self.choices)
 329                 i = self.choices.index(self.value)
 330                 self.value = self.choices[(i + 1) % nchoices]
 331
 332         def getText(self):
 333                 descr = self.description[self.value]
 334                 if descr:
 335                         return _(descr)
 336                 return descr
 337
 338         def getMulti(self, selected):
 339                 descr = self.description[self.value]
 340                 if descr:
 341                         return ("text", _(descr))
 342                 return ("text", descr)
 343
 344         # HTML
 345         def getHTML(self, id):
 346                 res = ""
 347                 for v in self.choices:
 348                         descr = self.description[v]
 349                         if self.value == v:
 350                                 checked = 'checked="checked" '
 351                         else:
 352                                 checked = ''
 353                         res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + descr + "</input></br>\n"
 354                 return res;
 355
 356         def unsafeAssign(self, value):
 357                 # setValue does check if value is in choices. This is safe enough.
 358                 self.value = value
 359
 360         description = property(lambda self: descriptionList(self.choices.choices, self.choices.type))
 361
 362 # a binary decision.
 363 #
 364 # several customized versions exist for different
 365 # descriptions.
 366 #
 367 boolean_descriptions = {False: "false", True: "true"}
 368 class ConfigBoolean(ConfigElement):
 369         def __init__(self, default = False, descriptions = boolean_descriptions):
 370                 ConfigElement.__init__(self)
 371                 self.descriptions = descriptions
 372                 self.value = self.last_value = self.default = default
 373
 374         def handleKey(self, key):
 375                 if key in [KEY_LEFT, KEY_RIGHT]:
 376                         self.value = not self.value
 377                 elif key == KEY_HOME:
 378                         self.value = False
 379                 elif key == KEY_END:
 380                         self.value = True
 381
 382         def getText(self):
 383                 descr = self.descriptions[self.value]
 384                 if descr:
 385                         return _(descr)
 386                 return descr
 387
 388         def getMulti(self, selected):
 389                 descr = self.descriptions[self.value]
 390                 if descr:
 391                         return ("text", _(descr))
 392                 return ("text", descr)
 393
 394         def tostring(self, value):
 395                 if not value:
 396                         return "false"
 397                 else:
 398                         return "true"
 399
 400         def fromstring(self, val):
 401                 if val == "true":
 402                         return True
 403                 else:
 404                         return False
 405
 406         def getHTML(self, id):
 407                 if self.value:
 408                         checked = ' checked="checked"'
 409                 else:
 410                         checked = ''
 411                 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
 412
 413         # this is FLAWED. and must be fixed.
 414         def unsafeAssign(self, value):
 415                 if value == "1":
 416                         self.value = True
 417                 else:
 418                         self.value = False
 419
 420         def onDeselect(self, session):
 421                 if not self.last_value == self.value:
 422                         self.changedFinal()
 423                         self.last_value = self.value
 424
 425 yes_no_descriptions = {False: _("no"), True: _("yes")}
 426 class ConfigYesNo(ConfigBoolean):
 427         def __init__(self, default = False):
 428                 ConfigBoolean.__init__(self, default = default, descriptions = yes_no_descriptions)
 429
 430 on_off_descriptions = {False: _("off"), True: _("on")}
 431 class ConfigOnOff(ConfigBoolean):
 432         def __init__(self, default = False):
 433                 ConfigBoolean.__init__(self, default = default, descriptions = on_off_descriptions)
 434
 435 enable_disable_descriptions = {False: _("disable"), True: _("enable")}
 436 class ConfigEnableDisable(ConfigBoolean):
 437         def __init__(self, default = False):
 438                 ConfigBoolean.__init__(self, default = default, descriptions = enable_disable_descriptions)
 439
 440 class ConfigDateTime(ConfigElement):
 441         def __init__(self, default, formatstring, increment = 86400):
 442                 ConfigElement.__init__(self)
 443                 self.increment = increment
 444                 self.formatstring = formatstring
 445                 self.value = self.last_value = self.default = int(default)
 446
 447         def handleKey(self, key):
 448                 if key == KEY_LEFT:
 449                         self.value = self.value - self.increment
 450                 elif key == KEY_RIGHT:
 451                         self.value = self.value + self.increment
 452                 elif key == KEY_HOME or key == KEY_END:
 453                         self.value = self.default
 454
 455         def getText(self):
 456                 return strftime(self.formatstring, localtime(self.value))
 457
 458         def getMulti(self, selected):
 459                 return ("text", strftime(self.formatstring, localtime(self.value)))
 460
 461         def fromstring(self, val):
 462                 return int(val)
 463
 464 # *THE* mighty config element class
 465 #
 466 # allows you to store/edit a sequence of values.
 467 # can be used for IP-addresses, dates, plain integers, ...
 468 # several helper exist to ease this up a bit.
 469 #
 470 class ConfigSequence(ConfigElement):
 471         def __init__(self, seperator, limits, default, censor_char = ""):
 472                 ConfigElement.__init__(self)
 473                 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
 474                 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
 475                 #assert isinstance(default, list), "default must be a list"
 476                 #assert isinstance(default[0], int), "list must contain numbers"
 477                 #assert len(default) == len(limits), "length must match"
 478
 479                 self.marked_pos = 0
 480                 self.seperator = seperator
 481                 self.limits = limits
 482                 self.censor_char = censor_char
 483
 484                 self.last_value = self.default = default
 485                 self.value = copy_copy(default)
 486                 self.endNotifier = None
 487
 488         def validate(self):
 489                 max_pos = 0
 490                 num = 0
 491                 for i in self._value:
 492                         max_pos += len(str(self.limits[num][1]))
 493
 494                         if self._value[num] < self.limits[num][0]:
 495                                 self._value[num] = self.limits[num][0]
 496
 497                         if self._value[num] > self.limits[num][1]:
 498                                 self._value[num] = self.limits[num][1]
 499
 500                         num += 1
 501
 502                 if self.marked_pos >= max_pos:
 503                         if endNotifier:
 504                                 for x in self.endNotifier:
 505                                         x(self)
 506                         self.marked_pos = max_pos - 1
 507
 508                 if self.marked_pos < 0:
 509                         self.marked_pos = 0
 510
 511         def validatePos(self):
 512                 if self.marked_pos < 0:
 513                         self.marked_pos = 0
 514
 515                 total_len = sum([len(str(x[1])) for x in self.limits])
 516
 517                 if self.marked_pos >= total_len:
 518                         self.marked_pos = total_len - 1
 519
 520         def addEndNotifier(self, notifier):
 521                 if endNotifier is None:
 522                         endNotifier = []
 523                 self.endNotifier.append(notifier)
 524
 525         def handleKey(self, key):
 526                 if key == KEY_LEFT:
 527                         self.marked_pos -= 1
 528                         self.validatePos()
 529
 530                 if key == KEY_RIGHT:
 531                         self.marked_pos += 1
 532                         self.validatePos()
 533
 534                 if key == KEY_HOME:
 535                         self.marked_pos = 0
 536                         self.validatePos()
 537
 538                 if key == KEY_END:
 539                         max_pos = 0
 540                         num = 0
 541                         for i in self._value:
 542                                 max_pos += len(str(self.limits[num][1]))
 543                                 num += 1
 544                         self.marked_pos = max_pos - 1
 545                         self.validatePos()
 546
 547                 if key in KEY_NUMBERS or key == KEY_ASCII:
 548                         if key == KEY_ASCII:
 549                                 code = getPrevAsciiCode()
 550                                 if code < 48 or code > 57:
 551                                         return
 552                                 number = code - 48
 553                         else:
 554                                 number = getKeyNumber(key)
 555
 556                         block_len = []
 557                         for x in self.limits:
 558                                 block_len.append(len(str(x[1])))
 559
 560                         total_len = sum(block_len)
 561
 562                         pos = 0
 563                         blocknumber = 0
 564                         block_len_total = [0, ]
 565                         for x in block_len:
 566                                 pos += block_len[blocknumber]
 567                                 block_len_total.append(pos)
 568                                 if pos - 1 >= self.marked_pos:
 569                                         pass
 570                                 else:
 571                                         blocknumber += 1
 572
 573                         # length of numberblock
 574                         number_len = len(str(self.limits[blocknumber][1]))
 575
 576                         # position in the block
 577                         posinblock = self.marked_pos - block_len_total[blocknumber]
 578
 579                         oldvalue = self._value[blocknumber]
 580                         olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
 581                         newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
 582
 583                         self._value[blocknumber] = newvalue
 584                         self.marked_pos += 1
 585
 586                         self.validate()
 587                         self.changed()
 588
 589         def genText(self):
 590                 value = ""
 591                 mPos = self.marked_pos
 592                 num = 0;
 593                 for i in self._value:
 594                         if value:       #fixme no heading separator possible
 595                                 value += self.seperator
 596                                 if mPos >= len(value) - 1:
 597                                         mPos += 1
 598                         if self.censor_char == "":
 599                                 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
 600                         else:
 601                                 value += (self.censor_char * len(str(self.limits[num][1])))
 602                         num += 1
 603                 return (value, mPos)
 604
 605         def getText(self):
 606                 (value, mPos) = self.genText()
 607                 return value
 608
 609         def getMulti(self, selected):
 610                 (value, mPos) = self.genText()
 611                         # only mark cursor when we are selected
 612                         # (this code is heavily ink optimized!)
 613                 if self.enabled:
 614                         return ("mtext"[1-selected:], value, [mPos])
 615                 else:
 616                         return ("text", value)
 617
 618         def tostring(self, val):
 619                 return self.seperator.join([self.saveSingle(x) for x in val])
 620
 621         def saveSingle(self, v):
 622                 return str(v)
 623
 624         def fromstring(self, value):
 625                 return [int(x) for x in value.split(self.seperator)]
 626
 627         def onDeselect(self, session):
 628                 if self.last_value != self._value:
 629                         self.changedFinal()
 630                         self.last_value = copy_copy(self._value)
 631
 632 ip_limits = [(0,255),(0,255),(0,255),(0,255)]
 633 class ConfigIP(ConfigSequence):
 634         def __init__(self, default, auto_jump = False):
 635                 ConfigSequence.__init__(self, seperator = ".", limits = ip_limits, default = default)
 636                 self.block_len = []
 637                 for x in self.limits:
 638                         self.block_len.append(len(str(x[1])))
 639                 self.marked_block = 0
 640                 self.overwrite = True
 641                 self.auto_jump = auto_jump
 642
 643         def handleKey(self, key):
 644
 645                 if key == KEY_LEFT:
 646                         if self.marked_block > 0:
 647                                 self.marked_block -= 1
 648                         self.overwrite = True
 649
 650                 if key == KEY_RIGHT:
 651                         if self.marked_block < len(self.limits)-1:
 652                                 self.marked_block += 1
 653                         self.overwrite = True
 654
 655                 if key == KEY_HOME:
 656                         self.marked_block = 0
 657                         self.overwrite = True
 658
 659                 if key == KEY_END:
 660                         self.marked_block = len(self.limits)-1
 661                         self.overwrite = True
 662
 663                 if key in KEY_NUMBERS or key == KEY_ASCII:
 664                         if key == KEY_ASCII:
 665                                 code = getPrevAsciiCode()
 666                                 if code < 48 or code > 57:
 667                                         return
 668                                 number = code - 48
 669                         else:
 670                                 number = getKeyNumber(key)
 671                         oldvalue = self._value[self.marked_block]
 672
 673                         if self.overwrite:
 674                                 self._value[self.marked_block] = number
 675                                 self.overwrite = False
 676                         else:
 677                                 oldvalue *= 10
 678                                 newvalue = oldvalue + number
 679                                 if self.auto_jump and newvalue > self.limits[self.marked_block][1] and self.marked_block < len(self.limits)-1:
 680                                         self.handleKey(KEY_RIGHT)
 681                                         self.handleKey(key)
 682                                         return
 683                                 else:
 684                                         self._value[self.marked_block] = newvalue
 685
 686                         if len(str(self._value[self.marked_block])) >= self.block_len[self.marked_block]:
 687                                 self.handleKey(KEY_RIGHT)
 688
 689                         self.validate()
 690                         self.changed()
 691
 692         def genText(self):
 693                 value = ""
 694                 block_strlen = []
 695                 for i in self._value:
 696                         block_strlen.append(len(str(i)))
 697                         if value:
 698                                 value += self.seperator
 699                         value += str(i)
 700                 leftPos = sum(block_strlen[:(self.marked_block)])+self.marked_block
 701                 rightPos = sum(block_strlen[:(self.marked_block+1)])+self.marked_block
 702                 mBlock = range(leftPos, rightPos)
 703                 return (value, mBlock)
 704
 705         def getMulti(self, selected):
 706                 (value, mBlock) = self.genText()
 707                 if self.enabled:
 708                         return ("mtext"[1-selected:], value, mBlock)
 709                 else:
 710                         return ("text", value)
 711
 712         def getHTML(self, id):
 713                 # we definitely don't want leading zeros
 714                 return '.'.join(["%d" % d for d in self.value])
 715
 716 mac_limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)]
 717 class ConfigMAC(ConfigSequence):
 718         def __init__(self, default):
 719                 ConfigSequence.__init__(self, seperator = ":", limits = mac_limits, default = default)
 720
 721 class ConfigPosition(ConfigSequence):
 722         def __init__(self, default, args):
 723                 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
 724
 725 clock_limits = [(0,23),(0,59)]
 726 class ConfigClock(ConfigSequence):
 727         def __init__(self, default):
 728                 t = localtime(default)
 729                 ConfigSequence.__init__(self, seperator = ":", limits = clock_limits, default = [t.tm_hour, t.tm_min])
 730
 731         def increment(self):
 732                 # Check if Minutes maxed out
 733                 if self._value[1] == 59:
 734                         # Increment Hour, reset Minutes
 735                         if self._value[0] < 23:
 736                                 self._value[0] += 1
 737                         else:
 738                                 self._value[0] = 0
 739                         self._value[1] = 0
 740                 else:
 741                         # Increment Minutes
 742                         self._value[1] += 1
 743                 # Trigger change
 744                 self.changed()
 745
 746         def decrement(self):
 747                 # Check if Minutes is minimum
 748                 if self._value[1] == 0:
 749                         # Decrement Hour, set Minutes to 59
 750                         if self._value[0] > 0:
 751                                 self._value[0] -= 1
 752                         else:
 753                                 self._value[0] = 23
 754                         self._value[1] = 59
 755                 else:
 756                         # Decrement Minutes
 757                         self._value[1] -= 1
 758                 # Trigger change
 759                 self.changed()
 760
 761 integer_limits = (0, 9999999999)
 762 class ConfigInteger(ConfigSequence):
 763         def __init__(self, default, limits = integer_limits):
 764                 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
 765
 766         # you need to override this to do input validation
 767         def setValue(self, value):
 768                 self._value = [value]
 769                 self.changed()
 770
 771         def getValue(self):
 772                 return self._value[0]
 773
 774         value = property(getValue, setValue)
 775
 776         def fromstring(self, value):
 777                 return int(value)
 778
 779         def tostring(self, value):
 780                 return str(value)
 781
 782 class ConfigPIN(ConfigInteger):
 783         def __init__(self, default, len = 4, censor = ""):
 784                 assert isinstance(default, int), "ConfigPIN default must be an integer"
 785                 if default == -1:
 786                         default = "aaaa"
 787                 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = default)
 788                 self.len = len
 789
 790         def getLength(self):
 791                 return self.len
 792
 793 class ConfigFloat(ConfigSequence):
 794         def __init__(self, default, limits):
 795                 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
 796
 797         def getFloat(self):
 798                 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
 799
 800         float = property(getFloat)
 801
 802 # an editable text...
 803 class ConfigText(ConfigElement, NumericalTextInput):
 804         def __init__(self, default = "", fixed_size = True, visible_width = False):
 805                 ConfigElement.__init__(self)
 806                 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
 807
 808                 self.marked_pos = 0
 809                 self.allmarked = (default != "")
 810                 self.fixed_size = fixed_size
 811                 self.visible_width = visible_width
 812                 self.offset = 0
 813                 self.overwrite = fixed_size
 814                 self.help_window = None
 815                 self.value = self.last_value = self.default = default
 816
 817         def validateMarker(self):
 818                 if self.fixed_size:
 819                         if self.marked_pos > len(self.text)-1:
 820                                 self.marked_pos = len(self.text)-1
 821                 else:
 822                         if self.marked_pos > len(self.text):
 823                                 self.marked_pos = len(self.text)
 824                 if self.marked_pos < 0:
 825                         self.marked_pos = 0
 826                 if self.visible_width:
 827                         if self.marked_pos < self.offset:
 828                                 self.offset = self.marked_pos
 829                         if self.marked_pos >= self.offset + self.visible_width:
 830                                 if self.marked_pos == len(self.text):
 831                                         self.offset = self.marked_pos - self.visible_width
 832                                 else:
 833                                         self.offset = self.marked_pos - self.visible_width + 1
 834                         if self.offset > 0 and self.offset + self.visible_width > len(self.text):
 835                                 self.offset = max(0, len(self.text) - self.visible_width)
 836
 837         def insertChar(self, ch, pos, owr):
 838                 if owr or self.overwrite:
 839                         self.text = self.text[0:pos] + ch + self.text[pos + 1:]
 840                 elif self.fixed_size:
 841                         self.text = self.text[0:pos] + ch + self.text[pos:-1]
 842                 else:
 843                         self.text = self.text[0:pos] + ch + self.text[pos:]
 844
 845         def deleteChar(self, pos):
 846                 if not self.fixed_size:
 847                         self.text = self.text[0:pos] + self.text[pos + 1:]
 848                 elif self.overwrite:
 849                         self.text = self.text[0:pos] + " " + self.text[pos + 1:]
 850                 else:
 851                         self.text = self.text[0:pos] + self.text[pos + 1:] + " "
 852
 853         def deleteAllChars(self):
 854                 if self.fixed_size:
 855                         self.text = " " * len(self.text)
 856                 else:
 857                         self.text = ""
 858                 self.marked_pos = 0
 859
 860         def handleKey(self, key):
 861                 # this will no change anything on the value itself
 862                 # so we can handle it here in gui element
 863                 if key == KEY_DELETE:
 864                         self.timeout()
 865                         if self.allmarked:
 866                                 self.deleteAllChars()
 867                                 self.allmarked = False
 868                         else:
 869                                 self.deleteChar(self.marked_pos)
 870                                 if self.fixed_size and self.overwrite:
 871                                         self.marked_pos += 1
 872                 elif key == KEY_BACKSPACE:
 873                         self.timeout()
 874                         if self.allmarked:
 875                                 self.deleteAllChars()
 876                                 self.allmarked = False
 877                         elif self.marked_pos > 0:
 878                                 self.deleteChar(self.marked_pos-1)
 879                                 if not self.fixed_size and self.offset > 0:
 880                                         self.offset -= 1
 881                                 self.marked_pos -= 1
 882                 elif key == KEY_LEFT:
 883                         self.timeout()
 884                         if self.allmarked:
 885                                 self.marked_pos = len(self.text)
 886                                 self.allmarked = False
 887                         else:
 888                                 self.marked_pos -= 1
 889                 elif key == KEY_RIGHT:
 890                         self.timeout()
 891                         if self.allmarked:
 892                                 self.marked_pos = 0
 893                                 self.allmarked = False
 894                         else:
 895                                 self.marked_pos += 1
 896                 elif key == KEY_HOME:
 897                         self.timeout()
 898                         self.allmarked = False
 899                         self.marked_pos = 0
 900                 elif key == KEY_END:
 901                         self.timeout()
 902                         self.allmarked = False
 903                         self.marked_pos = len(self.text)
 904                 elif key == KEY_TOGGLEOW:
 905                         self.timeout()
 906                         self.overwrite = not self.overwrite
 907                 elif key == KEY_ASCII:
 908                         self.timeout()
 909                         newChar = unichr(getPrevAsciiCode())
 910                         if self.allmarked:
 911                                 self.deleteAllChars()
 912                                 self.allmarked = False
 913                         self.insertChar(newChar, self.marked_pos, False)
 914                         self.marked_pos += 1
 915                 elif key in KEY_NUMBERS:
 916                         owr = self.lastKey == getKeyNumber(key)
 917                         newChar = self.getKey(getKeyNumber(key))
 918                         if self.allmarked:
 919                                 self.deleteAllChars()
 920                                 self.allmarked = False
 921                         self.insertChar(newChar, self.marked_pos, owr)
 922                 elif key == KEY_TIMEOUT:
 923                         self.timeout()
 924                         if self.help_window:
 925                                 self.help_window.update(self)
 926                         return
 927
 928                 if self.help_window:
 929                         self.help_window.update(self)
 930                 self.validateMarker()
 931                 self.changed()
 932
 933         def nextFunc(self):
 934                 self.marked_pos += 1
 935                 self.validateMarker()
 936                 self.changed()
 937
 938         def getValue(self):
 939                 return self.text.encode("utf-8")
 940
 941         def setValue(self, val):
 942                 try:
 943                         self.text = val.decode("utf-8")
 944                 except UnicodeDecodeError:
 945                         self.text = val.decode("utf-8", "ignore")
 946                         print "Broken UTF8!"
 947
 948         value = property(getValue, setValue)
 949         _value = property(getValue, setValue)
 950
 951         def getText(self):
 952                 return self.text.encode("utf-8")
 953
 954         def getMulti(self, selected):
 955                 if self.visible_width:
 956                         if self.allmarked:
 957                                 mark = range(0, min(self.visible_width, len(self.text)))
 958                         else:
 959                                 mark = [self.marked_pos-self.offset]
 960                         return ("mtext"[1-selected:], self.text[self.offset:self.offset+self.visible_width].encode("utf-8")+" ", mark)
 961                 else:
 962                         if self.allmarked:
 963                                 mark = range(0, len(self.text))
 964                         else:
 965                                 mark = [self.marked_pos]
 966                         return ("mtext"[1-selected:], self.text.encode("utf-8")+" ", mark)
 967
 968         def onSelect(self, session):
 969                 self.allmarked = (self.value != "")
 970                 if session is not None:
 971                         from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
 972                         self.help_window = session.instantiateDialog(NumericalTextInputHelpDialog, self)
 973                         self.help_window.show()
 974
 975         def onDeselect(self, session):
 976                 self.marked_pos = 0
 977                 self.offset = 0
 978                 if self.help_window:
 979                         session.deleteDialog(self.help_window)
 980                         self.help_window = None
 981                 if not self.last_value == self.value:
 982                         self.changedFinal()
 983                         self.last_value = self.value
 984
 985         def getHTML(self, id):
 986                 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
 987
 988         def unsafeAssign(self, value):
 989                 self.value = str(value)
 990
 991 class ConfigPassword(ConfigText):
 992         def __init__(self, default = "", fixed_size = False, visible_width = False, censor = "*"):
 993                 ConfigText.__init__(self, default = default, fixed_size = fixed_size, visible_width = visible_width)
 994                 self.censor_char = censor
 995                 self.hidden = True
 996
 997         def getMulti(self, selected):
 998                 mtext, text, mark = ConfigText.getMulti(self, selected)
 999                 if self.hidden:
1000                         text = len(text) * self.censor_char
1001                 return (mtext, text, mark)
1002
1003         def onSelect(self, session):
1004                 ConfigText.onSelect(self, session)
1005                 self.hidden = False
1006
1007         def onDeselect(self, session):
1008                 ConfigText.onDeselect(self, session)
1009                 self.hidden = True
1010
1011 class ConfigNumber(ConfigText):
1012         def __init__(self, default = 0):
1013                 ConfigText.__init__(self, str(default), fixed_size = False)
1014
1015         def getValue(self):
1016                 return int(self.text)
1017
1018         def setValue(self, val):
1019                 self.text = str(val)
1020
1021         value = property(getValue, setValue)
1022         _value = property(getValue, setValue)
1023
1024         def conform(self):
1025                 pos = len(self.text) - self.marked_pos
1026                 self.text = self.text.lstrip("0")
1027                 if self.text == "":
1028                         self.text = "0"
1029                 if pos > len(self.text):
1030                         self.marked_pos = 0
1031                 else:
1032                         self.marked_pos = len(self.text) - pos
1033
1034         def handleKey(self, key):
1035                 if key in KEY_NUMBERS or key == KEY_ASCII:
1036                         if key == KEY_ASCII:
1037                                 ascii = getPrevAsciiCode()
1038                                 if not (48 <= ascii <= 57):
1039                                         return
1040                         else:
1041                                 ascii = getKeyNumber(key) + 48
1042                         newChar = unichr(ascii)
1043                         if self.allmarked:
1044                                 self.deleteAllChars()
1045                                 self.allmarked = False
1046                         self.insertChar(newChar, self.marked_pos, False)
1047                         self.marked_pos += 1
1048                 else:
1049                         ConfigText.handleKey(self, key)
1050                 self.conform()
1051
1052         def onSelect(self, session):
1053                 self.allmarked = (self.value != "")
1054
1055         def onDeselect(self, session):
1056                 self.marked_pos = 0
1057                 self.offset = 0
1058                 if not self.last_value == self.value:
1059                         self.changedFinal()
1060                         self.last_value = self.value
1061
1062 class ConfigSearchText(ConfigText):
1063         def __init__(self, default = "", fixed_size = False, visible_width = False):
1064                 ConfigText.__init__(self, default = default, fixed_size = fixed_size, visible_width = visible_width)
1065                 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False, search = True)
1066
1067 class ConfigDirectory(ConfigText):
1068         def __init__(self, default="", visible_width=60):
1069                 ConfigText.__init__(self, default, fixed_size = True, visible_width = visible_width)
1070         def handleKey(self, key):
1071                 pass
1072         def getValue(self):
1073                 if self.text == "":
1074                         return None
1075                 else:
1076                         return ConfigText.getValue(self)
1077         def setValue(self, val):
1078                 if val == None:
1079                         val = ""
1080                 ConfigText.setValue(self, val)
1081         def getMulti(self, selected):
1082                 if self.text == "":
1083                         return ("mtext"[1-selected:], _("List of Storage Devices"), range(0))
1084                 else:
1085                         return ConfigText.getMulti(self, selected)
1086
1087 # a slider.
1088 class ConfigSlider(ConfigElement):
1089         def __init__(self, default = 0, increment = 1, limits = (0, 100)):
1090                 ConfigElement.__init__(self)
1091                 self.value = self.last_value = self.default = default
1092                 self.min = limits[0]
1093                 self.max = limits[1]
1094                 self.increment = increment
1095
1096         def checkValues(self):
1097                 if self.value < self.min:
1098                         self.value = self.min
1099
1100                 if self.value > self.max:
1101                         self.value = self.max
1102
1103         def handleKey(self, key):
1104                 if key == KEY_LEFT:
1105                         self.value -= self.increment
1106                 elif key == KEY_RIGHT:
1107                         self.value += self.increment
1108                 elif key == KEY_HOME:
1109                         self.value = self.min
1110                 elif key == KEY_END:
1111                         self.value = self.max
1112                 else:
1113                         return
1114                 self.checkValues()
1115
1116         def getText(self):
1117                 return "%d / %d" % (self.value, self.max)
1118
1119         def getMulti(self, selected):
1120                 self.checkValues()
1121                 return ("slider", self.value, self.max)
1122
1123         def fromstring(self, value):
1124                 return int(value)
1125
1126 # a satlist. in fact, it's a ConfigSelection.
1127 class ConfigSatlist(ConfigSelection):
1128         def __init__(self, list, default = None):
1129                 if default is not None:
1130                         default = str(default)
1131                 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc, flags) in list], default = default)
1132
1133         def getOrbitalPosition(self):
1134                 if self.value == "":
1135                         return None
1136                 return int(self.value)
1137
1138         orbital_position = property(getOrbitalPosition)
1139
1140 class ConfigSet(ConfigElement):
1141         def __init__(self, choices, default = []):
1142                 ConfigElement.__init__(self)
1143                 if isinstance(choices, list):
1144                         choices.sort()
1145                         self.choices = choicesList(choices, choicesList.LIST_TYPE_LIST)
1146                 else:
1147                         assert False, "ConfigSet choices must be a list!"
1148                 if default is None:
1149                         default = []
1150                 self.pos = -1
1151                 default.sort()
1152                 self.last_value = self.default = default
1153                 self.value = default[:]
1154
1155         def toggleChoice(self, choice):
1156                 if choice in self.value:
1157                         self.value.remove(choice)
1158                 else:
1159                         self.value.append(choice)
1160                         self.value.sort()
1161                 self.changed()
1162
1163         def handleKey(self, key):
1164                 if key in KEY_NUMBERS + [KEY_DELETE, KEY_BACKSPACE]:
1165                         if self.pos != -1:
1166                                 self.toggleChoice(self.choices[self.pos])
1167                 elif key == KEY_LEFT:
1168                         self.pos -= 1
1169                         if self.pos < -1:
1170                             self.pos = len(self.choices)-1
1171                 elif key == KEY_RIGHT:
1172                         self.pos += 1
1173                         if self.pos >= len(self.choices):
1174                             self.pos = -1
1175                 elif key in [KEY_HOME, KEY_END]:
1176                         self.pos = -1
1177
1178         def genString(self, lst):
1179                 res = ""
1180                 for x in lst:
1181                         res += self.description[x]+" "
1182                 return res
1183
1184         def getText(self):
1185                 return self.genString(self.value)
1186
1187         def getMulti(self, selected):
1188                 if not selected or self.pos == -1:
1189                         return ("text", self.genString(self.value))
1190                 else:
1191                         tmp = self.value[:]
1192                         ch = self.choices[self.pos]
1193                         mem = ch in self.value
1194                         if not mem:
1195                                 tmp.append(ch)
1196                                 tmp.sort()
1197                         ind = tmp.index(ch)
1198                         val1 = self.genString(tmp[:ind])
1199                         val2 = " "+self.genString(tmp[ind+1:])
1200                         if mem:
1201                                 chstr = " "+self.description[ch]+" "
1202                         else:
1203                                 chstr = "("+self.description[ch]+")"
1204                         return ("mtext", val1+chstr+val2, range(len(val1),len(val1)+len(chstr)))
1205
1206         def onDeselect(self, session):
1207                 self.pos = -1
1208                 if not self.last_value == self.value:
1209                         self.changedFinal()
1210                         self.last_value = self.value[:]
1211
1212         def tostring(self, value):
1213                 return str(value)
1214
1215         def fromstring(self, val):
1216                 return eval(val)
1217
1218         description = property(lambda self: descriptionList(self.choices.choices, choicesList.LIST_TYPE_LIST))
1219
1220 class ConfigLocations(ConfigElement):
1221         def __init__(self, default = [], visible_width = False):
1222                 ConfigElement.__init__(self)
1223                 self.visible_width = visible_width
1224                 self.pos = -1
1225                 self.default = default
1226                 self.locations = []
1227                 self.mountpoints = []
1228                 harddiskmanager.on_partition_list_change.append(self.mountpointsChanged)
1229                 self.value = default+[]
1230
1231         def setValue(self, value):
1232                 loc = [x[0] for x in self.locations if x[3]]
1233                 add = [x for x in value if not x in loc]
1234                 diff = add + [x for x in loc if not x in value]
1235                 self.locations = [x for x in self.locations if not x[0] in diff] + [[x, self.getMountpoint(x), True, True] for x in add]
1236                 self.locations.sort(key = lambda x: x[0])
1237                 self.changed()
1238
1239         def getValue(self):
1240                 self.checkChangedMountpoints()
1241                 for x in self.locations:
1242                         x[3] = x[2]
1243                 return [x[0] for x in self.locations if x[3]]
1244
1245         value = property(getValue, setValue)
1246
1247         def tostring(self, value):
1248                 return str(value)
1249
1250         def fromstring(self, val):
1251                 return eval(val)
1252
1253         def load(self):
1254                 sv = self.saved_value
1255                 if sv is None:
1256                         tmp = self.default
1257                 else:
1258                         tmp = self.fromstring(sv)
1259                 self.locations = [[x, None, False, False] for x in tmp]
1260                 self.refreshMountpoints()
1261                 for x in self.locations:
1262                         if os_path.exists(x[0]):
1263                                 x[1] = self.getMountpoint(x[0])
1264                                 x[2] = True
1265
1266         def save(self):
1267                 if self.save_disabled or self.locations == []:
1268                         self.saved_value = None
1269                 else:
1270                         self.saved_value = self.tostring([x[0] for x in self.locations])
1271
1272         def isChanged(self):
1273                 sv = self.saved_value
1274                 if val is None and self.locations == []:
1275                         return False
1276                 return self.tostring([x[0] for x in self.locations]) != sv
1277
1278         def mountpointsChanged(self, action, dev):
1279                 print "Mounts changed: ", action, dev
1280                 mp = dev.mountpoint+"/"
1281                 if action == "add":
1282                         self.addedMount(mp)
1283                 elif action == "remove":
1284                         self.removedMount(mp)
1285                 self.refreshMountpoints()
1286
1287         def addedMount(self, mp):
1288                 for x in self.locations:
1289                         if x[1] == mp:
1290                                 x[2] = True
1291                         elif x[1] == None and os_path.exists(x[0]):
1292                                 x[1] = self.getMountpoint(x[0])
1293                                 x[2] = True
1294
1295         def removedMount(self, mp):
1296                 for x in self.locations:
1297                         if x[1] == mp:
1298                                 x[2] = False
1299
1300         def refreshMountpoints(self):
1301                 self.mountpoints = [p.mountpoint + "/" for p in harddiskmanager.getMountedPartitions() if p.mountpoint != "/"]
1302                 self.mountpoints.sort(key = lambda x: -len(x))
1303
1304         def checkChangedMountpoints(self):
1305                 oldmounts = self.mountpoints
1306                 self.refreshMountpoints()
1307                 if oldmounts == self.mountpoints:
1308                         return
1309                 for x in oldmounts:
1310                         if not x in self.mountpoints:
1311                                 self.removedMount(x)
1312                 for x in self.mountpoints:
1313                         if not x in oldmounts:
1314                                 self.addedMount(x)
1315
1316         def getMountpoint(self, file):
1317                 file = os_path.realpath(file)+"/"
1318                 for m in self.mountpoints:
1319                         if file.startswith(m):
1320                                 return m
1321                 return None
1322
1323         def handleKey(self, key):
1324                 if key == KEY_LEFT:
1325                         self.pos -= 1
1326                         if self.pos < -1:
1327                             self.pos = len(self.value)-1
1328                 elif key == KEY_RIGHT:
1329                         self.pos += 1
1330                         if self.pos >= len(self.value):
1331                             self.pos = -1
1332                 elif key in [KEY_HOME, KEY_END]:
1333                         self.pos = -1
1334
1335         def getText(self):
1336                 return " ".join(self.value)
1337
1338         def getMulti(self, selected):
1339                 if not selected:
1340                         valstr = " ".join(self.value)
1341                         if self.visible_width and len(valstr) > self.visible_width:
1342                                 return ("text", valstr[0:self.visible_width])
1343                         else:
1344                                 return ("text", valstr)
1345                 else:
1346                         i = 0
1347                         valstr = ""
1348                         ind1 = 0
1349                         ind2 = 0
1350                         for val in self.value:
1351                                 if i == self.pos:
1352                                         ind1 = len(valstr)
1353                                 valstr += str(val)+" "
1354                                 if i == self.pos:
1355                                         ind2 = len(valstr)
1356                                 i += 1
1357                         if self.visible_width and len(valstr) > self.visible_width:
1358                                 if ind1+1 < self.visible_width/2:
1359                                         off = 0
1360                                 else:
1361                                         off = min(ind1+1-self.visible_width/2, len(valstr)-self.visible_width)
1362                                 return ("mtext", valstr[off:off+self.visible_width], range(ind1-off,ind2-off))
1363                         else:
1364                                 return ("mtext", valstr, range(ind1,ind2))
1365
1366         def onDeselect(self, session):
1367                 self.pos = -1
1368
1369 # nothing.
1370 class ConfigNothing(ConfigSelection):
1371         def __init__(self):
1372                 ConfigSelection.__init__(self, choices = [""])
1373
1374 # until here, 'saved_value' always had to be a *string*.
1375 # now, in ConfigSubsection, and only there, saved_value
1376 # is a dict, essentially forming a tree.
1377 #
1378 # config.foo.bar=True
1379 # config.foobar=False
1380 #
1381 # turns into:
1382 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
1383 #
1384
1385 class ConfigSubsectionContent:
1386         pass
1387
1388 # we store a backup of the loaded configuration
1389 # data in self.stored_values, to be able to deploy
1390 # them when a new config element will be added,
1391 # so non-default values are instantly available
1392
1393 # A list, for example:
1394 # config.dipswitches = ConfigSubList()
1395 # config.dipswitches.append(ConfigYesNo())
1396 # config.dipswitches.append(ConfigYesNo())
1397 # config.dipswitches.append(ConfigYesNo())
1398 class ConfigSubList(list):
1399         def __init__(self):
1400                 list.__init__(self)
1401                 self.stored_values = {}
1402
1403         def save(self):
1404                 for x in self:
1405                         x.save()
1406
1407         def load(self):
1408                 for x in self:
1409                         x.load()
1410
1411         def getSavedValue(self):
1412                 res = { }
1413                 for i in range(len(self)):
1414                         sv = self[i].saved_value
1415                         if sv is not None:
1416                                 res[str(i)] = sv
1417                 return res
1418
1419         def setSavedValue(self, values):
1420                 self.stored_values = dict(values)
1421                 for (key, val) in self.stored_values.items():
1422                         if int(key) < len(self):
1423                                 self[int(key)].saved_value = val
1424
1425         saved_value = property(getSavedValue, setSavedValue)
1426
1427         def append(self, item):
1428                 i = str(len(self))
1429                 list.append(self, item)
1430                 if i in self.stored_values:
1431                         item.saved_value = self.stored_values[i]
1432                         item.load()
1433
1434         def dict(self):
1435                 return dict([(str(index), value) for index, value in self.enumerate()])
1436
1437 # same as ConfigSubList, just as a dictionary.
1438 # care must be taken that the 'key' has a proper
1439 # str() method, because it will be used in the config
1440 # file.
1441 class ConfigSubDict(dict):
1442         def __init__(self):
1443                 dict.__init__(self)
1444                 self.stored_values = {}
1445
1446         def save(self):
1447                 for x in self.values():
1448                         x.save()
1449
1450         def load(self):
1451                 for x in self.values():
1452                         x.load()
1453
1454         def getSavedValue(self):
1455                 res = {}
1456                 for (key, val) in self.items():
1457                         sv = val.saved_value
1458                         if sv is not None:
1459                                 res[str(key)] = sv
1460                 return res
1461
1462         def setSavedValue(self, values):
1463                 self.stored_values = dict(values)
1464                 for (key, val) in self.items():
1465                         if str(key) in self.stored_values:
1466                                 val = self.stored_values[str(key)]
1467
1468         saved_value = property(getSavedValue, setSavedValue)
1469
1470         def __setitem__(self, key, item):
1471                 dict.__setitem__(self, key, item)
1472                 if str(key) in self.stored_values:
1473                         item.saved_value = self.stored_values[str(key)]
1474                         item.load()
1475
1476         def dict(self):
1477                 return self
1478
1479 # Like the classes above, just with a more "native"
1480 # syntax.
1481 #
1482 # some evil stuff must be done to allow instant
1483 # loading of added elements. this is why this class
1484 # is so complex.
1485 #
1486 # we need the 'content' because we overwrite
1487 # __setattr__.
1488 # If you don't understand this, try adding
1489 # __setattr__ to a usual exisiting class and you will.
1490 class ConfigSubsection:
1491         def __init__(self):
1492                 self.__dict__["content"] = ConfigSubsectionContent()
1493                 self.content.items = { }
1494                 self.content.stored_values = { }
1495
1496         def __setattr__(self, name, value):
1497                 if name == "saved_value":
1498                         return self.setSavedValue(value)
1499                 assert isinstance(value, (ConfigSubsection, ConfigElement, ConfigSubList, ConfigSubDict)), "ConfigSubsections can only store ConfigSubsections, ConfigSubLists, ConfigSubDicts or ConfigElements"
1500                 content = self.content
1501                 content.items[name] = value
1502                 x = content.stored_values.get(name, None)
1503                 if x is not None:
1504                         #print "ok, now we have a new item,", name, "and have the following value for it:", x
1505                         value.saved_value = x
1506                         value.load()
1507
1508         def __getattr__(self, name):
1509                 return self.content.items[name]
1510
1511         def getSavedValue(self):
1512                 res = self.content.stored_values
1513                 for (key, val) in self.content.items.items():
1514                         sv = val.saved_value
1515                         if sv is not None:
1516                                 res[key] = sv
1517                         elif key in res:
1518                                 del res[key]
1519                 return res
1520
1521         def setSavedValue(self, values):
1522                 values = dict(values)
1523                 self.content.stored_values = values
1524                 for (key, val) in self.content.items.items():
1525                         value = values.get(key, None)
1526                         if value is not None:
1527                                 val.saved_value = value
1528
1529         saved_value = property(getSavedValue, setSavedValue)
1530
1531         def save(self):
1532                 for x in self.content.items.values():
1533                         x.save()
1534
1535         def load(self):
1536                 for x in self.content.items.values():
1537                         x.load()
1538
1539         def dict(self):
1540                 return self.content.items
1541
1542 # the root config object, which also can "pickle" (=serialize)
1543 # down the whole config tree.
1544 #
1545 # we try to keep non-existing config entries, to apply them whenever
1546 # a new config entry is added to a subsection
1547 # also, non-existing config entries will be saved, so they won't be
1548 # lost when a config entry disappears.
1549 class Config(ConfigSubsection):
1550         def __init__(self):
1551                 ConfigSubsection.__init__(self)
1552
1553         def pickle_this(self, prefix, topickle, result):
1554                 for (key, val) in topickle.items():
1555                         name = ''.join((prefix, '.', key))
1556                         if isinstance(val, dict):
1557                                 self.pickle_this(name, val, result)
1558                         elif isinstance(val, tuple):
1559                                 result += [name, '=', val[0], '\n']
1560                         else:
1561                                 result += [name, '=', val, '\n']
1562
1563         def pickle(self):
1564                 result = []
1565                 self.pickle_this("config", self.saved_value, result)
1566                 return ''.join(result)
1567
1568         def unpickle(self, lines):
1569                 tree = { }
1570                 for l in lines:
1571                         if not l or l[0] == '#':
1572                                 continue
1573
1574                         n = l.find('=')
1575                         val = l[n+1:].strip()
1576
1577                         names = l[:n].split('.')
1578 #                       if val.find(' ') != -1:
1579 #                               val = val[:val.find(' ')]
1580
1581                         base = tree
1582
1583                         for n in names[:-1]:
1584                                 base = base.setdefault(n, {})
1585
1586                         base[names[-1]] = val
1587
1588                 # we inherit from ConfigSubsection, so ...
1589                 #object.__setattr__(self, "saved_value", tree["config"])
1590                 if "config" in tree:
1591                         self.setSavedValue(tree["config"])
1592
1593         def saveToFile(self, filename):
1594                 f = open(filename, "w")
1595                 f.write(self.pickle())
1596                 f.close()
1597
1598         def loadFromFile(self, filename):
1599                 f = open(filename, "r")
1600                 self.unpickle(f.readlines())
1601                 f.close()
1602
1603 config = Config()
1604 config.misc = ConfigSubsection()
1605
1606 class ConfigFile:
1607         CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "settings")
1608
1609         def load(self):
1610                 try:
1611                         config.loadFromFile(self.CONFIG_FILE)
1612                 except IOError, e:
1613                         print "unable to load config (%s), assuming defaults..." % str(e)
1614
1615         def save(self):
1616 #               config.save()
1617                 config.saveToFile(self.CONFIG_FILE)
1618
1619         def __resolveValue(self, pickles, cmap):
1620                 if cmap.has_key(pickles[0]):
1621                         if len(pickles) > 1:
1622                                 return self.__resolveValue(pickles[1:], cmap[pickles[0]].dict())
1623                         else:
1624                                 return str(cmap[pickles[0]].value)
1625                 return None
1626
1627         def getResolvedKey(self, key):
1628                 names = key.split('.')
1629                 if len(names) > 1:
1630                         if names[0] == "config":
1631                                 ret=self.__resolveValue(names[1:], config.content.items)
1632                                 if ret and len(ret):
1633                                         return ret
1634                 print "getResolvedKey", key, "failed !! (Typo??)"
1635                 return ""
1636
1637 def NoSave(element):
1638         element.disableSave()
1639         return element
1640
1641 configfile = ConfigFile()
1642
1643 configfile.load()
1644
1645 def getConfigListEntry(*args):
1646         assert len(args) > 1, "getConfigListEntry needs a minimum of two arguments (descr, configElement)"
1647         return args
1648
1649 def updateConfigElement(element, newelement):
1650         newelement.value = element.value
1651         return newelement
1652
1653 #def _(x):
1654 #       return x
1655 #
1656 #config.bla = ConfigSubsection()
1657 #config.bla.test = ConfigYesNo()
1658 #config.nim = ConfigSubList()
1659 #config.nim.append(ConfigSubsection())
1660 #config.nim[0].bla = ConfigYesNo()
1661 #config.nim.append(ConfigSubsection())
1662 #config.nim[1].bla = ConfigYesNo()
1663 #config.nim[1].blub = ConfigYesNo()
1664 #config.arg = ConfigSubDict()
1665 #config.arg["Hello"] = ConfigYesNo()
1666 #
1667 #config.arg["Hello"].handleKey(KEY_RIGHT)
1668 #config.arg["Hello"].handleKey(KEY_RIGHT)
1669 #
1670 ##config.saved_value
1671 #
1672 ##configfile.save()
1673 #config.save()
1674 #print config.pickle()