2 from enigma import getPrevAsciiCode
3 from Tools.NumericalTextInput import NumericalTextInput
4 from Tools.Directories import resolveFilename, SCOPE_CONFIG
5 from Components.Harddisk import harddiskmanager
9 # ConfigElement, the base class of all ConfigElements.
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
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)
29 class ConfigElement(object):
33 self.saved_value = None
34 self.save_disabled = False
38 # you need to override this to do input validation
39 def setValue(self, value):
46 value = property(getValue, setValue)
48 # you need to override this if self.value is not a string
49 def fromstring(self, value):
52 # you can overide this for fancy default handling
54 if self.saved_value is None:
55 self.value = self.default
57 self.value = self.fromstring(self.saved_value)
59 def tostring(self, value):
62 # you need to override this if str(self.value) doesn't work
64 if self.save_disabled or self.value == self.default:
65 self.saved_value = None
67 self.saved_value = self.tostring(self.value)
73 if self.saved_value is None and self.value == self.default:
75 return self.tostring(self.value) != self.saved_value
78 for x in self.notifiers:
81 def addNotifier(self, notifier, initial_call = True):
82 assert callable(notifier), "notifiers must be callable"
83 self.notifiers.append(notifier)
86 # do we want to call the notifier
87 # - at all when adding it? (yes, though optional)
88 # - when the default is active? (yes)
89 # - when no value *yet* has been set,
90 # because no config has ever been read (currently yes)
91 # (though that's not so easy to detect.
92 # the entry could just be new.)
96 def disableSave(self):
97 self.save_disabled = True
99 def __call__(self, selected):
100 return self.getMulti(selected)
102 def onSelect(self, session):
105 def onDeselect(self, session):
118 KEY_NUMBERS = range(12, 12+10)
122 def getKeyNumber(key):
123 assert key in KEY_NUMBERS
127 # ConfigSelection is a "one of.."-type.
128 # it has the "choices", usually a list, which contains
129 # (id, desc)-tuples (or just only the ids, in case the id
130 # will be used as description)
132 # all ids MUST be plain strings.
134 class ConfigSelection(ConfigElement):
135 def __init__(self, choices, default = None):
136 ConfigElement.__init__(self)
138 self.setChoices(choices, default)
140 def setChoices(self, choices, default = None):
142 self.description = {}
144 if isinstance(choices, list):
146 if isinstance(x, tuple):
147 self.choices.append(x[0])
148 self.description[x[0]] = x[1]
150 self.choices.append(x)
151 self.description[x] = x
152 elif isinstance(choices, dict):
153 for (key, val) in choices.items():
154 self.choices.append(key)
155 self.description[key] = val
157 assert False, "ConfigSelection choices must be dict or list!"
159 #assert len(self.choices), "you can't have an empty configselection"
160 if len(self.choices) == 0:
162 self.description[""] = ""
165 default = self.choices[0]
167 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
168 for x in self.choices:
169 assert isinstance(x, str), "ConfigSelection choices must be strings"
171 self.default = default
173 if self.value == None or not self.value in self.choices:
176 def setValue(self, value):
177 if value in self.choices:
180 self._value = self.default
184 def tostring(self, val):
190 def setCurrentText(self, text):
191 i = self.choices.index(self.value)
192 del self.description[self.choices[i]]
193 self.choices[i] = text
194 self.description[text] = text
197 value = property(getValue, setValue)
200 return self.choices.index(self.value)
202 index = property(getIndex)
205 def handleKey(self, key):
206 nchoices = len(self.choices)
207 i = self.choices.index(self.value)
209 self.value = self.choices[(i + nchoices - 1) % nchoices]
210 elif key == KEY_RIGHT:
211 self.value = self.choices[(i + 1) % nchoices]
212 elif key == KEY_HOME:
213 self.value = self.choices[0]
215 self.value = self.choices[nchoices - 1]
218 descr = self.description[self.value]
223 def getMulti(self, selected):
224 descr = self.description[self.value]
226 return ("text", _(descr))
227 return ("text", descr)
230 def getHTML(self, id):
232 for v in self.choices:
234 checked = 'checked="checked" '
237 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
240 def unsafeAssign(self, value):
241 # setValue does check if value is in choices. This is safe enough.
246 # several customized versions exist for different
249 class ConfigBoolean(ConfigElement):
250 def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
251 ConfigElement.__init__(self)
252 self.descriptions = descriptions
253 self.value = self.default = default
254 def handleKey(self, key):
255 if key in [KEY_LEFT, KEY_RIGHT]:
256 self.value = not self.value
257 elif key == KEY_HOME:
263 descr = self.descriptions[self.value]
268 def getMulti(self, selected):
269 descr = self.descriptions[self.value]
271 return ("text", _(descr))
272 return ("text", descr)
274 def tostring(self, value):
280 def fromstring(self, val):
286 def getHTML(self, id):
288 checked = ' checked="checked"'
291 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
293 # this is FLAWED. and must be fixed.
294 def unsafeAssign(self, value):
300 class ConfigYesNo(ConfigBoolean):
301 def __init__(self, default = False):
302 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
304 class ConfigOnOff(ConfigBoolean):
305 def __init__(self, default = False):
306 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
308 class ConfigEnableDisable(ConfigBoolean):
309 def __init__(self, default = False):
310 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
312 class ConfigDateTime(ConfigElement):
313 def __init__(self, default, formatstring, increment = 86400):
314 ConfigElement.__init__(self)
315 self.increment = increment
316 self.formatstring = formatstring
317 self.value = self.default = int(default)
319 def handleKey(self, key):
321 self.value = self.value - self.increment
322 elif key == KEY_RIGHT:
323 self.value = self.value + self.increment
324 elif key == KEY_HOME or key == KEY_END:
325 self.value = self.default
328 return time.strftime(self.formatstring, time.localtime(self.value))
330 def getMulti(self, selected):
331 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
333 def fromstring(self, val):
336 # *THE* mighty config element class
338 # allows you to store/edit a sequence of values.
339 # can be used for IP-addresses, dates, plain integers, ...
340 # several helper exist to ease this up a bit.
342 class ConfigSequence(ConfigElement):
343 def __init__(self, seperator, limits, censor_char = "", default = None):
344 ConfigElement.__init__(self)
345 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
346 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
347 #assert isinstance(default, list), "default must be a list"
348 #assert isinstance(default[0], int), "list must contain numbers"
349 #assert len(default) == len(limits), "length must match"
352 self.seperator = seperator
354 self.censor_char = censor_char
356 self.default = default
357 self.value = copy.copy(default)
359 self.endNotifier = []
364 for i in self._value:
365 max_pos += len(str(self.limits[num][1]))
367 if self._value[num] < self.limits[num][0]:
368 self._value[num] = self.limits[num][0]
370 if self._value[num] > self.limits[num][1]:
371 self._value[num] = self.limits[num][1]
375 if self.marked_pos >= max_pos:
376 for x in self.endNotifier:
378 self.marked_pos = max_pos - 1
380 if self.marked_pos < 0:
383 def validatePos(self):
384 if self.marked_pos < 0:
387 total_len = sum([len(str(x[1])) for x in self.limits])
389 if self.marked_pos >= total_len:
390 self.marked_pos = total_len - 1
392 def addEndNotifier(self, notifier):
393 self.endNotifier.append(notifier)
395 def handleKey(self, key):
411 for i in self._value:
412 max_pos += len(str(self.limits[num][1]))
414 self.marked_pos = max_pos - 1
417 if key in KEY_NUMBERS or key == KEY_ASCII:
419 code = getPrevAsciiCode()
420 if code < 48 or code > 57:
424 number = getKeyNumber(key)
427 for x in self.limits:
428 block_len.append(len(str(x[1])))
430 total_len = sum(block_len)
434 block_len_total = [0, ]
436 pos += block_len[blocknumber]
437 block_len_total.append(pos)
438 if pos - 1 >= self.marked_pos:
443 # length of numberblock
444 number_len = len(str(self.limits[blocknumber][1]))
446 # position in the block
447 posinblock = self.marked_pos - block_len_total[blocknumber]
449 oldvalue = self._value[blocknumber]
450 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
451 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
453 self._value[blocknumber] = newvalue
461 mPos = self.marked_pos
463 for i in self._value:
464 if len(value): #fixme no heading separator possible
465 value += self.seperator
466 if mPos >= len(value) - 1:
469 if self.censor_char == "":
470 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
472 value += (self.censor_char * len(str(self.limits[num][1])))
477 (value, mPos) = self.genText()
480 def getMulti(self, selected):
481 (value, mPos) = self.genText()
482 # only mark cursor when we are selected
483 # (this code is heavily ink optimized!)
485 return ("mtext"[1-selected:], value, [mPos])
487 return ("text", value)
489 def tostring(self, val):
490 return self.seperator.join([self.saveSingle(x) for x in val])
492 def saveSingle(self, v):
495 def fromstring(self, value):
496 return [int(x) for x in value.split(self.seperator)]
498 class ConfigIP(ConfigSequence):
499 def __init__(self, default):
500 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
502 def getHTML(self, id):
503 # we definitely don't want leading zeros
504 return '.'.join(["%d" % d for d in self.value])
506 class ConfigMAC(ConfigSequence):
507 def __init__(self, default):
508 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
510 class ConfigPosition(ConfigSequence):
511 def __init__(self, default, args):
512 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
514 class ConfigClock(ConfigSequence):
515 def __init__(self, default):
517 t = time.localtime(default)
518 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = [t.tm_hour, t.tm_min])
520 class ConfigInteger(ConfigSequence):
521 def __init__(self, default, limits = (0, 9999999999)):
522 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
524 # you need to override this to do input validation
525 def setValue(self, value):
526 self._value = [value]
530 return self._value[0]
532 value = property(getValue, setValue)
534 def fromstring(self, value):
537 def tostring(self, value):
540 class ConfigPIN(ConfigInteger):
541 def __init__(self, default, len = 4, censor = ""):
542 assert isinstance(default, int), "ConfigPIN default must be an integer"
545 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = default)
551 class ConfigFloat(ConfigSequence):
552 def __init__(self, default, limits):
553 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
556 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
558 float = property(getFloat)
560 # an editable text...
561 class ConfigText(ConfigElement, NumericalTextInput):
562 def __init__(self, default = "", fixed_size = True, visible_width = False):
563 ConfigElement.__init__(self)
564 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
567 self.allmarked = (default != "")
568 self.fixed_size = fixed_size
569 self.visible_width = visible_width
571 self.overwrite = fixed_size
572 self.help_window = None
573 self.value = self.default = default
575 def validateMarker(self):
577 if self.marked_pos > len(self.text)-1:
578 self.marked_pos = len(self.text)-1
580 if self.marked_pos > len(self.text):
581 self.marked_pos = len(self.text)
582 if self.marked_pos < 0:
584 if self.visible_width:
585 if self.marked_pos < self.offset:
586 self.offset = self.marked_pos
587 if self.marked_pos >= self.offset + self.visible_width:
588 if self.marked_pos == len(self.text):
589 self.offset = self.marked_pos - self.visible_width
591 self.offset = self.marked_pos - self.visible_width + 1
592 if self.offset > 0 and self.offset + self.visible_width > len(self.text):
593 self.offset = max(0, len(self.text) - self.visible_width)
595 def insertChar(self, ch, pos, owr):
596 if owr or self.overwrite:
597 self.text = self.text[0:pos] + ch + self.text[pos + 1:]
598 elif self.fixed_size:
599 self.text = self.text[0:pos] + ch + self.text[pos:-1]
601 self.text = self.text[0:pos] + ch + self.text[pos:]
603 def deleteChar(self, pos):
604 if not self.fixed_size:
605 self.text = self.text[0:pos] + self.text[pos + 1:]
607 self.text = self.text[0:pos] + " " + self.text[pos + 1:]
609 self.text = self.text[0:pos] + self.text[pos + 1:] + " "
611 def deleteAllChars(self):
613 self.text = " " * len(self.text)
618 def handleKey(self, key):
619 # this will no change anything on the value itself
620 # so we can handle it here in gui element
621 if key == KEY_DELETE:
624 self.deleteAllChars()
625 self.allmarked = False
627 self.deleteChar(self.marked_pos)
628 if self.fixed_size and self.overwrite:
630 elif key == KEY_BACKSPACE:
633 self.deleteAllChars()
634 self.allmarked = False
635 elif self.marked_pos > 0:
636 self.deleteChar(self.marked_pos-1)
637 if not self.fixed_size and self.offset > 0:
640 elif key == KEY_LEFT:
643 self.marked_pos = len(self.text)
644 self.allmarked = False
647 elif key == KEY_RIGHT:
651 self.allmarked = False
654 elif key == KEY_HOME:
656 self.allmarked = False
660 self.allmarked = False
661 self.marked_pos = len(self.text)
662 elif key == KEY_TOGGLEOW:
664 self.overwrite = not self.overwrite
665 elif key == KEY_ASCII:
667 newChar = unichr(getPrevAsciiCode())
669 self.deleteAllChars()
670 self.allmarked = False
671 self.insertChar(newChar, self.marked_pos, False)
673 elif key in KEY_NUMBERS:
674 owr = self.lastKey == getKeyNumber(key)
675 newChar = self.getKey(getKeyNumber(key))
677 self.deleteAllChars()
678 self.allmarked = False
679 self.insertChar(newChar, self.marked_pos, owr)
680 elif key == KEY_TIMEOUT:
683 self.help_window.update(self)
687 self.help_window.update(self)
688 self.validateMarker()
693 self.validateMarker()
697 return self.text.encode("utf-8")
699 def setValue(self, val):
701 self.text = val.decode("utf-8")
702 except UnicodeDecodeError:
706 value = property(getValue, setValue)
707 _value = property(getValue, setValue)
710 return self.text.encode("utf-8")
712 def getMulti(self, selected):
713 if self.visible_width:
715 mark = range(0, min(self.visible_width, len(self.text)))
717 mark = [self.marked_pos-self.offset]
718 return ("mtext"[1-selected:], self.text[self.offset:self.offset+self.visible_width].encode("utf-8")+" ", mark)
721 mark = range(0, len(self.text))
723 mark = [self.marked_pos]
724 return ("mtext"[1-selected:], self.text.encode("utf-8")+" ", mark)
726 def onSelect(self, session):
727 self.allmarked = (self.value != "")
728 if session is not None:
729 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
730 self.help_window = session.instantiateDialog(NumericalTextInputHelpDialog, self)
731 self.help_window.show()
733 def onDeselect(self, session):
737 session.deleteDialog(self.help_window)
738 self.help_window = None
740 def getHTML(self, id):
741 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
743 def unsafeAssign(self, value):
744 self.value = str(value)
746 class ConfigNumber(ConfigText):
747 def __init__(self, default = 0):
748 ConfigText.__init__(self, str(default), fixed_size = False)
751 return int(self.text)
753 def setValue(self, val):
756 value = property(getValue, setValue)
757 _value = property(getValue, setValue)
760 pos = len(self.text) - self.marked_pos
761 self.text = self.text.lstrip("0")
764 if pos > len(self.text):
767 self.marked_pos = len(self.text) - pos
769 def handleKey(self, key):
770 if key in KEY_NUMBERS or key == KEY_ASCII:
772 ascii = getPrevAsciiCode()
773 if not (48 <= ascii <= 57):
776 ascii = getKeyNumber(key) + 48
777 newChar = unichr(ascii)
779 self.deleteAllChars()
780 self.allmarked = False
781 self.insertChar(newChar, self.marked_pos, False)
784 ConfigText.handleKey(self, key)
787 def onSelect(self, session):
788 self.allmarked = (self.value != "")
790 def onDeselect(self, session):
795 class ConfigSlider(ConfigElement):
796 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
797 ConfigElement.__init__(self)
798 self.value = self.default = default
801 self.increment = increment
803 def checkValues(self):
804 if self.value < self.min:
805 self.value = self.min
807 if self.value > self.max:
808 self.value = self.max
810 def handleKey(self, key):
812 self.value -= self.increment
813 elif key == KEY_RIGHT:
814 self.value += self.increment
815 elif key == KEY_HOME:
816 self.value = self.min
818 self.value = self.max
826 return "%d / %d" % (self.value, self.max)
828 def getMulti(self, selected):
830 return ("slider", self.value, self.max)
832 def fromstring(self, value):
835 # a satlist. in fact, it's a ConfigSelection.
836 class ConfigSatlist(ConfigSelection):
837 def __init__(self, list, default = None):
838 if default is not None:
839 default = str(default)
840 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc, flags) in list], default = default)
842 def getOrbitalPosition(self):
845 return int(self.value)
847 orbital_position = property(getOrbitalPosition)
849 class ConfigSet(ConfigElement):
850 def __init__(self, choices, default = []):
851 ConfigElement.__init__(self)
853 self.description = {}
854 if isinstance(choices, list):
857 if isinstance(x, tuple):
858 self.choices.append(x[0])
859 self.description[x[0]] = str(x[1])
861 self.choices.append(x)
862 self.description[x] = str(x)
864 assert False, "ConfigSet choices must be a list!"
865 if len(self.choices) == 0:
867 self.description[""] = ""
872 self.default = default
873 self.value = default+[]
875 def toggleChoice(self, choice):
876 if choice in self.value:
877 self.value.remove(choice)
879 self.value.append(choice)
882 def handleKey(self, key):
883 if key in KEY_NUMBERS + [KEY_DELETE, KEY_BACKSPACE]:
885 self.toggleChoice(self.choices[self.pos])
886 elif key == KEY_LEFT:
889 self.pos = len(self.choices)-1
890 elif key == KEY_RIGHT:
892 if self.pos >= len(self.choices):
894 elif key in [KEY_HOME, KEY_END]:
897 def genString(self, lst):
900 res += self.description[x]+" "
904 return self.genString(self.value)
906 def getMulti(self, selected):
907 if not selected or self.pos == -1:
908 return ("text", self.genString(self.value))
911 ch = self.choices[self.pos]
912 mem = ch in self.value
917 val1 = self.genString(tmp[:ind])
918 val2 = " "+self.genString(tmp[ind+1:])
920 chstr = " "+self.description[ch]+" "
922 chstr = "("+self.description[ch]+")"
923 return ("mtext", val1+chstr+val2, range(len(val1),len(val1)+len(chstr)))
925 def onDeselect(self, session):
929 def tostring(self, value):
932 def fromstring(self, val):
935 class ConfigLocations(ConfigElement):
936 def __init__(self, default = [], visible_width = False):
937 ConfigElement.__init__(self)
938 self.visible_width = visible_width
940 self.default = default
942 self.mountpoints = []
943 harddiskmanager.on_partition_list_change.append(self.mountpointsChanged)
945 def setValue(self, value):
946 loc = [x[0] for x in self.locations if x[3]]
947 add = [x for x in value if not x in loc]
948 diff = add + [x for x in loc if not x in value]
949 self.locations = [x for x in self.locations if not x[0] in diff] + [[x, self.getMountpoint(x), True, True] for x in add]
950 self.locations.sort(key = lambda x: x[0])
954 self.checkChangedMountpoints()
955 for x in self.locations:
957 return [x[0] for x in self.locations if x[3]]
959 value = property(getValue, setValue)
961 def tostring(self, value):
964 def fromstring(self, val):
968 if self.saved_value is None:
971 tmp = self.fromstring(self.saved_value)
972 self.locations = [[x, None, False, False] for x in tmp]
973 self.refreshMountpoints()
974 for x in self.locations:
975 if os.path.exists(x[0]):
976 x[1] = self.getMountpoint(x[0])
980 if self.save_disabled or self.locations == []:
981 self.saved_value = None
983 self.saved_value = self.tostring([x[0] for x in self.locations])
986 if self.saved_value is None and self.locations == []:
988 return self.tostring([x[0] for x in self.locations]) != self.saved_value
990 def mountpointsChanged(self, action, dev):
991 print "Mounts changed: ", action, dev
992 mp = dev.mountpoint+"/"
995 elif action == "remove":
996 self.removedMount(mp)
997 self.refreshMountpoints()
999 def addedMount(self, mp):
1000 for x in self.locations:
1003 elif x[1] == None and os.path.exists(x[0]):
1004 x[1] = self.getMountpoint(x[0])
1007 def removedMount(self, mp):
1008 for x in self.locations:
1012 def refreshMountpoints(self):
1013 self.mountpoints = [p.mountpoint + "/" for p in harddiskmanager.getMountedPartitions() if p.mountpoint != "/"]
1014 self.mountpoints.sort(key = lambda x: -len(x))
1016 def checkChangedMountpoints(self):
1017 oldmounts = self.mountpoints
1018 self.refreshMountpoints()
1019 if oldmounts == self.mountpoints:
1022 if not x in self.mountpoints:
1023 self.removedMount(x)
1024 for x in self.mountpoints:
1025 if not x in oldmounts:
1028 def getMountpoint(self, file):
1029 file = os.path.realpath(file)+"/"
1030 for m in self.mountpoints:
1031 if file.startswith(m):
1035 def handleKey(self, key):
1039 self.pos = len(self.value)-1
1040 elif key == KEY_RIGHT:
1042 if self.pos >= len(self.value):
1044 elif key in [KEY_HOME, KEY_END]:
1048 return " ".join(self.value)
1050 def getMulti(self, selected):
1052 valstr = " ".join(self.value)
1053 if self.visible_width and len(valstr) > self.visible_width:
1054 return ("text", valstr[0:self.visible_width])
1056 return ("text", valstr)
1062 for val in self.value:
1065 valstr += str(val)+" "
1069 if self.visible_width and len(valstr) > self.visible_width:
1070 if ind1+1 < self.visible_width/2:
1073 off = min(ind1+1-self.visible_width/2, len(valstr)-self.visible_width)
1074 return ("mtext", valstr[off:off+self.visible_width], range(ind1-off,ind2-off))
1076 return ("mtext", valstr, range(ind1,ind2))
1078 def onDeselect(self, session):
1082 class ConfigNothing(ConfigSelection):
1084 ConfigSelection.__init__(self, choices = [""])
1086 # until here, 'saved_value' always had to be a *string*.
1087 # now, in ConfigSubsection, and only there, saved_value
1088 # is a dict, essentially forming a tree.
1090 # config.foo.bar=True
1091 # config.foobar=False
1094 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
1098 class ConfigSubsectionContent(object):
1101 # we store a backup of the loaded configuration
1102 # data in self.stored_values, to be able to deploy
1103 # them when a new config element will be added,
1104 # so non-default values are instantly available
1106 # A list, for example:
1107 # config.dipswitches = ConfigSubList()
1108 # config.dipswitches.append(ConfigYesNo())
1109 # config.dipswitches.append(ConfigYesNo())
1110 # config.dipswitches.append(ConfigYesNo())
1111 class ConfigSubList(list, object):
1113 object.__init__(self)
1115 self.stored_values = {}
1125 def getSavedValue(self):
1127 for i in range(len(self)):
1128 sv = self[i].saved_value
1133 def setSavedValue(self, values):
1134 self.stored_values = dict(values)
1135 for (key, val) in self.stored_values.items():
1136 if int(key) < len(self):
1137 self[int(key)].saved_value = val
1139 saved_value = property(getSavedValue, setSavedValue)
1141 def append(self, item):
1143 list.append(self, item)
1144 if i in self.stored_values:
1145 item.saved_value = self.stored_values[i]
1150 for index in range(len(self)):
1151 res[str(index)] = self[index]
1154 # same as ConfigSubList, just as a dictionary.
1155 # care must be taken that the 'key' has a proper
1156 # str() method, because it will be used in the config
1158 class ConfigSubDict(dict, object):
1160 object.__init__(self)
1162 self.stored_values = {}
1165 for x in self.values():
1169 for x in self.values():
1172 def getSavedValue(self):
1174 for (key, val) in self.items():
1175 if val.saved_value is not None:
1176 res[str(key)] = val.saved_value
1179 def setSavedValue(self, values):
1180 self.stored_values = dict(values)
1181 for (key, val) in self.items():
1182 if str(key) in self.stored_values:
1183 val = self.stored_values[str(key)]
1185 saved_value = property(getSavedValue, setSavedValue)
1187 def __setitem__(self, key, item):
1188 dict.__setitem__(self, key, item)
1189 if str(key) in self.stored_values:
1190 item.saved_value = self.stored_values[str(key)]
1196 # Like the classes above, just with a more "native"
1199 # some evil stuff must be done to allow instant
1200 # loading of added elements. this is why this class
1203 # we need the 'content' because we overwrite
1205 # If you don't understand this, try adding
1206 # __setattr__ to a usual exisiting class and you will.
1207 class ConfigSubsection(object):
1209 object.__init__(self)
1210 self.__dict__["content"] = ConfigSubsectionContent()
1211 self.content.items = { }
1212 self.content.stored_values = { }
1214 def __setattr__(self, name, value):
1215 if name == "saved_value":
1216 return self.setSavedValue(value)
1217 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"
1218 self.content.items[name] = value
1219 if name in self.content.stored_values:
1220 #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
1221 value.saved_value = self.content.stored_values[name]
1224 def __getattr__(self, name):
1225 return self.content.items[name]
1227 def getSavedValue(self):
1228 res = self.content.stored_values
1229 for (key, val) in self.content.items.items():
1230 if val.saved_value is not None:
1231 res[key] = val.saved_value
1237 def setSavedValue(self, values):
1238 values = dict(values)
1240 self.content.stored_values = values
1242 for (key, val) in self.content.items.items():
1244 val.saved_value = values[key]
1246 saved_value = property(getSavedValue, setSavedValue)
1249 for x in self.content.items.values():
1253 for x in self.content.items.values():
1257 return self.content.items
1259 # the root config object, which also can "pickle" (=serialize)
1260 # down the whole config tree.
1262 # we try to keep non-existing config entries, to apply them whenever
1263 # a new config entry is added to a subsection
1264 # also, non-existing config entries will be saved, so they won't be
1265 # lost when a config entry disappears.
1266 class Config(ConfigSubsection):
1268 ConfigSubsection.__init__(self)
1270 def pickle_this(self, prefix, topickle, result):
1271 for (key, val) in topickle.items():
1272 name = prefix + "." + key
1274 if isinstance(val, dict):
1275 self.pickle_this(name, val, result)
1276 elif isinstance(val, tuple):
1277 result.append(name + "=" + val[0]) # + " ; " + val[1])
1279 result.append(name + "=" + val)
1283 self.pickle_this("config", self.saved_value, result)
1284 return '\n'.join(result) + "\n"
1286 def unpickle(self, lines):
1289 if not len(l) or l[0] == '#':
1293 val = l[n+1:].strip()
1295 names = l[:n].split('.')
1296 # if val.find(' ') != -1:
1297 # val = val[:val.find(' ')]
1301 for n in names[:-1]:
1302 base = base.setdefault(n, {})
1304 base[names[-1]] = val
1306 # we inherit from ConfigSubsection, so ...
1307 #object.__setattr__(self, "saved_value", tree["config"])
1308 if "config" in tree:
1309 self.setSavedValue(tree["config"])
1311 def saveToFile(self, filename):
1312 f = open(filename, "w")
1313 f.write(self.pickle())
1316 def loadFromFile(self, filename):
1317 f = open(filename, "r")
1318 self.unpickle(f.readlines())
1322 config.misc = ConfigSubsection()
1325 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "settings")
1329 config.loadFromFile(self.CONFIG_FILE)
1331 print "unable to load config (%s), assuming defaults..." % str(e)
1335 config.saveToFile(self.CONFIG_FILE)
1337 def __resolveValue(self, pickles, cmap):
1338 if cmap.has_key(pickles[0]):
1339 if len(pickles) > 1:
1340 return self.__resolveValue(pickles[1:], cmap[pickles[0]].dict())
1342 return str(cmap[pickles[0]].value)
1345 def getResolvedKey(self, key):
1346 names = key.split('.')
1348 if names[0] == "config":
1349 ret=self.__resolveValue(names[1:], config.content.items)
1350 if ret and len(ret):
1352 print "getResolvedKey", key, "failed !! (Typo??)"
1355 def NoSave(element):
1356 element.disableSave()
1359 configfile = ConfigFile()
1363 def getConfigListEntry(*args):
1364 assert len(args) > 1, "getConfigListEntry needs a minimum of two arguments (descr, configElement)"
1370 #config.bla = ConfigSubsection()
1371 #config.bla.test = ConfigYesNo()
1372 #config.nim = ConfigSubList()
1373 #config.nim.append(ConfigSubsection())
1374 #config.nim[0].bla = ConfigYesNo()
1375 #config.nim.append(ConfigSubsection())
1376 #config.nim[1].bla = ConfigYesNo()
1377 #config.nim[1].blub = ConfigYesNo()
1378 #config.arg = ConfigSubDict()
1379 #config.arg["Hello"] = ConfigYesNo()
1381 #config.arg["Hello"].handleKey(KEY_RIGHT)
1382 #config.arg["Hello"].handleKey(KEY_RIGHT)
1384 ##config.saved_value
1388 #print config.pickle()