2 from Tools.NumericalTextInput import NumericalTextInput
3 from Tools.Directories import resolveFilename, SCOPE_CONFIG
7 # ConfigElement, the base class of all ConfigElements.
10 # value the current value, usefully encoded.
11 # usually a property which retrieves _value,
12 # and maybe does some reformatting
13 # _value the value as it's going to be saved in the configfile,
14 # though still in non-string form.
15 # this is the object which is actually worked on.
16 # default the initial value. If _value is equal to default,
17 # it will not be stored in the config file
18 # saved_value is a text representation of _value, stored in the config file
20 # and has (at least) the following methods:
21 # save() stores _value into saved_value,
22 # (or stores 'None' if it should not be stored)
23 # load() loads _value from saved_value, or loads
24 # the default if saved_value is 'None' (default)
27 class ConfigElement(object):
31 self.saved_value = None
32 self.save_disabled = False
36 # you need to override this to do input validation
37 def setValue(self, value):
44 value = property(getValue, setValue)
46 # you need to override this if self.value is not a string
47 def fromstring(self, value):
50 # you can overide this for fancy default handling
52 if self.saved_value is None:
53 self.value = self.default
55 self.value = self.fromstring(self.saved_value)
57 def tostring(self, value):
60 # you need to override this if str(self.value) doesn't work
62 if self.save_disabled or self.value == self.default:
63 self.saved_value = None
65 self.saved_value = self.tostring(self.value)
71 for x in self.notifiers:
74 def addNotifier(self, notifier, initial_call = True):
75 assert callable(notifier), "notifiers must be callable"
76 self.notifiers.append(notifier)
79 # do we want to call the notifier
80 # - at all when adding it? (yes, though optional)
81 # - when the default is active? (yes)
82 # - when no value *yet* has been set,
83 # because no config has ever been read (currently yes)
84 # (though that's not so easy to detect.
85 # the entry could just be new.)
89 def disableSave(self):
90 self.save_disabled = True
92 def __call__(self, selected):
93 return self.getMulti(selected)
103 KEY_NUMBERS = range(12, 12+10)
107 def getKeyNumber(key):
108 assert key in KEY_NUMBERS
112 # ConfigSelection is a "one of.."-type.
113 # it has the "choices", usually a list, which contains
114 # (id, desc)-tuples (or just only the ids, in case the id
115 # will be used as description)
117 # all ids MUST be plain strings.
119 class ConfigSelection(ConfigElement):
120 def __init__(self, choices, default = None):
121 ConfigElement.__init__(self)
123 self.description = {}
125 if isinstance(choices, list):
127 if isinstance(x, tuple):
128 self.choices.append(x[0])
129 self.description[x[0]] = x[1]
131 self.choices.append(x)
132 self.description[x] = x
133 elif isinstance(choices, dict):
134 for (key, val) in choices.items():
135 self.choices.append(key)
136 self.description[key] = val
138 assert False, "ConfigSelection choices must be dict or list!"
140 #assert len(self.choices), "you can't have an empty configselection"
141 if len(self.choices) == 0:
143 self.description[""] = ""
146 default = self.choices[0]
148 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
149 for x in self.choices:
150 assert isinstance(x, str), "ConfigSelection choices must be strings"
152 self.value = self.default = default
154 def setValue(self, value):
155 if value in self.choices:
158 self._value = self.default
162 def tostring(self, val):
168 value = property(getValue, setValue)
171 return self.choices.index(self.value)
173 index = property(getIndex)
176 def handleKey(self, key):
177 nchoices = len(self.choices)
178 i = self.choices.index(self.value)
180 self.value = self.choices[(i + nchoices - 1) % nchoices]
181 elif key == KEY_RIGHT:
182 self.value = self.choices[(i + 1) % nchoices]
184 def getMulti(self, selected):
185 return ("text", self.description[self.value])
188 def getHTML(self, id):
190 for v in self.choices:
192 checked = 'checked="checked" '
195 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
198 def unsafeAssign(self, value):
199 # setValue does check if value is in choices. This is safe enough.
204 # several customized versions exist for different
207 class ConfigBoolean(ConfigElement):
208 def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
209 ConfigElement.__init__(self)
210 self.descriptions = descriptions
211 self.value = self.default = default
212 def handleKey(self, key):
213 if key in [KEY_LEFT, KEY_RIGHT]:
214 self.value = not self.value
216 def getMulti(self, selected):
217 return ("text", _(self.descriptions[self.value]))
219 def tostring(self, value):
225 def fromstring(self, val):
231 def getHTML(self, id):
233 checked = ' checked="checked"'
236 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
238 # this is FLAWED. and must be fixed.
239 def unsafeAssign(self, value):
245 class ConfigYesNo(ConfigBoolean):
246 def __init__(self, default = False):
247 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
249 class ConfigOnOff(ConfigBoolean):
250 def __init__(self, default = False):
251 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
253 class ConfigEnableDisable(ConfigBoolean):
254 def __init__(self, default = False):
255 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
257 class ConfigDateTime(ConfigElement):
258 def __init__(self, default, formatstring, increment = 86400):
259 ConfigElement.__init__(self)
260 self.increment = increment
261 self.formatstring = formatstring
262 self.value = self.default = int(default)
264 def handleKey(self, key):
266 self.value = self.value - self.increment
268 self.value = self.value + self.increment
270 def getMulti(self, selected):
271 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
273 def fromstring(self, val):
276 # *THE* mighty config element class
278 # allows you to store/edit a sequence of values.
279 # can be used for IP-addresses, dates, plain integers, ...
280 # several helper exist to ease this up a bit.
282 class ConfigSequence(ConfigElement):
283 def __init__(self, seperator, limits, censor_char = "", default = None):
284 ConfigElement.__init__(self)
285 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
286 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
287 #assert isinstance(default, list), "default must be a list"
288 #assert isinstance(default[0], int), "list must contain numbers"
289 #assert len(default) == len(limits), "length must match"
292 self.seperator = seperator
294 self.censor_char = censor_char
296 self.default = default
297 self.value = copy.copy(default)
302 for i in self._value:
303 max_pos += len(str(self.limits[num][1]))
305 while self._value[num] < self.limits[num][0]:
308 while self._value[num] > self.limits[num][1]:
309 self._value[num] -= 1
313 if self.marked_pos >= max_pos:
314 self.marked_pos = max_pos - 1
316 if self.marked_pos < 0:
319 def validatePos(self):
320 if self.marked_pos < 0:
323 total_len = sum([len(str(x[1])) for x in self.limits])
325 if self.marked_pos >= total_len:
326 self.marked_pos = total_len - 1
328 def handleKey(self, key):
337 if key in KEY_NUMBERS:
339 for x in self.limits:
340 block_len.append(len(str(x[1])))
342 total_len = sum(block_len)
346 block_len_total = [0, ]
348 pos += block_len[blocknumber]
349 block_len_total.append(pos)
350 if pos - 1 >= self.marked_pos:
355 number = getKeyNumber(key)
357 # length of numberblock
358 number_len = len(str(self.limits[blocknumber][1]))
360 # position in the block
361 posinblock = self.marked_pos - block_len_total[blocknumber]
363 oldvalue = self._value[blocknumber]
364 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
365 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
367 self._value[blocknumber] = newvalue
373 def getMulti(self, selected):
375 mPos = self.marked_pos
377 for i in self._value:
378 if len(value): #fixme no heading separator possible
379 value += self.seperator
380 if mPos >= len(value) - 1:
383 if self.censor_char == "":
384 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
386 value += (self.censor_char * len(str(self.limits[num][1])))
389 # only mark cursor when we are selected
390 # (this code is heavily ink optimized!)
392 return ("mtext"[1-selected:], value, [mPos])
394 return ("text", value)
396 def tostring(self, val):
397 return self.seperator.join([self.saveSingle(x) for x in val])
399 def saveSingle(self, v):
402 def fromstring(self, value):
403 return [int(x) for x in self.saved_value.split(self.seperator)]
405 class ConfigIP(ConfigSequence):
406 def __init__(self, default):
407 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
409 class ConfigMAC(ConfigSequence):
410 def __init__(self, default):
411 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
413 class ConfigPosition(ConfigSequence):
414 def __init__(self, default, args):
415 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
417 class ConfigClock(ConfigSequence):
418 def __init__(self, default):
420 t = time.localtime(default)
421 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = [t.tm_hour, t.tm_min])
423 class ConfigInteger(ConfigSequence):
424 def __init__(self, default, limits):
425 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
427 # you need to override this to do input validation
428 def setValue(self, value):
429 self._value = [value]
433 return self._value[0]
435 value = property(getValue, setValue)
437 def fromstring(self, value):
440 def tostring(self, value):
443 class ConfigPIN(ConfigInteger):
444 def __init__(self, default, len = 4, censor = ""):
445 assert isinstance(default, int), "ConfigPIN default must be an integer"
448 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = default)
454 class ConfigFloat(ConfigSequence):
455 def __init__(self, default, limits):
456 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
459 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
461 float = property(getFloat)
463 # an editable text...
464 class ConfigText(ConfigElement, NumericalTextInput):
465 def __init__(self, default = "", fixed_size = True):
466 ConfigElement.__init__(self)
467 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
470 self.fixed_size = fixed_size
472 self.value = self.default = default
474 def validateMarker(self):
475 if self.marked_pos < 0:
477 if self.marked_pos >= len(self.text):
478 self.marked_pos = len(self.text) - 1
480 #def nextEntry(self):
481 # self.vals[1](self.getConfigPath())
483 def handleKey(self, key):
484 # this will no change anything on the value itself
485 # so we can handle it here in gui element
486 if key == KEY_DELETE:
487 self.text = self.text[0:self.marked_pos] + self.text[self.marked_pos + 1:]
488 elif key == KEY_LEFT:
490 elif key == KEY_RIGHT:
492 if not self.fixed_size:
493 if self.marked_pos >= len(self.text):
494 self.text = self.text.ljust(len(self.text) + 1)
495 elif key in KEY_NUMBERS:
496 number = self.getKey(getKeyNumber(key))
497 self.text = self.text[0:self.marked_pos] + unicode(number) + self.text[self.marked_pos + 1:]
498 elif key == KEY_TIMEOUT:
502 self.validateMarker()
507 self.validateMarker()
511 return self.text.encode("utf-8")
513 def setValue(self, val):
515 self.text = val.decode("utf-8")
516 except UnicodeDecodeError:
520 value = property(getValue, setValue)
521 _value = property(getValue, setValue)
523 def getMulti(self, selected):
524 return ("mtext"[1-selected:], self.value, [self.marked_pos])
526 def helpWindow(self):
527 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
528 return (NumericalTextInputHelpDialog,self)
530 def getHTML(self, id):
531 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
533 def unsafeAssign(self, value):
534 self.value = str(value)
537 class ConfigSlider(ConfigElement):
538 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
539 ConfigElement.__init__(self)
540 self.value = self.default = default
543 self.increment = increment
545 def checkValues(self):
546 if self.value < self.min:
547 self.value = self.min
549 if self.value > self.max:
550 self.value = self.max
552 def handleKey(self, key):
554 self.value -= self.increment
555 elif key == KEY_RIGHT:
556 self.value += self.increment
563 def getMulti(self, selected):
565 return ("slider", self.value, self.max)
567 def fromstring(self, value):
570 # a satlist. in fact, it's a ConfigSelection.
571 class ConfigSatlist(ConfigSelection):
572 def __init__(self, list, default = None):
573 if default is not None:
574 default = str(default)
575 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc) in list], default = default)
577 def getOrbitalPosition(self):
580 return int(self.value)
582 orbital_position = property(getOrbitalPosition)
585 class ConfigNothing(ConfigSelection):
587 ConfigSelection.__init__(self, choices = [""])
589 # until here, 'saved_value' always had to be a *string*.
590 # now, in ConfigSubsection, and only there, saved_value
591 # is a dict, essentially forming a tree.
593 # config.foo.bar=True
594 # config.foobar=False
597 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
601 class ConfigSubsectionContent(object):
604 # we store a backup of the loaded configuration
605 # data in self.stored_values, to be able to deploy
606 # them when a new config element will be added,
607 # so non-default values are instantly available
609 # A list, for example:
610 # config.dipswitches = ConfigSubList()
611 # config.dipswitches.append(ConfigYesNo())
612 # config.dipswitches.append(ConfigYesNo())
613 # config.dipswitches.append(ConfigYesNo())
614 class ConfigSubList(list, object):
616 object.__init__(self)
618 self.stored_values = {}
628 def getSavedValue(self):
630 for i in range(len(self)):
631 sv = self[i].saved_value
636 def setSavedValue(self, values):
637 self.stored_values = dict(values)
638 for (key, val) in self.stored_values.items():
639 if int(key) < len(self):
640 self[int(key)].saved_value = val
642 saved_value = property(getSavedValue, setSavedValue)
644 def append(self, item):
646 list.append(self, item)
647 if i in self.stored_values:
648 item.saved_value = self.stored_values[i]
651 # same as ConfigSubList, just as a dictionary.
652 # care must be taken that the 'key' has a proper
653 # str() method, because it will be used in the config
655 class ConfigSubDict(dict, object):
657 object.__init__(self)
659 self.stored_values = {}
662 for x in self.values():
666 for x in self.values():
669 def getSavedValue(self):
671 for (key, val) in self.items():
672 if val.saved_value is not None:
673 res[str(key)] = val.saved_value
676 def setSavedValue(self, values):
677 self.stored_values = dict(values)
678 for (key, val) in self.items():
679 if str(key) in self.stored_values:
680 val = self.stored_values[str(key)]
682 saved_value = property(getSavedValue, setSavedValue)
684 def __setitem__(self, key, item):
685 dict.__setitem__(self, key, item)
686 if str(key) in self.stored_values:
687 item.saved_value = self.stored_values[str(key)]
690 # Like the classes above, just with a more "native"
693 # some evil stuff must be done to allow instant
694 # loading of added elements. this is why this class
697 # we need the 'content' because we overwrite
699 # If you don't understand this, try adding
700 # __setattr__ to a usual exisiting class and you will.
701 class ConfigSubsection(object):
703 object.__init__(self)
704 self.__dict__["content"] = ConfigSubsectionContent()
705 self.content.items = { }
706 self.content.stored_values = { }
708 def __setattr__(self, name, value):
709 if name == "saved_value":
710 return self.setSavedValue(value)
711 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"
712 self.content.items[name] = value
713 if name in self.content.stored_values:
714 #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
715 value.saved_value = self.content.stored_values[name]
718 def __getattr__(self, name):
719 return self.content.items[name]
721 def getSavedValue(self):
722 res = self.content.stored_values
723 for (key, val) in self.content.items.items():
724 if val.saved_value is not None:
725 res[key] = val.saved_value
731 def setSavedValue(self, values):
732 values = dict(values)
734 self.content.stored_values = values
736 for (key, val) in self.content.items.items():
738 val.setSavedValue(values[key])
740 saved_value = property(getSavedValue, setSavedValue)
743 for x in self.content.items.values():
747 for x in self.content.items.values():
750 # the root config object, which also can "pickle" (=serialize)
751 # down the whole config tree.
753 # we try to keep non-existing config entries, to apply them whenever
754 # a new config entry is added to a subsection
755 # also, non-existing config entries will be saved, so they won't be
756 # lost when a config entry disappears.
757 class Config(ConfigSubsection):
759 ConfigSubsection.__init__(self)
761 def pickle_this(self, prefix, topickle, result):
762 for (key, val) in topickle.items():
763 name = prefix + "." + key
765 if isinstance(val, dict):
766 self.pickle_this(name, val, result)
767 elif isinstance(val, tuple):
768 result.append(name + "=" + val[0]) # + " ; " + val[1])
770 result.append(name + "=" + val)
774 self.pickle_this("config", self.saved_value, result)
775 return '\n'.join(result) + "\n"
777 def unpickle(self, lines):
780 if not len(l) or l[0] == '#':
784 val = l[n+1:].strip()
786 names = l[:n].split('.')
787 # if val.find(' ') != -1:
788 # val = val[:val.find(' ')]
793 base = base.setdefault(n, {})
795 base[names[-1]] = val
797 # we inherit from ConfigSubsection, so ...
798 #object.__setattr__(self, "saved_value", tree["config"])
799 self.setSavedValue(tree["config"])
801 def saveToFile(self, filename):
802 f = open(filename, "w")
803 f.write(self.pickle())
806 def loadFromFile(self, filename):
807 f = open(filename, "r")
808 self.unpickle(f.readlines())
812 config.misc = ConfigSubsection()
815 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "config2")
819 config.loadFromFile(self.CONFIG_FILE)
821 print "unable to load config (%s), assuming defaults..." % str(e)
825 config.saveToFile(self.CONFIG_FILE)
827 def getResolvedKey(self, key):
831 element.disableSave()
834 configfile = ConfigFile()
838 def getConfigListEntry(desc, config):
839 return (desc, config)
844 #config.bla = ConfigSubsection()
845 #config.bla.test = ConfigYesNo()
846 #config.nim = ConfigSubList()
847 #config.nim.append(ConfigSubsection())
848 #config.nim[0].bla = ConfigYesNo()
849 #config.nim.append(ConfigSubsection())
850 #config.nim[1].bla = ConfigYesNo()
851 #config.nim[1].blub = ConfigYesNo()
852 #config.arg = ConfigSubDict()
853 #config.arg["Hello"] = ConfigYesNo()
855 #config.arg["Hello"].handleKey(KEY_RIGHT)
856 #config.arg["Hello"].handleKey(KEY_RIGHT)
862 #print config.pickle()