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):
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)
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.)
88 def disableSave(self):
89 self.save_disabled = True
91 def __call__(self, selected):
92 return self.getMulti(selected)
102 KEY_NUMBERS = range(12, 12+10)
106 def getKeyNumber(key):
107 assert key in KEY_NUMBERS
111 # ConfigSelection is a "one of.."-type.
112 # it has the "choices", usually a list, which contains
113 # (id, desc)-tuples (or just only the ids, in case the id
114 # will be used as description)
116 # all ids MUST be plain strings.
118 class ConfigSelection(ConfigElement):
119 def __init__(self, choices, default = None):
120 ConfigElement.__init__(self)
122 self.description = {}
124 if isinstance(choices, list):
126 if isinstance(x, tuple):
127 self.choices.append(x[0])
128 self.description[x[0]] = x[1]
130 self.choices.append(x)
131 self.description[x] = x
132 elif isinstance(choices, dict):
133 for (key, val) in choices.items():
134 self.choices.append(key)
135 self.description[key] = val
137 assert False, "ConfigSelection choices must be dict or list!"
139 #assert len(self.choices), "you can't have an empty configselection"
140 if len(self.choices) == 0:
142 self.description[""] = ""
145 default = self.choices[0]
147 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
148 for x in self.choices:
149 assert isinstance(x, str), "ConfigSelection choices must be strings"
151 self.value = self.default = default
153 def setValue(self, value):
154 if value in self.choices:
157 self._value = self.default
161 def tostring(self, val):
167 value = property(getValue, setValue)
170 return self.choices.index(self.value)
172 index = property(getIndex)
175 def handleKey(self, key):
176 nchoices = len(self.choices)
177 i = self.choices.index(self.value)
179 self.value = self.choices[(i + nchoices - 1) % nchoices]
180 elif key == KEY_RIGHT:
181 self.value = self.choices[(i + 1) % nchoices]
183 def getMulti(self, selected):
184 return ("text", self.description[self.value])
187 def getHTML(self, id):
189 for v in self.choices:
191 checked = 'checked="checked" '
194 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
197 def unsafeAssign(self, value):
198 # setValue does check if value is in choices. This is safe enough.
203 # several customized versions exist for different
206 class ConfigBoolean(ConfigElement):
207 def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
208 ConfigElement.__init__(self)
209 self.descriptions = descriptions
210 self.value = self.default = default
211 def handleKey(self, key):
212 if key in [KEY_LEFT, KEY_RIGHT]:
213 self.value = not self.value
215 def getMulti(self, selected):
216 return ("text", _(self.descriptions[self.value]))
218 def tostring(self, value):
224 def fromstring(self, val):
230 def getHTML(self, id):
232 checked = ' checked="checked"'
235 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
237 # this is FLAWED. and must be fixed.
238 def unsafeAssign(self, value):
244 class ConfigYesNo(ConfigBoolean):
245 def __init__(self, default = False):
246 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
248 class ConfigOnOff(ConfigBoolean):
249 def __init__(self, default = False):
250 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
252 class ConfigEnableDisable(ConfigBoolean):
253 def __init__(self, default = False):
254 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
256 class ConfigDateTime(ConfigElement):
257 def __init__(self, default, formatstring, increment = 86400):
258 ConfigElement.__init__(self)
259 self.increment = increment
260 self.formatstring = formatstring
261 self.value = self.default = int(default)
263 def handleKey(self, key):
265 self.value = self.value - self.increment
267 self.value = self.value + self.increment
269 def getMulti(self, selected):
270 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
272 def fromstring(self, val):
275 # *THE* mighty config element class
277 # allows you to store/edit a sequence of values.
278 # can be used for IP-addresses, dates, plain integers, ...
279 # several helper exist to ease this up a bit.
281 class ConfigSequence(ConfigElement):
282 def __init__(self, seperator, limits, censor_char = "", default = None):
283 ConfigElement.__init__(self)
284 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
285 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
286 #assert isinstance(default, list), "default must be a list"
287 #assert isinstance(default[0], int), "list must contain numbers"
288 #assert len(default) == len(limits), "length must match"
291 self.seperator = seperator
293 self.censor_char = censor_char
295 self.default = default
296 self.value = copy.copy(default)
301 for i in self._value:
302 max_pos += len(str(self.limits[num][1]))
304 while self._value[num] < self.limits[num][0]:
307 while self._value[num] > self.limits[num][1]:
308 self._value[num] -= 1
312 if self.marked_pos >= max_pos:
313 self.marked_pos = max_pos - 1
315 if self.marked_pos < 0:
318 def validatePos(self):
319 if self.marked_pos < 0:
322 total_len = sum([len(str(x[1])) for x in self.limits])
324 if self.marked_pos >= total_len:
325 self.marked_pos = total_len - 1
327 def handleKey(self, key):
336 if key in KEY_NUMBERS:
338 for x in self.limits:
339 block_len.append(len(str(x[1])))
341 total_len = sum(block_len)
345 block_len_total = [0, ]
347 pos += block_len[blocknumber]
348 block_len_total.append(pos)
349 if pos - 1 >= self.marked_pos:
354 number = getKeyNumber(key)
356 # length of numberblock
357 number_len = len(str(self.limits[blocknumber][1]))
359 # position in the block
360 posinblock = self.marked_pos - block_len_total[blocknumber]
362 oldvalue = self._value[blocknumber]
363 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
364 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
366 self._value[blocknumber] = newvalue
372 def getMulti(self, selected):
374 mPos = self.marked_pos
376 for i in self._value:
377 if len(value): #fixme no heading separator possible
378 value += self.seperator
379 if mPos >= len(value) - 1:
382 if self.censor_char == "":
383 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
385 value += (self.censor_char * len(str(self.limits[num][1])))
388 # only mark cursor when we are selected
389 # (this code is heavily ink optimized!)
391 return ("mtext"[1-selected:], value, [mPos])
393 return ("text", value)
395 def tostring(self, val):
396 return self.seperator.join([self.saveSingle(x) for x in val])
398 def saveSingle(self, v):
401 def fromstring(self, value):
402 return [int(x) for x in self.saved_value.split(self.seperator)]
404 class ConfigIP(ConfigSequence):
405 def __init__(self, default):
406 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
408 class ConfigMAC(ConfigSequence):
409 def __init__(self, default):
410 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
412 class ConfigPosition(ConfigSequence):
413 def __init__(self, default, args):
414 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
416 class ConfigClock(ConfigSequence):
417 def __init__(self, default):
419 t = time.localtime(default)
420 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = [t.tm_hour, t.tm_min])
422 class ConfigInteger(ConfigSequence):
423 def __init__(self, default, limits):
424 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
426 # you need to override this to do input validation
427 def setValue(self, value):
428 self._value = [value]
432 return self._value[0]
434 value = property(getValue, setValue)
436 def fromstring(self, value):
439 def tostring(self, value):
442 class ConfigPIN(ConfigInteger):
443 def __init__(self, default, len = 4, censor = ""):
444 assert isinstance(default, int), "ConfigPIN default must be an integer"
447 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = default)
453 class ConfigFloat(ConfigSequence):
454 def __init__(self, default, limits):
455 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
458 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
460 float = property(getFloat)
462 # an editable text...
463 class ConfigText(ConfigElement, NumericalTextInput):
464 def __init__(self, default = "", fixed_size = True):
465 ConfigElement.__init__(self)
466 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
469 self.fixed_size = fixed_size
471 self.value = self.default = default
473 def validateMarker(self):
474 if self.marked_pos < 0:
476 if self.marked_pos >= len(self.text):
477 self.marked_pos = len(self.text) - 1
479 #def nextEntry(self):
480 # self.vals[1](self.getConfigPath())
482 def handleKey(self, key):
483 # this will no change anything on the value itself
484 # so we can handle it here in gui element
485 if key == KEY_DELETE:
486 self.text = self.text[0:self.marked_pos] + self.text[self.marked_pos + 1:]
487 elif key == KEY_LEFT:
489 elif key == KEY_RIGHT:
491 if not self.fixed_size:
492 if self.marked_pos >= len(self.text):
493 self.text = self.text.ljust(len(self.text) + 1)
494 elif key in KEY_NUMBERS:
495 number = self.getKey(getKeyNumber(key))
496 self.text = self.text[0:self.marked_pos] + unicode(number) + self.text[self.marked_pos + 1:]
497 elif key == KEY_TIMEOUT:
501 self.validateMarker()
506 self.validateMarker()
510 return self.text.encode("utf-8")
512 def setValue(self, val):
514 self.text = val.decode("utf-8")
515 except UnicodeDecodeError:
519 value = property(getValue, setValue)
520 _value = property(getValue, setValue)
522 def getMulti(self, selected):
523 return ("mtext"[1-selected:], self.value, [self.marked_pos])
525 def helpWindow(self):
526 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
527 return (NumericalTextInputHelpDialog,self)
529 def getHTML(self, id):
530 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
532 def unsafeAssign(self, value):
533 self.value = str(value)
536 class ConfigSlider(ConfigElement):
537 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
538 ConfigElement.__init__(self)
539 self.value = self.default = default
542 self.increment = increment
544 def checkValues(self):
545 if self.value < self.min:
546 self.value = self.min
548 if self.value > self.max:
549 self.value = self.max
551 def handleKey(self, key):
553 self.value -= self.increment
554 elif key == KEY_RIGHT:
555 self.value += self.increment
562 def getMulti(self, selected):
564 return ("slider", self.value, self.max)
566 def fromstring(self, value):
569 # a satlist. in fact, it's a ConfigSelection.
570 class ConfigSatlist(ConfigSelection):
571 def __init__(self, list, default = None):
572 if default is not None:
573 default = str(default)
574 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc) in list], default = default)
576 def getOrbitalPosition(self):
579 return int(self.value)
581 orbital_position = property(getOrbitalPosition)
584 class ConfigNothing(ConfigSelection):
586 ConfigSelection.__init__(self, choices = [""])
588 # until here, 'saved_value' always had to be a *string*.
589 # now, in ConfigSubsection, and only there, saved_value
590 # is a dict, essentially forming a tree.
592 # config.foo.bar=True
593 # config.foobar=False
596 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
600 class ConfigSubsectionContent(object):
603 # we store a backup of the loaded configuration
604 # data in self.stored_values, to be able to deploy
605 # them when a new config element will be added,
606 # so non-default values are instantly available
608 # A list, for example:
609 # config.dipswitches = ConfigSubList()
610 # config.dipswitches.append(ConfigYesNo())
611 # config.dipswitches.append(ConfigYesNo())
612 # config.dipswitches.append(ConfigYesNo())
613 class ConfigSubList(list, object):
615 object.__init__(self)
617 self.stored_values = {}
627 def getSavedValue(self):
629 for i in range(len(self)):
630 sv = self[i].saved_value
635 def setSavedValue(self, values):
636 self.stored_values = dict(values)
637 for (key, val) in self.stored_values.items():
638 if int(key) < len(self):
639 self[int(key)].saved_value = val
641 saved_value = property(getSavedValue, setSavedValue)
643 def append(self, item):
645 list.append(self, item)
646 if i in self.stored_values:
647 item.saved_value = self.stored_values[i]
650 # same as ConfigSubList, just as a dictionary.
651 # care must be taken that the 'key' has a proper
652 # str() method, because it will be used in the config
654 class ConfigSubDict(dict, object):
656 object.__init__(self)
658 self.stored_values = {}
661 for x in self.values():
665 for x in self.values():
668 def getSavedValue(self):
670 for (key, val) in self.items():
671 if val.saved_value is not None:
672 res[str(key)] = val.saved_value
675 def setSavedValue(self, values):
676 self.stored_values = dict(values)
677 for (key, val) in self.items():
678 if str(key) in self.stored_values:
679 val = self.stored_values[str(key)]
681 saved_value = property(getSavedValue, setSavedValue)
683 def __setitem__(self, key, item):
684 dict.__setitem__(self, key, item)
685 if str(key) in self.stored_values:
686 item.saved_value = self.stored_values[str(key)]
689 # Like the classes above, just with a more "native"
692 # some evil stuff must be done to allow instant
693 # loading of added elements. this is why this class
696 # we need the 'content' because we overwrite
698 # If you don't understand this, try adding
699 # __setattr__ to a usual exisiting class and you will.
700 class ConfigSubsection(object):
702 object.__init__(self)
703 self.__dict__["content"] = ConfigSubsectionContent()
704 self.content.items = { }
705 self.content.stored_values = { }
707 def __setattr__(self, name, value):
708 if name == "saved_value":
709 return self.setSavedValue(value)
710 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"
711 self.content.items[name] = value
712 if name in self.content.stored_values:
713 #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
714 value.saved_value = self.content.stored_values[name]
717 def __getattr__(self, name):
718 return self.content.items[name]
720 def getSavedValue(self):
721 res = self.content.stored_values
722 for (key, val) in self.content.items.items():
723 if val.saved_value is not None:
724 res[key] = val.saved_value
730 def setSavedValue(self, values):
731 values = dict(values)
733 self.content.stored_values = values
735 for (key, val) in self.content.items.items():
737 val.setSavedValue(values[key])
739 saved_value = property(getSavedValue, setSavedValue)
742 for x in self.content.items.values():
746 for x in self.content.items.values():
749 # the root config object, which also can "pickle" (=serialize)
750 # down the whole config tree.
752 # we try to keep non-existing config entries, to apply them whenever
753 # a new config entry is added to a subsection
754 # also, non-existing config entries will be saved, so they won't be
755 # lost when a config entry disappears.
756 class Config(ConfigSubsection):
758 ConfigSubsection.__init__(self)
760 def pickle_this(self, prefix, topickle, result):
761 for (key, val) in topickle.items():
762 name = prefix + "." + key
764 if isinstance(val, dict):
765 self.pickle_this(name, val, result)
766 elif isinstance(val, tuple):
767 result.append(name + "=" + val[0]) # + " ; " + val[1])
769 result.append(name + "=" + val)
773 self.pickle_this("config", self.saved_value, result)
774 return '\n'.join(result) + "\n"
776 def unpickle(self, lines):
779 if not len(l) or l[0] == '#':
783 val = l[n+1:].strip()
785 names = l[:n].split('.')
786 # if val.find(' ') != -1:
787 # val = val[:val.find(' ')]
792 base = base.setdefault(n, {})
794 base[names[-1]] = val
796 # we inherit from ConfigSubsection, so ...
797 #object.__setattr__(self, "saved_value", tree["config"])
798 self.setSavedValue(tree["config"])
800 def saveToFile(self, filename):
801 f = open(filename, "w")
802 f.write(self.pickle())
805 def loadFromFile(self, filename):
806 f = open(filename, "r")
807 self.unpickle(f.readlines())
811 config.misc = ConfigSubsection()
814 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "config2")
818 config.loadFromFile(self.CONFIG_FILE)
820 print "unable to load config (%s), assuming defaults..." % str(e)
824 config.saveToFile(self.CONFIG_FILE)
826 def getResolvedKey(self, key):
830 element.disableSave()
833 configfile = ConfigFile()
837 def getConfigListEntry(desc, config):
838 return (desc, config)
843 #config.bla = ConfigSubsection()
844 #config.bla.test = ConfigYesNo()
845 #config.nim = ConfigSubList()
846 #config.nim.append(ConfigSubsection())
847 #config.nim[0].bla = ConfigYesNo()
848 #config.nim.append(ConfigSubsection())
849 #config.nim[1].bla = ConfigYesNo()
850 #config.nim[1].blub = ConfigYesNo()
851 #config.arg = ConfigSubDict()
852 #config.arg["Hello"] = ConfigYesNo()
854 #config.arg["Hello"].handleKey(KEY_RIGHT)
855 #config.arg["Hello"].handleKey(KEY_RIGHT)
861 #print config.pickle()