2 from enigma import getPrevAsciiCode
3 from Tools.NumericalTextInput import NumericalTextInput
4 from Tools.Directories import resolveFilename, SCOPE_CONFIG
8 # ConfigElement, the base class of all ConfigElements.
11 # value the current value, usefully encoded.
12 # usually a property which retrieves _value,
13 # and maybe does some reformatting
14 # _value the value as it's going to be saved in the configfile,
15 # though still in non-string form.
16 # this is the object which is actually worked on.
17 # default the initial value. If _value is equal to default,
18 # it will not be stored in the config file
19 # saved_value is a text representation of _value, stored in the config file
21 # and has (at least) the following methods:
22 # save() stores _value into saved_value,
23 # (or stores 'None' if it should not be stored)
24 # load() loads _value from saved_value, or loads
25 # the default if saved_value is 'None' (default)
28 class ConfigElement(object):
32 self.saved_value = None
33 self.save_disabled = False
37 # you need to override this to do input validation
38 def setValue(self, value):
45 value = property(getValue, setValue)
47 # you need to override this if self.value is not a string
48 def fromstring(self, value):
51 # you can overide this for fancy default handling
53 if self.saved_value is None:
54 self.value = self.default
56 self.value = self.fromstring(self.saved_value)
58 def tostring(self, value):
61 # you need to override this if str(self.value) doesn't work
63 if self.save_disabled or self.value == self.default:
64 self.saved_value = None
66 self.saved_value = self.tostring(self.value)
72 if self.saved_value is None and self.value == self.default:
74 return self.tostring(self.value) != self.saved_value
77 for x in self.notifiers:
80 def addNotifier(self, notifier, initial_call = True):
81 assert callable(notifier), "notifiers must be callable"
82 self.notifiers.append(notifier)
85 # do we want to call the notifier
86 # - at all when adding it? (yes, though optional)
87 # - when the default is active? (yes)
88 # - when no value *yet* has been set,
89 # because no config has ever been read (currently yes)
90 # (though that's not so easy to detect.
91 # the entry could just be new.)
95 def disableSave(self):
96 self.save_disabled = True
98 def __call__(self, selected):
99 return self.getMulti(selected)
101 def onSelect(self, session):
104 def onDeselect(self, session):
117 KEY_NUMBERS = range(12, 12+10)
121 def getKeyNumber(key):
122 assert key in KEY_NUMBERS
126 # ConfigSelection is a "one of.."-type.
127 # it has the "choices", usually a list, which contains
128 # (id, desc)-tuples (or just only the ids, in case the id
129 # will be used as description)
131 # all ids MUST be plain strings.
133 class ConfigSelection(ConfigElement):
134 def __init__(self, choices, default = None):
135 ConfigElement.__init__(self)
137 self.description = {}
139 if isinstance(choices, list):
141 if isinstance(x, tuple):
142 self.choices.append(x[0])
143 self.description[x[0]] = x[1]
145 self.choices.append(x)
146 self.description[x] = x
147 elif isinstance(choices, dict):
148 for (key, val) in choices.items():
149 self.choices.append(key)
150 self.description[key] = val
152 assert False, "ConfigSelection choices must be dict or list!"
154 #assert len(self.choices), "you can't have an empty configselection"
155 if len(self.choices) == 0:
157 self.description[""] = ""
160 default = self.choices[0]
162 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
163 for x in self.choices:
164 assert isinstance(x, str), "ConfigSelection choices must be strings"
166 self.value = self.default = default
168 def setValue(self, value):
169 if value in self.choices:
172 self._value = self.default
176 def tostring(self, val):
182 def setCurrentText(self, text):
183 i = self.choices.index(self.value)
184 del self.description[self.choices[i]]
185 self.choices[i] = text
186 self.description[text] = text
189 value = property(getValue, setValue)
192 return self.choices.index(self.value)
194 index = property(getIndex)
197 def handleKey(self, key):
198 nchoices = len(self.choices)
199 i = self.choices.index(self.value)
201 self.value = self.choices[(i + nchoices - 1) % nchoices]
202 elif key == KEY_RIGHT:
203 self.value = self.choices[(i + 1) % nchoices]
204 elif key == KEY_HOME:
205 self.value = self.choices[0]
207 self.value = self.choices[nchoices - 1]
210 descr = self.description[self.value]
215 def getMulti(self, selected):
216 descr = self.description[self.value]
218 return ("text", _(descr))
219 return ("text", descr)
222 def getHTML(self, id):
224 for v in self.choices:
226 checked = 'checked="checked" '
229 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
232 def unsafeAssign(self, value):
233 # setValue does check if value is in choices. This is safe enough.
238 # several customized versions exist for different
241 class ConfigBoolean(ConfigElement):
242 def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
243 ConfigElement.__init__(self)
244 self.descriptions = descriptions
245 self.value = self.default = default
246 def handleKey(self, key):
247 if key in [KEY_LEFT, KEY_RIGHT]:
248 self.value = not self.value
249 elif key == KEY_HOME:
255 descr = self.descriptions[self.value]
260 def getMulti(self, selected):
261 descr = self.descriptions[self.value]
263 return ("text", _(descr))
264 return ("text", descr)
266 def tostring(self, value):
272 def fromstring(self, val):
278 def getHTML(self, id):
280 checked = ' checked="checked"'
283 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
285 # this is FLAWED. and must be fixed.
286 def unsafeAssign(self, value):
292 class ConfigYesNo(ConfigBoolean):
293 def __init__(self, default = False):
294 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
296 class ConfigOnOff(ConfigBoolean):
297 def __init__(self, default = False):
298 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
300 class ConfigEnableDisable(ConfigBoolean):
301 def __init__(self, default = False):
302 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
304 class ConfigDateTime(ConfigElement):
305 def __init__(self, default, formatstring, increment = 86400):
306 ConfigElement.__init__(self)
307 self.increment = increment
308 self.formatstring = formatstring
309 self.value = self.default = int(default)
311 def handleKey(self, key):
313 self.value = self.value - self.increment
314 elif key == KEY_RIGHT:
315 self.value = self.value + self.increment
316 elif key == KEY_HOME or key == KEY_END:
317 self.value = self.default
320 return time.strftime(self.formatstring, time.localtime(self.value))
322 def getMulti(self, selected):
323 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
325 def fromstring(self, val):
328 # *THE* mighty config element class
330 # allows you to store/edit a sequence of values.
331 # can be used for IP-addresses, dates, plain integers, ...
332 # several helper exist to ease this up a bit.
334 class ConfigSequence(ConfigElement):
335 def __init__(self, seperator, limits, censor_char = "", default = None):
336 ConfigElement.__init__(self)
337 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
338 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
339 #assert isinstance(default, list), "default must be a list"
340 #assert isinstance(default[0], int), "list must contain numbers"
341 #assert len(default) == len(limits), "length must match"
344 self.seperator = seperator
346 self.censor_char = censor_char
348 self.default = default
349 self.value = copy.copy(default)
351 self.endNotifier = []
356 for i in self._value:
357 max_pos += len(str(self.limits[num][1]))
359 while self._value[num] < self.limits[num][0]:
360 self._value[num] += 1
362 while self._value[num] > self.limits[num][1]:
363 self._value[num] -= 1
367 if self.marked_pos >= max_pos:
368 for x in self.endNotifier:
370 self.marked_pos = max_pos - 1
372 if self.marked_pos < 0:
375 def validatePos(self):
376 if self.marked_pos < 0:
379 total_len = sum([len(str(x[1])) for x in self.limits])
381 if self.marked_pos >= total_len:
382 self.marked_pos = total_len - 1
384 def addEndNotifier(self, notifier):
385 self.endNotifier.append(notifier)
387 def handleKey(self, key):
403 for i in self._value:
404 max_pos += len(str(self.limits[num][1]))
406 self.marked_pos = max_pos - 1
409 if key in KEY_NUMBERS or key == KEY_ASCII:
411 code = getPrevAsciiCode()
412 if code < 48 or code > 57:
416 number = getKeyNumber(key)
419 for x in self.limits:
420 block_len.append(len(str(x[1])))
422 total_len = sum(block_len)
426 block_len_total = [0, ]
428 pos += block_len[blocknumber]
429 block_len_total.append(pos)
430 if pos - 1 >= self.marked_pos:
435 # length of numberblock
436 number_len = len(str(self.limits[blocknumber][1]))
438 # position in the block
439 posinblock = self.marked_pos - block_len_total[blocknumber]
441 oldvalue = self._value[blocknumber]
442 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
443 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
445 self._value[blocknumber] = newvalue
453 mPos = self.marked_pos
455 for i in self._value:
456 if len(value): #fixme no heading separator possible
457 value += self.seperator
458 if mPos >= len(value) - 1:
461 if self.censor_char == "":
462 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
464 value += (self.censor_char * len(str(self.limits[num][1])))
469 (value, mPos) = self.genText()
472 def getMulti(self, selected):
473 (value, mPos) = self.genText()
474 # only mark cursor when we are selected
475 # (this code is heavily ink optimized!)
477 return ("mtext"[1-selected:], value, [mPos])
479 return ("text", value)
481 def tostring(self, val):
482 return self.seperator.join([self.saveSingle(x) for x in val])
484 def saveSingle(self, v):
487 def fromstring(self, value):
488 return [int(x) for x in value.split(self.seperator)]
490 class ConfigIP(ConfigSequence):
491 def __init__(self, default):
492 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
494 def getHTML(self, id):
495 # we definitely don't want leading zeros
496 return '.'.join(["%d" % d for d in self.value])
498 class ConfigMAC(ConfigSequence):
499 def __init__(self, default):
500 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
502 class ConfigPosition(ConfigSequence):
503 def __init__(self, default, args):
504 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
506 class ConfigClock(ConfigSequence):
507 def __init__(self, default):
509 t = time.localtime(default)
510 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = [t.tm_hour, t.tm_min])
512 class ConfigInteger(ConfigSequence):
513 def __init__(self, default, limits = (0, 10000000000)):
514 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
516 # you need to override this to do input validation
517 def setValue(self, value):
518 self._value = [value]
522 return self._value[0]
524 value = property(getValue, setValue)
526 def fromstring(self, value):
529 def tostring(self, value):
532 class ConfigPIN(ConfigInteger):
533 def __init__(self, default, len = 4, censor = ""):
534 assert isinstance(default, int), "ConfigPIN default must be an integer"
537 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = default)
543 class ConfigFloat(ConfigSequence):
544 def __init__(self, default, limits):
545 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
548 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
550 float = property(getFloat)
552 # an editable text...
553 class ConfigText(ConfigElement, NumericalTextInput):
554 def __init__(self, default = "", fixed_size = True, visible_width = False):
555 ConfigElement.__init__(self)
556 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
559 self.allmarked = (default != "")
560 self.fixed_size = fixed_size
561 self.visible_width = visible_width
563 self.overwrite = fixed_size
564 self.help_window = None
565 self.value = self.default = default
567 def validateMarker(self):
569 if self.marked_pos > len(self.text)-1:
570 self.marked_pos = len(self.text)-1
572 if self.marked_pos > len(self.text):
573 self.marked_pos = len(self.text)
574 if self.marked_pos < 0:
576 if self.visible_width:
577 if self.marked_pos < self.offset:
578 self.offset = self.marked_pos
579 if self.marked_pos >= self.offset + self.visible_width:
580 if self.marked_pos == len(self.text):
581 self.offset = self.marked_pos - self.visible_width
583 self.offset = self.marked_pos - self.visible_width + 1
584 if self.offset > 0 and self.offset + self.visible_width > len(self.text):
585 self.offset = max(0, len(self.text) - self.visible_width)
587 def insertChar(self, ch, pos, owr):
588 if owr or self.overwrite:
589 self.text = self.text[0:pos] + ch + self.text[pos + 1:]
590 elif self.fixed_size:
591 self.text = self.text[0:pos] + ch + self.text[pos:-1]
593 self.text = self.text[0:pos] + ch + self.text[pos:]
595 def deleteChar(self, pos):
596 if not self.fixed_size:
597 self.text = self.text[0:pos] + self.text[pos + 1:]
599 self.text = self.text[0:pos] + " " + self.text[pos + 1:]
601 self.text = self.text[0:pos] + self.text[pos + 1:] + " "
603 def deleteAllChars(self):
605 self.text = " " * len(self.text)
610 def handleKey(self, key):
611 # this will no change anything on the value itself
612 # so we can handle it here in gui element
613 if key == KEY_DELETE:
616 self.deleteAllChars()
617 self.allmarked = False
619 self.deleteChar(self.marked_pos)
620 if self.fixed_size and self.overwrite:
622 elif key == KEY_BACKSPACE:
625 self.deleteAllChars()
626 self.allmarked = False
627 elif self.marked_pos > 0:
628 self.deleteChar(self.marked_pos-1)
629 if not self.fixed_size and self.offset > 0:
632 elif key == KEY_LEFT:
635 self.marked_pos = len(self.text)
636 self.allmarked = False
639 elif key == KEY_RIGHT:
643 self.allmarked = False
646 elif key == KEY_HOME:
648 self.allmarked = False
652 self.allmarked = False
653 self.marked_pos = len(self.text)
654 elif key == KEY_TOGGLEOW:
656 self.overwrite = not self.overwrite
657 elif key == KEY_ASCII:
659 newChar = unichr(getPrevAsciiCode())
661 self.deleteAllChars()
662 self.allmarked = False
663 self.insertChar(newChar, self.marked_pos, False)
665 elif key in KEY_NUMBERS:
666 owr = self.lastKey == getKeyNumber(key)
667 newChar = self.getKey(getKeyNumber(key))
669 self.deleteAllChars()
670 self.allmarked = False
671 self.insertChar(newChar, self.marked_pos, owr)
672 elif key == KEY_TIMEOUT:
675 self.help_window.update(self)
679 self.help_window.update(self)
680 self.validateMarker()
685 self.validateMarker()
689 return self.text.encode("utf-8")
691 def setValue(self, val):
693 self.text = val.decode("utf-8")
694 except UnicodeDecodeError:
698 value = property(getValue, setValue)
699 _value = property(getValue, setValue)
704 def getMulti(self, selected):
705 if self.visible_width:
707 mark = range(0, min(self.visible_width, len(self.text)))
709 mark = [self.marked_pos-self.offset]
710 return ("mtext"[1-selected:], self.text[self.offset:self.offset+self.visible_width].encode("utf-8")+" ", mark)
713 mark = range(0, len(self.text))
715 mark = [self.marked_pos]
716 return ("mtext"[1-selected:], self.value+" ", mark)
718 def onSelect(self, session):
719 self.allmarked = (self.value != "")
720 if session is not None:
721 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
722 self.help_window = session.instantiateDialog(NumericalTextInputHelpDialog, self)
723 self.help_window.show()
725 def onDeselect(self, session):
729 session.deleteDialog(self.help_window)
730 self.help_window = None
732 def getHTML(self, id):
733 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
735 def unsafeAssign(self, value):
736 self.value = str(value)
739 class ConfigSlider(ConfigElement):
740 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
741 ConfigElement.__init__(self)
742 self.value = self.default = default
745 self.increment = increment
747 def checkValues(self):
748 if self.value < self.min:
749 self.value = self.min
751 if self.value > self.max:
752 self.value = self.max
754 def handleKey(self, key):
756 self.value -= self.increment
757 elif key == KEY_RIGHT:
758 self.value += self.increment
759 elif key == KEY_HOME:
760 self.value = self.min
762 self.value = self.max
770 return "%d / %d" % (self.value, self.max)
772 def getMulti(self, selected):
774 return ("slider", self.value, self.max)
776 def fromstring(self, value):
779 # a satlist. in fact, it's a ConfigSelection.
780 class ConfigSatlist(ConfigSelection):
781 def __init__(self, list, default = None):
782 if default is not None:
783 default = str(default)
784 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc, flags) in list], default = default)
786 def getOrbitalPosition(self):
789 return int(self.value)
791 orbital_position = property(getOrbitalPosition)
794 class ConfigNothing(ConfigSelection):
796 ConfigSelection.__init__(self, choices = [""])
798 # until here, 'saved_value' always had to be a *string*.
799 # now, in ConfigSubsection, and only there, saved_value
800 # is a dict, essentially forming a tree.
802 # config.foo.bar=True
803 # config.foobar=False
806 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
810 class ConfigSubsectionContent(object):
813 # we store a backup of the loaded configuration
814 # data in self.stored_values, to be able to deploy
815 # them when a new config element will be added,
816 # so non-default values are instantly available
818 # A list, for example:
819 # config.dipswitches = ConfigSubList()
820 # config.dipswitches.append(ConfigYesNo())
821 # config.dipswitches.append(ConfigYesNo())
822 # config.dipswitches.append(ConfigYesNo())
823 class ConfigSubList(list, object):
825 object.__init__(self)
827 self.stored_values = {}
837 def getSavedValue(self):
839 for i in range(len(self)):
840 sv = self[i].saved_value
845 def setSavedValue(self, values):
846 self.stored_values = dict(values)
847 for (key, val) in self.stored_values.items():
848 if int(key) < len(self):
849 self[int(key)].saved_value = val
851 saved_value = property(getSavedValue, setSavedValue)
853 def append(self, item):
855 list.append(self, item)
856 if i in self.stored_values:
857 item.saved_value = self.stored_values[i]
862 for index in range(len(self)):
863 res[str(index)] = self[index]
866 # same as ConfigSubList, just as a dictionary.
867 # care must be taken that the 'key' has a proper
868 # str() method, because it will be used in the config
870 class ConfigSubDict(dict, object):
872 object.__init__(self)
874 self.stored_values = {}
877 for x in self.values():
881 for x in self.values():
884 def getSavedValue(self):
886 for (key, val) in self.items():
887 if val.saved_value is not None:
888 res[str(key)] = val.saved_value
891 def setSavedValue(self, values):
892 self.stored_values = dict(values)
893 for (key, val) in self.items():
894 if str(key) in self.stored_values:
895 val = self.stored_values[str(key)]
897 saved_value = property(getSavedValue, setSavedValue)
899 def __setitem__(self, key, item):
900 dict.__setitem__(self, key, item)
901 if str(key) in self.stored_values:
902 item.saved_value = self.stored_values[str(key)]
908 # Like the classes above, just with a more "native"
911 # some evil stuff must be done to allow instant
912 # loading of added elements. this is why this class
915 # we need the 'content' because we overwrite
917 # If you don't understand this, try adding
918 # __setattr__ to a usual exisiting class and you will.
919 class ConfigSubsection(object):
921 object.__init__(self)
922 self.__dict__["content"] = ConfigSubsectionContent()
923 self.content.items = { }
924 self.content.stored_values = { }
926 def __setattr__(self, name, value):
927 if name == "saved_value":
928 return self.setSavedValue(value)
929 assert isinstance(value, ConfigSubsection) or isinstance(value, ConfigElement) or isinstance(value, ConfigSubList) or isinstance(value, ConfigSubDict), "ConfigSubsections can only store ConfigSubsections, ConfigSubLists, ConfigSubDicts or ConfigElements"
930 self.content.items[name] = value
931 if name in self.content.stored_values:
932 #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
933 value.saved_value = self.content.stored_values[name]
936 def __getattr__(self, name):
937 return self.content.items[name]
939 def getSavedValue(self):
940 res = self.content.stored_values
941 for (key, val) in self.content.items.items():
942 if val.saved_value is not None:
943 res[key] = val.saved_value
949 def setSavedValue(self, values):
950 values = dict(values)
952 self.content.stored_values = values
954 for (key, val) in self.content.items.items():
956 val.setSavedValue(values[key])
958 saved_value = property(getSavedValue, setSavedValue)
961 for x in self.content.items.values():
965 for x in self.content.items.values():
969 return self.content.items
971 # the root config object, which also can "pickle" (=serialize)
972 # down the whole config tree.
974 # we try to keep non-existing config entries, to apply them whenever
975 # a new config entry is added to a subsection
976 # also, non-existing config entries will be saved, so they won't be
977 # lost when a config entry disappears.
978 class Config(ConfigSubsection):
980 ConfigSubsection.__init__(self)
982 def pickle_this(self, prefix, topickle, result):
983 for (key, val) in topickle.items():
984 name = prefix + "." + key
986 if isinstance(val, dict):
987 self.pickle_this(name, val, result)
988 elif isinstance(val, tuple):
989 result.append(name + "=" + val[0]) # + " ; " + val[1])
991 result.append(name + "=" + val)
995 self.pickle_this("config", self.saved_value, result)
996 return '\n'.join(result) + "\n"
998 def unpickle(self, lines):
1001 if not len(l) or l[0] == '#':
1005 val = l[n+1:].strip()
1007 names = l[:n].split('.')
1008 # if val.find(' ') != -1:
1009 # val = val[:val.find(' ')]
1013 for n in names[:-1]:
1014 base = base.setdefault(n, {})
1016 base[names[-1]] = val
1018 # we inherit from ConfigSubsection, so ...
1019 #object.__setattr__(self, "saved_value", tree["config"])
1020 if "config" in tree:
1021 self.setSavedValue(tree["config"])
1023 def saveToFile(self, filename):
1024 f = open(filename, "w")
1025 f.write(self.pickle())
1028 def loadFromFile(self, filename):
1029 f = open(filename, "r")
1030 self.unpickle(f.readlines())
1034 config.misc = ConfigSubsection()
1037 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "settings")
1041 config.loadFromFile(self.CONFIG_FILE)
1043 print "unable to load config (%s), assuming defaults..." % str(e)
1047 config.saveToFile(self.CONFIG_FILE)
1049 def __resolveValue(self, pickles, cmap):
1050 if cmap.has_key(pickles[0]):
1051 if len(pickles) > 1:
1052 return self.__resolveValue(pickles[1:], cmap[pickles[0]].dict())
1054 return str(cmap[pickles[0]].value)
1057 def getResolvedKey(self, key):
1058 names = key.split('.')
1060 if names[0] == "config":
1061 ret=self.__resolveValue(names[1:], config.content.items)
1062 if ret and len(ret):
1064 print "getResolvedKey", key, "failed !! (Typo??)"
1067 def NoSave(element):
1068 element.disableSave()
1071 configfile = ConfigFile()
1075 def getConfigListEntry(*args):
1076 assert len(args) > 1, "getConfigListEntry needs a minimum of two arguments (descr, configElement)"
1082 #config.bla = ConfigSubsection()
1083 #config.bla.test = ConfigYesNo()
1084 #config.nim = ConfigSubList()
1085 #config.nim.append(ConfigSubsection())
1086 #config.nim[0].bla = ConfigYesNo()
1087 #config.nim.append(ConfigSubsection())
1088 #config.nim[1].bla = ConfigYesNo()
1089 #config.nim[1].blub = ConfigYesNo()
1090 #config.arg = ConfigSubDict()
1091 #config.arg["Hello"] = ConfigYesNo()
1093 #config.arg["Hello"].handleKey(KEY_RIGHT)
1094 #config.arg["Hello"].handleKey(KEY_RIGHT)
1096 ##config.saved_value
1100 #print config.pickle()