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):
30 self.saved_value = None
31 self.save_disabled = False
35 # you need to override this to do input validation
36 def setValue(self, value):
43 value = property(getValue, setValue)
45 # you need to override this if self.value is not a string
46 def fromstring(self, value):
49 # you can overide this for fancy default handling
51 if self.saved_value is None:
52 self.value = self.default
54 self.value = self.fromstring(self.saved_value)
56 def tostring(self, value):
59 # you need to override this if str(self.value) doesn't work
61 if self.save_disabled or self.value == self.default:
62 self.saved_value = None
64 self.saved_value = self.tostring(self.value)
70 for x in self.notifiers:
73 def addNotifier(self, notifier):
74 assert callable(notifier), "notifiers must be callable"
75 self.notifiers.append(notifier)
78 # do we want to call the notifier
79 # - at all when adding it? (yes)
80 # - when the default is active? (yes)
81 # - when no value *yet* has been set,
82 # because no config has ever been read (currently yes)
83 # (though that's not so easy to detect.
84 # the entry could just be new.)
87 def disableSave(self):
88 self.save_disabled = True
90 def __call__(self, selected):
91 return self.getMulti(selected)
101 KEY_NUMBERS = range(12, 12+10)
105 def getKeyNumber(key):
106 assert key in KEY_NUMBERS
110 # ConfigSelection is a "one of.."-type.
111 # it has the "choices", usually a list, which contains
112 # (id, desc)-tuples (or just only the ids, in case the id
113 # will be used as description)
115 # all ids MUST be plain strings.
117 class ConfigSelection(ConfigElement):
118 def __init__(self, choices, default = None):
119 ConfigElement.__init__(self)
121 self.description = {}
123 if isinstance(choices, list):
125 if isinstance(x, tuple):
126 self.choices.append(x[0])
127 self.description[x[0]] = x[1]
129 self.choices.append(x)
130 self.description[x] = x
131 elif isinstance(choices, dict):
132 for (key, val) in choices.items():
133 self.choices.append(key)
134 self.description[key] = val
136 assert False, "ConfigSelection choices must be dict or list!"
138 #assert len(self.choices), "you can't have an empty configselection"
139 if len(self.choices) == 0:
141 self.description[""] = ""
144 default = self.choices[0]
146 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
147 for x in self.choices:
148 assert isinstance(x, str), "ConfigSelection choices must be strings"
150 self.value = self.default = default
152 def setValue(self, value):
153 if value in self.choices:
156 self._value = self.default
160 def tostring(self, val):
161 return (val, ','.join(self.choices))
166 value = property(getValue, setValue)
169 return self.choices.index(self.value)
171 index = property(getIndex)
174 def handleKey(self, key):
175 nchoices = len(self.choices)
176 i = self.choices.index(self.value)
178 self.value = self.choices[(i + nchoices - 1) % nchoices]
179 elif key == KEY_RIGHT:
180 self.value = self.choices[(i + 1) % nchoices]
182 def getMulti(self, selected):
183 return ("text", self.description[self.value])
186 def getHTML(self, id):
188 for v in self.choices:
190 checked = 'checked="checked" '
193 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
196 def unsafeAssign(self, value):
197 # setValue does check if value is in choices. This is safe enough.
202 # several customized versions exist for different
205 class ConfigBoolean(ConfigElement):
206 def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
207 ConfigElement.__init__(self)
208 self.descriptions = descriptions
209 self.value = self.default = default
210 def handleKey(self, key):
211 if key in [KEY_LEFT, KEY_RIGHT]:
212 self.value = not self.value
214 def getMulti(self, selected):
215 return ("text", _(self.descriptions[self.value]))
217 def tostring(self, value):
223 def fromstring(self, val):
229 def getHTML(self, id):
231 checked = ' checked="checked"'
234 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
236 # this is FLAWED. and must be fixed.
237 def unsafeAssign(self, value):
243 class ConfigYesNo(ConfigBoolean):
244 def __init__(self, default = False):
245 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
247 class ConfigOnOff(ConfigBoolean):
248 def __init__(self, default = False):
249 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
251 class ConfigEnableDisable(ConfigBoolean):
252 def __init__(self, default = False):
253 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
255 class ConfigDateTime(ConfigElement):
256 def __init__(self, default, formatstring, increment = 86400):
257 ConfigElement.__init__(self)
258 self.increment = increment
259 self.formatstring = formatstring
260 self.value = self.default = int(default)
262 def handleKey(self, key):
264 self.value = self.value - self.increment
266 self.value = self.value + self.increment
268 def getMulti(self, selected):
269 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
271 def fromstring(self, val):
274 # *THE* mighty config element class
276 # allows you to store/edit a sequence of values.
277 # can be used for IP-addresses, dates, plain integers, ...
278 # several helper exist to ease this up a bit.
280 class ConfigSequence(ConfigElement):
281 def __init__(self, seperator, limits, censor_char = "", default = None):
282 ConfigElement.__init__(self)
283 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
284 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
285 #assert isinstance(default, list), "default must be a list"
286 #assert isinstance(default[0], int), "list must contain numbers"
287 #assert len(default) == len(limits), "length must match"
290 self.seperator = seperator
292 self.censor_char = censor_char
294 self.default = default
295 self.value = copy.copy(default)
300 for i in self._value:
301 max_pos += len(str(self.limits[num][1]))
303 while self._value[num] < self.limits[num][0]:
306 while self._value[num] > self.limits[num][1]:
307 self._value[num] -= 1
311 if self.marked_pos >= max_pos:
312 self.marked_pos = max_pos - 1
314 if self.marked_pos < 0:
317 def validatePos(self):
318 if self.marked_pos < 0:
321 total_len = sum([len(str(x[1])) for x in self.limits])
323 if self.marked_pos >= total_len:
324 self.marked_pos = total_len - 1
326 def handleKey(self, key):
335 if key in KEY_NUMBERS:
337 for x in self.limits:
338 block_len.append(len(str(x[1])))
340 total_len = sum(block_len)
344 block_len_total = [0, ]
346 pos += block_len[blocknumber]
347 block_len_total.append(pos)
348 if pos - 1 >= self.marked_pos:
353 number = getKeyNumber(key)
355 # length of numberblock
356 number_len = len(str(self.limits[blocknumber][1]))
358 # position in the block
359 posinblock = self.marked_pos - block_len_total[blocknumber]
361 oldvalue = self._value[blocknumber]
362 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
363 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
365 self._value[blocknumber] = newvalue
371 def getMulti(self, selected):
373 mPos = self.marked_pos
375 for i in self._value:
376 if len(value): #fixme no heading separator possible
377 value += self.seperator
378 if mPos >= len(value) - 1:
381 if self.censor_char == "":
382 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
384 value += (self.censorChar * len(str(self.limits[num][1])))
387 # only mark cursor when we are selected
388 # (this code is heavily ink optimized!)
390 return ("mtext"[1-selected:], value, [mPos])
392 return ("text", value)
394 def tostring(self, val):
395 return self.seperator.join([self.saveSingle(x) for x in val])
397 def saveSingle(self, v):
400 def fromstring(self, value):
401 return [int(x) for x in self.saved_value.split(self.seperator)]
403 class ConfigIP(ConfigSequence):
404 def __init__(self, default):
405 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
407 class ConfigMAC(ConfigSequence):
408 def __init__(self, default):
409 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
411 class ConfigPosition(ConfigSequence):
412 def __init__(self, default, args):
413 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
415 class ConfigClock(ConfigSequence):
416 def __init__(self, default):
417 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = default)
419 class ConfigInteger(ConfigSequence):
420 def __init__(self, default, limits):
421 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
423 # you need to override this to do input validation
424 def setValue(self, value):
425 self._value = [value]
429 return self._value[0]
431 value = property(getValue, setValue)
433 def fromstring(self, value):
436 def tostring(self, value):
439 class ConfigPIN(ConfigSequence):
440 def __init__(self, default, len = 4, censor = ""):
441 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = [default])
443 class ConfigFloat(ConfigSequence):
444 def __init__(self, default, limits):
445 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
448 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
450 float = property(getFloat)
452 # an editable text...
453 class ConfigText(ConfigElement, NumericalTextInput):
454 def __init__(self, default = "", fixed_size = True):
455 ConfigElement.__init__(self)
456 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
459 self.fixed_size = fixed_size
461 self.value = self.default = default
463 def validateMarker(self):
464 if self.marked_pos < 0:
466 if self.marked_pos >= len(self.text):
467 self.marked_pos = len(self.text) - 1
469 #def nextEntry(self):
470 # self.vals[1](self.getConfigPath())
472 def handleKey(self, key):
473 # this will no change anything on the value itself
474 # so we can handle it here in gui element
475 if key == KEY_DELETE:
476 self.text = self.text[0:self.marked_pos] + self.text[self.marked_pos + 1:]
477 elif key == KEY_LEFT:
479 elif key == KEY_RIGHT:
481 if not self.fixed_size:
482 if self.marked_pos >= len(self.text):
483 self.text = self.text.ljust(len(self.text) + 1)
484 elif key in KEY_NUMBERS:
485 number = self.getKey(getKeyNumber(key))
486 self.text = self.text[0:self.marked_pos] + str(number) + self.text[self.marked_pos + 1:]
487 elif key == KEY_TIMEOUT:
491 self.validateMarker()
496 self.validateMarker()
500 return self.text.encode("utf-8")
502 def setValue(self, val):
504 self.text = val.decode("utf-8")
505 except UnicodeDecodeError:
509 value = property(getValue, setValue)
510 _value = property(getValue, setValue)
512 def getMulti(self, selected):
513 return ("mtext"[1-selected:], self.value, [self.marked_pos])
515 def helpWindow(self):
516 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
517 return (NumericalTextInputHelpDialog,self)
519 def getHTML(self, id):
520 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
522 def unsafeAssign(self, value):
523 self.value = str(value)
526 class ConfigSlider(ConfigElement):
527 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
528 ConfigElement.__init__(self)
529 self.value = self.default = default
532 self.increment = increment
534 def checkValues(self):
535 if self.value < self.min:
536 self.value = self.min
538 if self.value > self.max:
539 self.value = self.max
541 def handleKey(self, key):
543 self.value -= self.increment
544 elif key == KEY_RIGHT:
545 self.value += self.increment
552 def getMulti(self, selected):
554 return ("slider", self.value, self.max)
556 def fromstring(self, value):
559 # a satlist. in fact, it's a ConfigSelection.
560 class ConfigSatlist(ConfigSelection):
561 def __init__(self, list, default = None):
562 if default is not None:
563 default = str(default)
564 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc) in list], default = default)
566 def getOrbitalPosition(self):
569 return int(self.value)
571 orbital_position = property(getOrbitalPosition)
574 class ConfigDummy(ConfigSelection):
576 ConfigSelection.__init__(self, choices = [""])
578 # until here, 'saved_value' always had to be a *string*.
579 # now, in ConfigSubsection, and only there, saved_value
580 # is a dict, essentially forming a tree.
582 # config.foo.bar=True
583 # config.foobar=False
586 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
590 class ConfigSubsectionContent(object):
593 # we store a backup of the loaded configuration
594 # data in self.stored_values, to be able to deploy
595 # them when a new config element will be added,
596 # so non-default values are instantly available
598 # A list, for example:
599 # config.dipswitches = ConfigSubList()
600 # config.dipswitches.append(ConfigYesNo())
601 # config.dipswitches.append(ConfigYesNo())
602 # config.dipswitches.append(ConfigYesNo())
603 class ConfigSubList(list, object):
605 object.__init__(self)
607 self.stored_values = {}
617 def getSavedValue(self):
619 for i in range(len(self)):
620 sv = self[i].saved_value
625 def setSavedValue(self, values):
626 self.stored_values = dict(values)
627 for (key, val) in self.stored_values.items():
628 if int(key) < len(self):
629 self[int(key)].saved_value = val
631 saved_value = property(getSavedValue, setSavedValue)
633 def append(self, item):
634 list.append(self, item)
636 if i in self.stored_values:
637 item.saved_value = self.stored_values[i]
640 # same as ConfigSubList, just as a dictionary.
641 # care must be taken that the 'key' has a proper
642 # str() method, because it will be used in the config
644 class ConfigSubDict(dict, object):
646 object.__init__(self)
648 self.stored_values = {}
651 for x in self.values():
655 for x in self.values():
658 def getSavedValue(self):
660 for (key, val) in self.items():
661 if val.saved_value is not None:
662 res[str(key)] = val.saved_value
665 def setSavedValue(self, values):
666 self.stored_values = dict(values)
667 for (key, val) in self.items():
668 if str(key) in self.stored_values:
669 val = self.stored_values[str(key)]
671 saved_value = property(getSavedValue, setSavedValue)
673 def __setitem__(self, key, item):
674 dict.__setitem__(self, key, item)
675 if str(key) in self.stored_values:
676 item.saved_value = self.stored_values[str(key)]
679 # Like the classes above, just with a more "native"
682 # some evil stuff must be done to allow instant
683 # loading of added elements. this is why this class
686 # we need the 'content' because we overwrite
688 # If you don't understand this, try adding
689 # __setattr__ to a usual exisiting class and you will.
690 class ConfigSubsection(object):
692 object.__init__(self)
693 self.__dict__["content"] = ConfigSubsectionContent()
694 self.content.items = { }
695 self.content.stored_values = { }
697 def __setattr__(self, name, value):
698 if name == "saved_value":
699 return self.setSavedValue(value)
700 self.content.items[name] = value
701 if name in self.content.stored_values:
702 #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
703 value.saved_value = self.content.stored_values[name]
706 def __getattr__(self, name):
707 return self.content.items[name]
709 def getSavedValue(self):
710 res = self.content.stored_values
711 for (key, val) in self.content.items.items():
712 if val.saved_value is not None:
713 res[key] = val.saved_value
716 def setSavedValue(self, values):
717 values = dict(values)
719 self.content.stored_values = values
721 for (key, val) in self.content.items.items():
723 val.setSavedValue(values[key])
725 saved_value = property(getSavedValue, setSavedValue)
728 for x in self.content.items.values():
732 for x in self.content.items.values():
735 # the root config object, which also can "pickle" (=serialize)
736 # down the whole config tree.
738 # we try to keep non-existing config entries, to apply them whenever
739 # a new config entry is added to a subsection
740 # also, non-existing config entries will be saved, so they won't be
741 # lost when a config entry disappears.
742 class Config(ConfigSubsection):
744 ConfigSubsection.__init__(self)
746 def pickle_this(self, prefix, topickle, result):
747 for (key, val) in topickle.items():
748 name = prefix + "." + key
750 if isinstance(val, dict):
751 self.pickle_this(name, val, result)
752 elif isinstance(val, tuple):
753 result.append(name + "=" + val[0]) # + " ; " + val[1])
755 result.append(name + "=" + val)
759 self.pickle_this("config", self.saved_value, result)
760 return '\n'.join(result) + "\n"
762 def unpickle(self, lines):
765 if not len(l) or l[0] == '#':
769 val = l[n+1:].strip()
771 names = l[:n].split('.')
772 # if val.find(' ') != -1:
773 # val = val[:val.find(' ')]
778 base = base.setdefault(n, {})
780 base[names[-1]] = val
782 # we inherit from ConfigSubsection, so ...
783 #object.__setattr__(self, "saved_value", tree["config"])
784 self.setSavedValue(tree["config"])
786 def saveToFile(self, filename):
787 f = open(filename, "w")
788 f.write(self.pickle())
791 def loadFromFile(self, filename):
792 f = open(filename, "r")
793 self.unpickle(f.readlines())
797 config.misc = ConfigSubsection()
800 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "config2")
804 config.loadFromFile(self.CONFIG_FILE)
806 print "unable to load config (%s), assuming defaults..." % str(e)
810 config.saveToFile(self.CONFIG_FILE)
812 def getResolvedKey(self, key):
816 element.disableSave()
819 configfile = ConfigFile()
823 def getConfigListEntry(desc, config):
824 return (desc, config)
829 #config.bla = ConfigSubsection()
830 #config.bla.test = ConfigYesNo()
831 #config.nim = ConfigSubList()
832 #config.nim.append(ConfigSubsection())
833 #config.nim[0].bla = ConfigYesNo()
834 #config.nim.append(ConfigSubsection())
835 #config.nim[1].bla = ConfigYesNo()
836 #config.nim[1].blub = ConfigYesNo()
837 #config.arg = ConfigSubDict()
838 #config.arg["Hello"] = ConfigYesNo()
840 #config.arg["Hello"].handleKey(KEY_RIGHT)
841 #config.arg["Hello"].handleKey(KEY_RIGHT)
847 #print config.pickle()