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)
77 def disableSave(self):
78 self.save_disabled = True
80 def __call__(self, selected):
81 return self.getMulti(selected)
91 KEY_NUMBERS = range(12, 12+10)
95 def getKeyNumber(key):
96 assert key in KEY_NUMBERS
100 # ConfigSelection is a "one of.."-type.
101 # it has the "choices", usually a list, which contains
102 # (id, desc)-tuples (or just only the ids, in case the id
103 # will be used as description)
105 # all ids MUST be plain strings.
107 class ConfigSelection(ConfigElement):
108 def __init__(self, choices, default = None):
109 ConfigElement.__init__(self)
111 self.description = {}
113 if isinstance(choices, list):
115 if isinstance(x, tuple):
116 self.choices.append(x[0])
117 self.description[x[0]] = x[1]
119 self.choices.append(x)
120 self.description[x] = x
121 elif isinstance(choices, dict):
122 for (key, val) in choices.items():
123 self.choices.append(key)
124 self.description[key] = val
126 assert False, "ConfigSelection choices must be dict or list!"
128 #assert len(self.choices), "you can't have an empty configselection"
129 if len(self.choices) == 0:
131 self.description[""] = ""
134 default = self.choices[0]
136 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
137 for x in self.choices:
138 assert isinstance(x, str), "ConfigSelection choices must be strings"
140 self.value = self.default = default
142 def setValue(self, value):
143 if value in self.choices:
146 self._value = self.default
150 def tostring(self, val):
151 return (val, ','.join(self.choices))
156 value = property(getValue, setValue)
159 return self.choices.index(self.value)
161 index = property(getIndex)
164 def handleKey(self, key):
165 nchoices = len(self.choices)
166 i = self.choices.index(self.value)
168 self.value = self.choices[(i + nchoices - 1) % nchoices]
169 elif key == KEY_RIGHT:
170 self.value = self.choices[(i + 1) % nchoices]
172 def getMulti(self, selected):
173 return ("text", self.description[self.value])
176 def getHTML(self, id):
178 for v in self.choices:
180 checked = 'checked="checked" '
183 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
186 def unsafeAssign(self, value):
187 # setValue does check if value is in choices. This is safe enough.
192 # several customized versions exist for different
195 class ConfigBoolean(ConfigElement):
196 def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
197 ConfigElement.__init__(self)
198 self.descriptions = descriptions
199 self.value = self.default = default
200 def handleKey(self, key):
201 if key in [KEY_LEFT, KEY_RIGHT]:
202 self.value = not self.value
204 def getMulti(self, selected):
205 return ("text", _(self.descriptions[self.value]))
207 def tostring(self, value):
213 def fromstring(self, val):
219 def getHTML(self, id):
221 checked = ' checked="checked"'
224 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
226 # this is FLAWED. and must be fixed.
227 def unsafeAssign(self, value):
233 class ConfigYesNo(ConfigBoolean):
234 def __init__(self, default = False):
235 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
237 class ConfigOnOff(ConfigBoolean):
238 def __init__(self, default = False):
239 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
241 class ConfigEnableDisable(ConfigBoolean):
242 def __init__(self, default = False):
243 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
245 class ConfigDateTime(ConfigElement):
246 def __init__(self, default, formatstring, increment = 86400):
247 ConfigElement.__init__(self)
248 self.increment = increment
249 self.formatstring = formatstring
250 self.value = self.default = int(default)
252 def handleKey(self, key):
254 self.value = self.value - self.increment
256 self.value = self.value + self.increment
258 def getMulti(self, selected):
259 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
261 def fromstring(self, val):
264 # *THE* mighty config element class
266 # allows you to store/edit a sequence of values.
267 # can be used for IP-addresses, dates, plain integers, ...
268 # several helper exist to ease this up a bit.
270 class ConfigSequence(ConfigElement):
271 def __init__(self, seperator, limits, censor_char = "", default = None):
272 ConfigElement.__init__(self)
273 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
274 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
275 #assert isinstance(default, list), "default must be a list"
276 #assert isinstance(default[0], int), "list must contain numbers"
277 #assert len(default) == len(limits), "length must match"
280 self.seperator = seperator
282 self.censor_char = censor_char
284 self.default = default
285 self.value = copy.copy(default)
290 for i in self._value:
291 max_pos += len(str(self.limits[num][1]))
293 while self._value[num] < self.limits[num][0]:
296 while self._value[num] > self.limits[num][1]:
297 self._value[num] -= 1
301 if self.marked_pos >= max_pos:
302 self.marked_pos = max_pos - 1
304 if self.marked_pos < 0:
307 def validatePos(self):
308 if self.marked_pos < 0:
311 total_len = sum([len(str(x[1])) for x in self.limits])
313 if self.marked_pos >= total_len:
314 self.marked_pos = total_len - 1
316 def handleKey(self, key):
325 if key in KEY_NUMBERS:
327 for x in self.limits:
328 block_len.append(len(str(x[1])))
330 total_len = sum(block_len)
334 block_len_total = [0, ]
336 pos += block_len[blocknumber]
337 block_len_total.append(pos)
338 if pos - 1 >= self.marked_pos:
343 number = getKeyNumber(key)
345 # length of numberblock
346 number_len = len(str(self.limits[blocknumber][1]))
348 # position in the block
349 posinblock = self.marked_pos - block_len_total[blocknumber]
351 oldvalue = self._value[blocknumber]
352 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
353 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
355 self._value[blocknumber] = newvalue
361 def getMulti(self, selected):
363 mPos = self.marked_pos
365 for i in self._value:
366 if len(value): #fixme no heading separator possible
367 value += self.seperator
368 if mPos >= len(value) - 1:
371 if self.censor_char == "":
372 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
374 value += (self.censorChar * len(str(self.limits[num][1])))
377 # only mark cursor when we are selected
378 # (this code is heavily ink optimized!)
380 return ("mtext"[1-selected:], value, [mPos])
382 return ("text", value)
384 def tostring(self, val):
385 return self.seperator.join([self.saveSingle(x) for x in val])
387 def saveSingle(self, v):
390 def fromstring(self, value):
391 return [int(x) for x in self.saved_value.split(self.seperator)]
393 class ConfigIP(ConfigSequence):
394 def __init__(self, default):
395 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
397 class ConfigMAC(ConfigSequence):
398 def __init__(self, default):
399 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
401 class ConfigPosition(ConfigSequence):
402 def __init__(self, default, args):
403 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
405 class ConfigClock(ConfigSequence):
406 def __init__(self, default):
407 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = default)
409 class ConfigInteger(ConfigSequence):
410 def __init__(self, default, limits):
411 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
413 # you need to override this to do input validation
414 def setValue(self, value):
415 self._value = [value]
419 return self._value[0]
421 value = property(getValue, setValue)
423 def fromstring(self, value):
426 def tostring(self, value):
429 class ConfigPIN(ConfigSequence):
430 def __init__(self, default, len = 4, censor = ""):
431 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = [default])
433 class ConfigFloat(ConfigSequence):
434 def __init__(self, default, limits):
435 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
438 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
440 float = property(getFloat)
442 # an editable text...
443 class ConfigText(ConfigElement, NumericalTextInput):
444 def __init__(self, default = "", fixed_size = True):
445 ConfigElement.__init__(self)
446 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
449 self.fixed_size = fixed_size
451 self.value = self.default = default
453 def validateMarker(self):
454 if self.marked_pos < 0:
456 if self.marked_pos >= len(self.text):
457 self.marked_pos = len(self.text) - 1
459 #def nextEntry(self):
460 # self.vals[1](self.getConfigPath())
462 def handleKey(self, key):
463 # this will no change anything on the value itself
464 # so we can handle it here in gui element
465 if key == KEY_DELETE:
466 self.text = self.text[0:self.marked_pos] + self.text[self.marked_pos + 1:]
467 elif key == KEY_LEFT:
469 elif key == KEY_RIGHT:
471 if not self.fixed_size:
472 if self.marked_pos >= len(self.text):
473 self.text = self.text.ljust(len(self.text) + 1)
474 elif key in KEY_NUMBERS:
475 number = self.getKey(getKeyNumber(key))
476 self.text = self.text[0:self.marked_pos] + str(number) + self.text[self.marked_pos + 1:]
477 elif key == KEY_TIMEOUT:
481 self.validateMarker()
486 self.validateMarker()
490 return self.text.encode("utf-8")
492 def setValue(self, val):
494 self.text = val.decode("utf-8")
495 except UnicodeDecodeError:
499 value = property(getValue, setValue)
500 _value = property(getValue, setValue)
502 def getMulti(self, selected):
503 return ("mtext"[1-selected:], self.value, [self.marked_pos])
505 def helpWindow(self):
506 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
507 return (NumericalTextInputHelpDialog,self)
509 def getHTML(self, id):
510 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
512 def unsafeAssign(self, value):
513 self.value = str(value)
516 class ConfigSlider(ConfigElement):
517 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
518 ConfigElement.__init__(self)
519 self.value = self.default = default
522 self.increment = increment
524 def checkValues(self):
525 if self.value < self.min:
526 self.value = self.min
528 if self.value > self.max:
529 self.value = self.max
531 def handleKey(self, key):
533 self.value -= self.increment
534 elif key == KEY_RIGHT:
535 self.value += self.increment
542 def getMulti(self, selected):
544 return ("slider", self.value, self.max)
546 def fromstring(self, value):
549 # a satlist. in fact, it's a ConfigSelection.
550 class ConfigSatlist(ConfigSelection):
551 def __init__(self, list, default = None):
552 if default is not None:
553 default = str(default)
554 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc) in list], default = default)
556 def getOrbitalPosition(self):
559 return int(self.value)
561 orbital_position = property(getOrbitalPosition)
564 class ConfigDummy(ConfigSelection):
566 ConfigSelection.__init__(self, choices = [""])
568 # until here, 'saved_value' always had to be a *string*.
569 # now, in ConfigSubsection, and only there, saved_value
570 # is a dict, essentially forming a tree.
572 # config.foo.bar=True
573 # config.foobar=False
576 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
580 class ConfigSubsectionContent(object):
583 # we store a backup of the loaded configuration
584 # data in self.stored_values, to be able to deploy
585 # them when a new config element will be added,
586 # so non-default values are instantly available
588 # A list, for example:
589 # config.dipswitches = ConfigSubList()
590 # config.dipswitches.append(ConfigYesNo())
591 # config.dipswitches.append(ConfigYesNo())
592 # config.dipswitches.append(ConfigYesNo())
593 class ConfigSubList(list, object):
595 object.__init__(self)
597 self.stored_values = {}
607 def getSavedValue(self):
609 for i in range(len(self)):
610 sv = self[i].saved_value
615 def setSavedValue(self, values):
616 self.stored_values = dict(values)
617 for (key, val) in self.stored_values.items():
618 if int(key) < len(self):
619 self[int(key)].saved_value = val
621 saved_value = property(getSavedValue, setSavedValue)
623 def append(self, item):
624 list.append(self, item)
626 if i in self.stored_values:
627 item.saved_value = self.stored_values[i]
630 # same as ConfigSubList, just as a dictionary.
631 # care must be taken that the 'key' has a proper
632 # str() method, because it will be used in the config
634 class ConfigSubDict(dict, object):
636 object.__init__(self)
638 self.stored_values = {}
641 for x in self.values():
645 for x in self.values():
648 def getSavedValue(self):
650 for (key, val) in self.items():
651 if val.saved_value is not None:
652 res[str(key)] = val.saved_value
655 def setSavedValue(self, values):
656 self.stored_values = dict(values)
657 for (key, val) in self.items():
658 if str(key) in self.stored_values:
659 val = self.stored_values[str(key)]
661 saved_value = property(getSavedValue, setSavedValue)
663 def __setitem__(self, key, item):
664 dict.__setitem__(self, key, item)
665 if str(key) in self.stored_values:
666 item.saved_value = self.stored_values[str(key)]
669 # Like the classes above, just with a more "native"
672 # some evil stuff must be done to allow instant
673 # loading of added elements. this is why this class
676 # we need the 'content' because we overwrite
678 # If you don't understand this, try adding
679 # __setattr__ to a usual exisiting class and you will.
680 class ConfigSubsection(object):
682 object.__init__(self)
683 self.__dict__["content"] = ConfigSubsectionContent()
684 self.content.items = { }
685 self.content.stored_values = { }
687 def __setattr__(self, name, value):
688 if name == "saved_value":
689 return self.setSavedValue(value)
690 self.content.items[name] = value
691 if name in self.content.stored_values:
692 #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
693 value.saved_value = self.content.stored_values[name]
696 def __getattr__(self, name):
697 return self.content.items[name]
699 def getSavedValue(self):
700 res = self.content.stored_values
701 for (key, val) in self.content.items.items():
702 if val.saved_value is not None:
703 res[key] = val.saved_value
706 def setSavedValue(self, values):
707 values = dict(values)
709 self.content.stored_values = values
711 for (key, val) in self.content.items.items():
713 val.setSavedValue(values[key])
715 saved_value = property(getSavedValue, setSavedValue)
718 for x in self.content.items.values():
722 for x in self.content.items.values():
725 # the root config object, which also can "pickle" (=serialize)
726 # down the whole config tree.
728 # we try to keep non-existing config entries, to apply them whenever
729 # a new config entry is added to a subsection
730 # also, non-existing config entries will be saved, so they won't be
731 # lost when a config entry disappears.
732 class Config(ConfigSubsection):
734 ConfigSubsection.__init__(self)
736 def pickle_this(self, prefix, topickle, result):
737 for (key, val) in topickle.items():
738 name = prefix + "." + key
740 if isinstance(val, dict):
741 self.pickle_this(name, val, result)
742 elif isinstance(val, tuple):
743 result.append(name + "=" + val[0]) # + " ; " + val[1])
745 result.append(name + "=" + val)
749 self.pickle_this("config", self.saved_value, result)
750 return '\n'.join(result) + "\n"
752 def unpickle(self, lines):
755 if not len(l) or l[0] == '#':
759 val = l[n+1:].strip()
761 names = l[:n].split('.')
762 # if val.find(' ') != -1:
763 # val = val[:val.find(' ')]
768 base = base.setdefault(n, {})
770 base[names[-1]] = val
772 # we inherit from ConfigSubsection, so ...
773 #object.__setattr__(self, "saved_value", tree["config"])
774 self.setSavedValue(tree["config"])
776 def saveToFile(self, filename):
777 f = open(filename, "w")
778 f.write(self.pickle())
781 def loadFromFile(self, filename):
782 f = open(filename, "r")
783 self.unpickle(f.readlines())
787 config.misc = ConfigSubsection()
790 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "config2")
794 config.loadFromFile(self.CONFIG_FILE)
796 print "unable to load config (%s), assuming defaults..." % str(e)
800 config.saveToFile(self.CONFIG_FILE)
802 def getResolvedKey(self, key):
806 element.disableSave()
809 configfile = ConfigFile()
813 def getConfigListEntry(desc, config):
814 return (desc, config)
819 #config.bla = ConfigSubsection()
820 #config.bla.test = ConfigYesNo()
821 #config.nim = ConfigSubList()
822 #config.nim.append(ConfigSubsection())
823 #config.nim[0].bla = ConfigYesNo()
824 #config.nim.append(ConfigSubsection())
825 #config.nim[1].bla = ConfigYesNo()
826 #config.nim[1].blub = ConfigYesNo()
827 #config.arg = ConfigSubDict()
828 #config.arg["Hello"] = ConfigYesNo()
830 #config.arg["Hello"].handleKey(KEY_RIGHT)
831 #config.arg["Hello"].handleKey(KEY_RIGHT)
837 #print config.pickle()