1 from enigma import getPrevAsciiCode
2 from Tools.NumericalTextInput import NumericalTextInput
3 from Tools.Directories import resolveFilename, SCOPE_CONFIG
4 from Components.Harddisk import harddiskmanager
5 from copy import copy as copy_copy
6 from os import path as os_path
7 from time import localtime, strftime
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):
32 self.saved_value = None
33 self.last_value = None
34 self.save_disabled = False
36 self.notifiers_final = []
38 self.callNotifiersOnSaveAndCancel = False
40 # you need to override this to do input validation
41 def setValue(self, value):
48 value = property(getValue, setValue)
50 # you need to override this if self.value is not a string
51 def fromstring(self, value):
54 # you can overide this for fancy default handling
58 self.value = self.default
60 self.value = self.fromstring(sv)
62 def tostring(self, value):
65 # you need to override this if str(self.value) doesn't work
67 if self.save_disabled or self.value == self.default:
68 self.saved_value = None
70 self.saved_value = self.tostring(self.value)
71 if self.callNotifiersOnSaveAndCancel:
76 if self.callNotifiersOnSaveAndCancel:
81 if sv is None and self.value == self.default:
83 return self.tostring(self.value) != sv
86 for x in self.notifiers:
89 def changedFinal(self):
90 for x in self.notifiers_final:
93 def addNotifier(self, notifier, initial_call = True, immediate_feedback = True):
94 assert callable(notifier), "notifiers must be callable"
95 if immediate_feedback:
96 self.notifiers.append(notifier)
98 self.notifiers_final.append(notifier)
100 # do we want to call the notifier
101 # - at all when adding it? (yes, though optional)
102 # - when the default is active? (yes)
103 # - when no value *yet* has been set,
104 # because no config has ever been read (currently yes)
105 # (though that's not so easy to detect.
106 # the entry could just be new.)
110 def disableSave(self):
111 self.save_disabled = True
113 def __call__(self, selected):
114 return self.getMulti(selected)
116 def onSelect(self, session):
119 def onDeselect(self, session):
120 if not self.last_value == self.value:
122 self.last_value = self.value
134 KEY_NUMBERS = range(12, 12+10)
138 def getKeyNumber(key):
139 assert key in KEY_NUMBERS
142 class choicesList(object): # XXX: we might want a better name for this
146 def __init__(self, choices, type = None):
147 object.__init__(self)
148 self.choices = choices
150 if isinstance(choices, list):
151 self.type = choicesList.LIST_TYPE_LIST
152 elif isinstance(choices, dict):
153 self.type = choicesList.LIST_TYPE_DICT
155 assert False, "choices must be dict or list!"
160 if self.type == choicesList.LIST_TYPE_LIST:
161 ret = [isinstance(x, tuple) and x[0] or x for x in self.choices]
163 ret = self.choices.keys()
167 if self.type == choicesList.LIST_TYPE_LIST:
168 ret = [isinstance(x, tuple) and x[0] or x for x in self.choices]
171 return iter(ret or [""])
174 return len(self.choices) or 1
176 def __getitem__(self, index):
177 if self.type == choicesList.LIST_TYPE_LIST:
178 ret = self.choices[index]
179 if isinstance(ret, tuple):
182 return self.choices.keys()[index]
184 def index(self, value):
185 return self.__list__().index(value)
187 def __setitem__(self, index, value):
188 if self.type == choicesList.LIST_TYPE_LIST:
189 orig = self.choices[index]
190 if isinstance(orig, tuple):
191 self.choices[index] = (value, orig[1])
193 self.choices[index] = value
195 key = self.choices.keys()[index]
196 orig = self.choices[key]
197 del self.choices[key]
198 self.choices[value] = orig
201 choices = self.choices
204 if self.type is choicesList.LIST_TYPE_LIST:
206 if isinstance(default, tuple):
209 default = choices.keys()[0]
212 class descriptionList(choicesList): # XXX: we might want a better name for this
214 if self.type == choicesList.LIST_TYPE_LIST:
215 ret = [isinstance(x, tuple) and x[1] or x for x in self.choices]
217 ret = self.choices.values()
221 return iter(self.__list__())
223 def __getitem__(self, index):
224 if self.type == choicesList.LIST_TYPE_LIST:
225 for x in self.choices:
226 if isinstance(x, tuple):
231 return str(index) # Fallback!
233 return str(self.choices.get(index, ""))
235 def __setitem__(self, index, value):
236 if self.type == choicesList.LIST_TYPE_LIST:
237 i = self.index(index)
238 orig = self.choices[i]
239 if isinstance(orig, tuple):
240 self.choices[i] = (orig[0], value)
242 self.choices[i] = value
244 self.choices[index] = value
247 # ConfigSelection is a "one of.."-type.
248 # it has the "choices", usually a list, which contains
249 # (id, desc)-tuples (or just only the ids, in case the id
250 # will be used as description)
252 # all ids MUST be plain strings.
254 class ConfigSelection(ConfigElement):
255 def __init__(self, choices, default = None):
256 ConfigElement.__init__(self)
257 self.choices = choicesList(choices)
260 default = self.choices.default()
262 self.default = self._value = self.last_value = default
265 def setChoices(self, choices, default = None):
266 self.choices = choicesList(choices)
269 default = self.choices.default()
271 if self.value not in self.choices:
274 def setValue(self, value):
275 if value in self.choices:
278 self._value = self.default
281 def tostring(self, val):
287 def setCurrentText(self, text):
288 i = self.choices.index(self.value)
289 self.choices[i] = text
290 self.description[text] = text
293 value = property(getValue, setValue)
296 return self.choices.index(self.value)
298 index = property(getIndex)
301 def handleKey(self, key):
302 nchoices = len(self.choices)
303 i = self.choices.index(self.value)
305 self.value = self.choices[(i + nchoices - 1) % nchoices]
306 elif key == KEY_RIGHT:
307 self.value = self.choices[(i + 1) % nchoices]
308 elif key == KEY_HOME:
309 self.value = self.choices[0]
311 self.value = self.choices[nchoices - 1]
313 def selectNext(self):
314 nchoices = len(self.choices)
315 i = self.choices.index(self.value)
316 self.value = self.choices[(i + 1) % nchoices]
319 descr = self.description[self.value]
324 def getMulti(self, selected):
325 descr = self.description[self.value]
327 return ("text", _(descr))
328 return ("text", descr)
331 def getHTML(self, id):
333 for v in self.choices:
334 descr = self.description[v]
336 checked = 'checked="checked" '
339 res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + descr + "</input></br>\n"
342 def unsafeAssign(self, value):
343 # setValue does check if value is in choices. This is safe enough.
346 description = property(lambda self: descriptionList(self.choices.choices, self.choices.type))
350 # several customized versions exist for different
353 boolean_descriptions = {False: "false", True: "true"}
354 class ConfigBoolean(ConfigElement):
355 def __init__(self, default = False, descriptions = boolean_descriptions):
356 ConfigElement.__init__(self)
357 self.descriptions = descriptions
358 self.value = self.last_value = self.default = default
360 def handleKey(self, key):
361 if key in [KEY_LEFT, KEY_RIGHT]:
362 self.value = not self.value
363 elif key == KEY_HOME:
369 descr = self.descriptions[self.value]
374 def getMulti(self, selected):
375 descr = self.descriptions[self.value]
377 return ("text", _(descr))
378 return ("text", descr)
380 def tostring(self, value):
386 def fromstring(self, val):
392 def getHTML(self, id):
394 checked = ' checked="checked"'
397 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
399 # this is FLAWED. and must be fixed.
400 def unsafeAssign(self, value):
406 def onDeselect(self, session):
407 if not self.last_value == self.value:
409 self.last_value = self.value
411 yes_no_descriptions = {False: _("no"), True: _("yes")}
412 class ConfigYesNo(ConfigBoolean):
413 def __init__(self, default = False):
414 ConfigBoolean.__init__(self, default = default, descriptions = yes_no_descriptions)
416 on_off_descriptions = {False: _("off"), True: _("on")}
417 class ConfigOnOff(ConfigBoolean):
418 def __init__(self, default = False):
419 ConfigBoolean.__init__(self, default = default, descriptions = on_off_descriptions)
421 enable_disable_descriptions = {False: _("disable"), True: _("enable")}
422 class ConfigEnableDisable(ConfigBoolean):
423 def __init__(self, default = False):
424 ConfigBoolean.__init__(self, default = default, descriptions = enable_disable_descriptions)
426 class ConfigDateTime(ConfigElement):
427 def __init__(self, default, formatstring, increment = 86400):
428 ConfigElement.__init__(self)
429 self.increment = increment
430 self.formatstring = formatstring
431 self.value = self.last_value = self.default = int(default)
433 def handleKey(self, key):
435 self.value = self.value - self.increment
436 elif key == KEY_RIGHT:
437 self.value = self.value + self.increment
438 elif key == KEY_HOME or key == KEY_END:
439 self.value = self.default
442 return strftime(self.formatstring, localtime(self.value))
444 def getMulti(self, selected):
445 return ("text", strftime(self.formatstring, localtime(self.value)))
447 def fromstring(self, val):
450 # *THE* mighty config element class
452 # allows you to store/edit a sequence of values.
453 # can be used for IP-addresses, dates, plain integers, ...
454 # several helper exist to ease this up a bit.
456 class ConfigSequence(ConfigElement):
457 def __init__(self, seperator, limits, default, censor_char = ""):
458 ConfigElement.__init__(self)
459 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
460 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
461 #assert isinstance(default, list), "default must be a list"
462 #assert isinstance(default[0], int), "list must contain numbers"
463 #assert len(default) == len(limits), "length must match"
466 self.seperator = seperator
468 self.censor_char = censor_char
470 self.last_value = self.default = default
471 self.value = copy_copy(default)
472 self.endNotifier = None
477 for i in self._value:
478 max_pos += len(str(self.limits[num][1]))
480 if self._value[num] < self.limits[num][0]:
481 self._value[num] = self.limits[num][0]
483 if self._value[num] > self.limits[num][1]:
484 self._value[num] = self.limits[num][1]
488 if self.marked_pos >= max_pos:
490 for x in self.endNotifier:
492 self.marked_pos = max_pos - 1
494 if self.marked_pos < 0:
497 def validatePos(self):
498 if self.marked_pos < 0:
501 total_len = sum([len(str(x[1])) for x in self.limits])
503 if self.marked_pos >= total_len:
504 self.marked_pos = total_len - 1
506 def addEndNotifier(self, notifier):
507 if endNotifier is None:
509 self.endNotifier.append(notifier)
511 def handleKey(self, key):
527 for i in self._value:
528 max_pos += len(str(self.limits[num][1]))
530 self.marked_pos = max_pos - 1
533 if key in KEY_NUMBERS or key == KEY_ASCII:
535 code = getPrevAsciiCode()
536 if code < 48 or code > 57:
540 number = getKeyNumber(key)
543 for x in self.limits:
544 block_len.append(len(str(x[1])))
546 total_len = sum(block_len)
550 block_len_total = [0, ]
552 pos += block_len[blocknumber]
553 block_len_total.append(pos)
554 if pos - 1 >= self.marked_pos:
559 # length of numberblock
560 number_len = len(str(self.limits[blocknumber][1]))
562 # position in the block
563 posinblock = self.marked_pos - block_len_total[blocknumber]
565 oldvalue = self._value[blocknumber]
566 olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
567 newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
569 self._value[blocknumber] = newvalue
577 mPos = self.marked_pos
579 for i in self._value:
580 if value: #fixme no heading separator possible
581 value += self.seperator
582 if mPos >= len(value) - 1:
584 if self.censor_char == "":
585 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
587 value += (self.censor_char * len(str(self.limits[num][1])))
592 (value, mPos) = self.genText()
595 def getMulti(self, selected):
596 (value, mPos) = self.genText()
597 # only mark cursor when we are selected
598 # (this code is heavily ink optimized!)
600 return ("mtext"[1-selected:], value, [mPos])
602 return ("text", value)
604 def tostring(self, val):
605 return self.seperator.join([self.saveSingle(x) for x in val])
607 def saveSingle(self, v):
610 def fromstring(self, value):
611 return [int(x) for x in value.split(self.seperator)]
613 def onDeselect(self, session):
614 if self.last_value != self._value:
616 self.last_value = copy_copy(self._value)
618 ip_limits = [(0,255),(0,255),(0,255),(0,255)]
619 class ConfigIP(ConfigSequence):
620 def __init__(self, default, auto_jump = False):
621 ConfigSequence.__init__(self, seperator = ".", limits = ip_limits, default = default)
623 for x in self.limits:
624 self.block_len.append(len(str(x[1])))
625 self.marked_block = 0
626 self.overwrite = True
627 self.auto_jump = auto_jump
629 def handleKey(self, key):
632 if self.marked_block > 0:
633 self.marked_block -= 1
634 self.overwrite = True
637 if self.marked_block < len(self.limits)-1:
638 self.marked_block += 1
639 self.overwrite = True
642 self.marked_block = 0
643 self.overwrite = True
646 self.marked_block = len(self.limits)-1
647 self.overwrite = True
649 if key in KEY_NUMBERS or key == KEY_ASCII:
651 code = getPrevAsciiCode()
652 if code < 48 or code > 57:
656 number = getKeyNumber(key)
657 oldvalue = self._value[self.marked_block]
660 self._value[self.marked_block] = number
661 self.overwrite = False
664 newvalue = oldvalue + number
665 if self.auto_jump and newvalue > self.limits[self.marked_block][1] and self.marked_block < len(self.limits)-1:
666 self.handleKey(KEY_RIGHT)
670 self._value[self.marked_block] = newvalue
672 if len(str(self._value[self.marked_block])) >= self.block_len[self.marked_block]:
673 self.handleKey(KEY_RIGHT)
681 for i in self._value:
682 block_strlen.append(len(str(i)))
684 value += self.seperator
686 leftPos = sum(block_strlen[:(self.marked_block)])+self.marked_block
687 rightPos = sum(block_strlen[:(self.marked_block+1)])+self.marked_block
688 mBlock = range(leftPos, rightPos)
689 return (value, mBlock)
691 def getMulti(self, selected):
692 (value, mBlock) = self.genText()
694 return ("mtext"[1-selected:], value, mBlock)
696 return ("text", value)
698 def getHTML(self, id):
699 # we definitely don't want leading zeros
700 return '.'.join(["%d" % d for d in self.value])
702 mac_limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)]
703 class ConfigMAC(ConfigSequence):
704 def __init__(self, default):
705 ConfigSequence.__init__(self, seperator = ":", limits = mac_limits, default = default)
707 class ConfigPosition(ConfigSequence):
708 def __init__(self, default, args):
709 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
711 clock_limits = [(0,23),(0,59)]
712 class ConfigClock(ConfigSequence):
713 def __init__(self, default):
714 t = localtime(default)
715 ConfigSequence.__init__(self, seperator = ":", limits = clock_limits, default = [t.tm_hour, t.tm_min])
718 # Check if Minutes maxed out
719 if self._value[1] == 59:
720 # Increment Hour, reset Minutes
721 if self._value[0] < 23:
733 # Check if Minutes is minimum
734 if self._value[1] == 0:
735 # Decrement Hour, set Minutes to 59
736 if self._value[0] > 0:
747 integer_limits = (0, 9999999999)
748 class ConfigInteger(ConfigSequence):
749 def __init__(self, default, limits = integer_limits):
750 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
752 # you need to override this to do input validation
753 def setValue(self, value):
754 self._value = [value]
758 return self._value[0]
760 value = property(getValue, setValue)
762 def fromstring(self, value):
765 def tostring(self, value):
768 class ConfigPIN(ConfigInteger):
769 def __init__(self, default, len = 4, censor = ""):
770 assert isinstance(default, int), "ConfigPIN default must be an integer"
773 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = default)
779 class ConfigFloat(ConfigSequence):
780 def __init__(self, default, limits):
781 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
784 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
786 float = property(getFloat)
788 # an editable text...
789 class ConfigText(ConfigElement, NumericalTextInput):
790 def __init__(self, default = "", fixed_size = True, visible_width = False):
791 ConfigElement.__init__(self)
792 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
795 self.allmarked = (default != "")
796 self.fixed_size = fixed_size
797 self.visible_width = visible_width
799 self.overwrite = fixed_size
800 self.help_window = None
801 self.value = self.last_value = self.default = default
803 def validateMarker(self):
805 if self.marked_pos > len(self.text)-1:
806 self.marked_pos = len(self.text)-1
808 if self.marked_pos > len(self.text):
809 self.marked_pos = len(self.text)
810 if self.marked_pos < 0:
812 if self.visible_width:
813 if self.marked_pos < self.offset:
814 self.offset = self.marked_pos
815 if self.marked_pos >= self.offset + self.visible_width:
816 if self.marked_pos == len(self.text):
817 self.offset = self.marked_pos - self.visible_width
819 self.offset = self.marked_pos - self.visible_width + 1
820 if self.offset > 0 and self.offset + self.visible_width > len(self.text):
821 self.offset = max(0, len(self.text) - self.visible_width)
823 def insertChar(self, ch, pos, owr):
824 if owr or self.overwrite:
825 self.text = self.text[0:pos] + ch + self.text[pos + 1:]
826 elif self.fixed_size:
827 self.text = self.text[0:pos] + ch + self.text[pos:-1]
829 self.text = self.text[0:pos] + ch + self.text[pos:]
831 def deleteChar(self, pos):
832 if not self.fixed_size:
833 self.text = self.text[0:pos] + self.text[pos + 1:]
835 self.text = self.text[0:pos] + " " + self.text[pos + 1:]
837 self.text = self.text[0:pos] + self.text[pos + 1:] + " "
839 def deleteAllChars(self):
841 self.text = " " * len(self.text)
846 def handleKey(self, key):
847 # this will no change anything on the value itself
848 # so we can handle it here in gui element
849 if key == KEY_DELETE:
852 self.deleteAllChars()
853 self.allmarked = False
855 self.deleteChar(self.marked_pos)
856 if self.fixed_size and self.overwrite:
858 elif key == KEY_BACKSPACE:
861 self.deleteAllChars()
862 self.allmarked = False
863 elif self.marked_pos > 0:
864 self.deleteChar(self.marked_pos-1)
865 if not self.fixed_size and self.offset > 0:
868 elif key == KEY_LEFT:
871 self.marked_pos = len(self.text)
872 self.allmarked = False
875 elif key == KEY_RIGHT:
879 self.allmarked = False
882 elif key == KEY_HOME:
884 self.allmarked = False
888 self.allmarked = False
889 self.marked_pos = len(self.text)
890 elif key == KEY_TOGGLEOW:
892 self.overwrite = not self.overwrite
893 elif key == KEY_ASCII:
895 newChar = unichr(getPrevAsciiCode())
897 self.deleteAllChars()
898 self.allmarked = False
899 self.insertChar(newChar, self.marked_pos, False)
901 elif key in KEY_NUMBERS:
902 owr = self.lastKey == getKeyNumber(key)
903 newChar = self.getKey(getKeyNumber(key))
905 self.deleteAllChars()
906 self.allmarked = False
907 self.insertChar(newChar, self.marked_pos, owr)
908 elif key == KEY_TIMEOUT:
911 self.help_window.update(self)
915 self.help_window.update(self)
916 self.validateMarker()
921 self.validateMarker()
925 return self.text.encode("utf-8")
927 def setValue(self, val):
929 self.text = val.decode("utf-8")
930 except UnicodeDecodeError:
931 self.text = val.decode("utf-8", "ignore")
934 value = property(getValue, setValue)
935 _value = property(getValue, setValue)
938 return self.text.encode("utf-8")
940 def getMulti(self, selected):
941 if self.visible_width:
943 mark = range(0, min(self.visible_width, len(self.text)))
945 mark = [self.marked_pos-self.offset]
946 return ("mtext"[1-selected:], self.text[self.offset:self.offset+self.visible_width].encode("utf-8")+" ", mark)
949 mark = range(0, len(self.text))
951 mark = [self.marked_pos]
952 return ("mtext"[1-selected:], self.text.encode("utf-8")+" ", mark)
954 def onSelect(self, session):
955 self.allmarked = (self.value != "")
956 if session is not None:
957 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
958 self.help_window = session.instantiateDialog(NumericalTextInputHelpDialog, self)
959 self.help_window.show()
961 def onDeselect(self, session):
965 session.deleteDialog(self.help_window)
966 self.help_window = None
967 if not self.last_value == self.value:
969 self.last_value = self.value
971 def getHTML(self, id):
972 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
974 def unsafeAssign(self, value):
975 self.value = str(value)
977 class ConfigPassword(ConfigText):
978 def __init__(self, default = "", fixed_size = False, visible_width = False, censor = "*"):
979 ConfigText.__init__(self, default = default, fixed_size = fixed_size, visible_width = visible_width)
980 self.censor_char = censor
983 def getMulti(self, selected):
984 mtext, text, mark = ConfigText.getMulti(self, selected)
986 text = len(text) * self.censor_char
987 return (mtext, text, mark)
989 def onSelect(self, session):
990 ConfigText.onSelect(self, session)
993 def onDeselect(self, session):
994 ConfigText.onDeselect(self, session)
997 class ConfigNumber(ConfigText):
998 def __init__(self, default = 0):
999 ConfigText.__init__(self, str(default), fixed_size = False)
1002 return int(self.text)
1004 def setValue(self, val):
1005 self.text = str(val)
1007 value = property(getValue, setValue)
1008 _value = property(getValue, setValue)
1011 pos = len(self.text) - self.marked_pos
1012 self.text = self.text.lstrip("0")
1015 if pos > len(self.text):
1018 self.marked_pos = len(self.text) - pos
1020 def handleKey(self, key):
1021 if key in KEY_NUMBERS or key == KEY_ASCII:
1022 if key == KEY_ASCII:
1023 ascii = getPrevAsciiCode()
1024 if not (48 <= ascii <= 57):
1027 ascii = getKeyNumber(key) + 48
1028 newChar = unichr(ascii)
1030 self.deleteAllChars()
1031 self.allmarked = False
1032 self.insertChar(newChar, self.marked_pos, False)
1033 self.marked_pos += 1
1035 ConfigText.handleKey(self, key)
1038 def onSelect(self, session):
1039 self.allmarked = (self.value != "")
1041 def onDeselect(self, session):
1044 if not self.last_value == self.value:
1046 self.last_value = self.value
1048 class ConfigSearchText(ConfigText):
1049 def __init__(self, default = "", fixed_size = False, visible_width = False):
1050 ConfigText.__init__(self, default = default, fixed_size = fixed_size, visible_width = visible_width)
1051 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False, search = True)
1053 class ConfigDirectory(ConfigText):
1054 def __init__(self, default="", visible_width=60):
1055 ConfigText.__init__(self, default, fixed_size = True, visible_width = visible_width)
1056 def handleKey(self, key):
1062 return ConfigText.getValue(self)
1063 def setValue(self, val):
1066 ConfigText.setValue(self, val)
1067 def getMulti(self, selected):
1069 return ("mtext"[1-selected:], _("List of Storage Devices"), range(0))
1071 return ConfigText.getMulti(self, selected)
1074 class ConfigSlider(ConfigElement):
1075 def __init__(self, default = 0, increment = 1, limits = (0, 100)):
1076 ConfigElement.__init__(self)
1077 self.value = self.last_value = self.default = default
1078 self.min = limits[0]
1079 self.max = limits[1]
1080 self.increment = increment
1082 def checkValues(self):
1083 if self.value < self.min:
1084 self.value = self.min
1086 if self.value > self.max:
1087 self.value = self.max
1089 def handleKey(self, key):
1091 self.value -= self.increment
1092 elif key == KEY_RIGHT:
1093 self.value += self.increment
1094 elif key == KEY_HOME:
1095 self.value = self.min
1096 elif key == KEY_END:
1097 self.value = self.max
1103 return "%d / %d" % (self.value, self.max)
1105 def getMulti(self, selected):
1107 return ("slider", self.value, self.max)
1109 def fromstring(self, value):
1112 # a satlist. in fact, it's a ConfigSelection.
1113 class ConfigSatlist(ConfigSelection):
1114 def __init__(self, list, default = None):
1115 if default is not None:
1116 default = str(default)
1117 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc, flags) in list], default = default)
1119 def getOrbitalPosition(self):
1120 if self.value == "":
1122 return int(self.value)
1124 orbital_position = property(getOrbitalPosition)
1126 class ConfigSet(ConfigElement):
1127 def __init__(self, choices, default = []):
1128 ConfigElement.__init__(self)
1129 if isinstance(choices, list):
1131 self.choices = choicesList(choices, choicesList.LIST_TYPE_LIST)
1133 assert False, "ConfigSet choices must be a list!"
1138 self.last_value = self.default = default
1139 self.value = default[:]
1141 def toggleChoice(self, choice):
1142 if choice in self.value:
1143 self.value.remove(choice)
1145 self.value.append(choice)
1149 def handleKey(self, key):
1150 if key in KEY_NUMBERS + [KEY_DELETE, KEY_BACKSPACE]:
1152 self.toggleChoice(self.choices[self.pos])
1153 elif key == KEY_LEFT:
1156 self.pos = len(self.choices)-1
1157 elif key == KEY_RIGHT:
1159 if self.pos >= len(self.choices):
1161 elif key in [KEY_HOME, KEY_END]:
1164 def genString(self, lst):
1167 res += self.description[x]+" "
1171 return self.genString(self.value)
1173 def getMulti(self, selected):
1174 if not selected or self.pos == -1:
1175 return ("text", self.genString(self.value))
1178 ch = self.choices[self.pos]
1179 mem = ch in self.value
1184 val1 = self.genString(tmp[:ind])
1185 val2 = " "+self.genString(tmp[ind+1:])
1187 chstr = " "+self.description[ch]+" "
1189 chstr = "("+self.description[ch]+")"
1190 return ("mtext", val1+chstr+val2, range(len(val1),len(val1)+len(chstr)))
1192 def onDeselect(self, session):
1194 if not self.last_value == self.value:
1196 self.last_value = self.value[:]
1198 def tostring(self, value):
1201 def fromstring(self, val):
1204 description = property(lambda self: descriptionList(self.choices.choices, choicesList.LIST_TYPE_LIST))
1206 class ConfigLocations(ConfigElement):
1207 def __init__(self, default = [], visible_width = False):
1208 ConfigElement.__init__(self)
1209 self.visible_width = visible_width
1211 self.default = default
1213 self.mountpoints = []
1214 harddiskmanager.on_partition_list_change.append(self.mountpointsChanged)
1215 self.value = default+[]
1217 def setValue(self, value):
1218 loc = [x[0] for x in self.locations if x[3]]
1219 add = [x for x in value if not x in loc]
1220 diff = add + [x for x in loc if not x in value]
1221 self.locations = [x for x in self.locations if not x[0] in diff] + [[x, self.getMountpoint(x), True, True] for x in add]
1222 self.locations.sort(key = lambda x: x[0])
1226 self.checkChangedMountpoints()
1227 for x in self.locations:
1229 return [x[0] for x in self.locations if x[3]]
1231 value = property(getValue, setValue)
1233 def tostring(self, value):
1236 def fromstring(self, val):
1240 sv = self.saved_value
1244 tmp = self.fromstring(sv)
1245 self.locations = [[x, None, False, False] for x in tmp]
1246 self.refreshMountpoints()
1247 for x in self.locations:
1248 if os_path.exists(x[0]):
1249 x[1] = self.getMountpoint(x[0])
1253 if self.save_disabled or self.locations == []:
1254 self.saved_value = None
1256 self.saved_value = self.tostring([x[0] for x in self.locations])
1258 def isChanged(self):
1259 sv = self.saved_value
1260 if val is None and self.locations == []:
1262 return self.tostring([x[0] for x in self.locations]) != sv
1264 def mountpointsChanged(self, action, dev):
1265 print "Mounts changed: ", action, dev
1266 mp = dev.mountpoint+"/"
1269 elif action == "remove":
1270 self.removedMount(mp)
1271 self.refreshMountpoints()
1273 def addedMount(self, mp):
1274 for x in self.locations:
1277 elif x[1] == None and os_path.exists(x[0]):
1278 x[1] = self.getMountpoint(x[0])
1281 def removedMount(self, mp):
1282 for x in self.locations:
1286 def refreshMountpoints(self):
1287 self.mountpoints = [p.mountpoint + "/" for p in harddiskmanager.getMountedPartitions() if p.mountpoint != "/"]
1288 self.mountpoints.sort(key = lambda x: -len(x))
1290 def checkChangedMountpoints(self):
1291 oldmounts = self.mountpoints
1292 self.refreshMountpoints()
1293 if oldmounts == self.mountpoints:
1296 if not x in self.mountpoints:
1297 self.removedMount(x)
1298 for x in self.mountpoints:
1299 if not x in oldmounts:
1302 def getMountpoint(self, file):
1303 file = os_path.realpath(file)+"/"
1304 for m in self.mountpoints:
1305 if file.startswith(m):
1309 def handleKey(self, key):
1313 self.pos = len(self.value)-1
1314 elif key == KEY_RIGHT:
1316 if self.pos >= len(self.value):
1318 elif key in [KEY_HOME, KEY_END]:
1322 return " ".join(self.value)
1324 def getMulti(self, selected):
1326 valstr = " ".join(self.value)
1327 if self.visible_width and len(valstr) > self.visible_width:
1328 return ("text", valstr[0:self.visible_width])
1330 return ("text", valstr)
1336 for val in self.value:
1339 valstr += str(val)+" "
1343 if self.visible_width and len(valstr) > self.visible_width:
1344 if ind1+1 < self.visible_width/2:
1347 off = min(ind1+1-self.visible_width/2, len(valstr)-self.visible_width)
1348 return ("mtext", valstr[off:off+self.visible_width], range(ind1-off,ind2-off))
1350 return ("mtext", valstr, range(ind1,ind2))
1352 def onDeselect(self, session):
1356 class ConfigNothing(ConfigSelection):
1358 ConfigSelection.__init__(self, choices = [""])
1360 # until here, 'saved_value' always had to be a *string*.
1361 # now, in ConfigSubsection, and only there, saved_value
1362 # is a dict, essentially forming a tree.
1364 # config.foo.bar=True
1365 # config.foobar=False
1368 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
1372 class ConfigSubsectionContent(object):
1375 # we store a backup of the loaded configuration
1376 # data in self.stored_values, to be able to deploy
1377 # them when a new config element will be added,
1378 # so non-default values are instantly available
1380 # A list, for example:
1381 # config.dipswitches = ConfigSubList()
1382 # config.dipswitches.append(ConfigYesNo())
1383 # config.dipswitches.append(ConfigYesNo())
1384 # config.dipswitches.append(ConfigYesNo())
1385 class ConfigSubList(list, object):
1387 object.__init__(self)
1389 self.stored_values = {}
1399 def getSavedValue(self):
1401 for i in range(len(self)):
1402 sv = self[i].saved_value
1407 def setSavedValue(self, values):
1408 self.stored_values = dict(values)
1409 for (key, val) in self.stored_values.items():
1410 if int(key) < len(self):
1411 self[int(key)].saved_value = val
1413 saved_value = property(getSavedValue, setSavedValue)
1415 def append(self, item):
1417 list.append(self, item)
1418 if i in self.stored_values:
1419 item.saved_value = self.stored_values[i]
1423 return dict([(str(index), value) for index, value in self.enumerate()])
1425 # same as ConfigSubList, just as a dictionary.
1426 # care must be taken that the 'key' has a proper
1427 # str() method, because it will be used in the config
1429 class ConfigSubDict(dict, object):
1431 object.__init__(self)
1433 self.stored_values = {}
1436 for x in self.values():
1440 for x in self.values():
1443 def getSavedValue(self):
1445 for (key, val) in self.items():
1446 sv = val.saved_value
1451 def setSavedValue(self, values):
1452 self.stored_values = dict(values)
1453 for (key, val) in self.items():
1454 if str(key) in self.stored_values:
1455 val = self.stored_values[str(key)]
1457 saved_value = property(getSavedValue, setSavedValue)
1459 def __setitem__(self, key, item):
1460 dict.__setitem__(self, key, item)
1461 if str(key) in self.stored_values:
1462 item.saved_value = self.stored_values[str(key)]
1468 # Like the classes above, just with a more "native"
1471 # some evil stuff must be done to allow instant
1472 # loading of added elements. this is why this class
1475 # we need the 'content' because we overwrite
1477 # If you don't understand this, try adding
1478 # __setattr__ to a usual exisiting class and you will.
1479 class ConfigSubsection(object):
1481 object.__init__(self)
1482 self.__dict__["content"] = ConfigSubsectionContent()
1483 self.content.items = { }
1484 self.content.stored_values = { }
1486 def __setattr__(self, name, value):
1487 if name == "saved_value":
1488 return self.setSavedValue(value)
1489 assert isinstance(value, (ConfigSubsection, ConfigElement, ConfigSubList, ConfigSubDict)), "ConfigSubsections can only store ConfigSubsections, ConfigSubLists, ConfigSubDicts or ConfigElements"
1490 self.content.items[name] = value
1491 x = self.content.stored_values.get(name, None)
1493 #print "ok, now we have a new item,", name, "and have the following value for it:", x
1494 value.saved_value = x
1497 def __getattr__(self, name):
1498 return self.content.items[name]
1500 def getSavedValue(self):
1501 res = self.content.stored_values
1502 for (key, val) in self.content.items.items():
1503 sv = val.saved_value
1510 def setSavedValue(self, values):
1511 values = dict(values)
1512 self.content.stored_values = values
1513 for (key, val) in self.content.items.items():
1514 value = values.get(key, None)
1515 if value is not None:
1516 val.saved_value = value
1518 saved_value = property(getSavedValue, setSavedValue)
1521 for x in self.content.items.values():
1525 for x in self.content.items.values():
1529 return self.content.items
1531 # the root config object, which also can "pickle" (=serialize)
1532 # down the whole config tree.
1534 # we try to keep non-existing config entries, to apply them whenever
1535 # a new config entry is added to a subsection
1536 # also, non-existing config entries will be saved, so they won't be
1537 # lost when a config entry disappears.
1538 class Config(ConfigSubsection):
1540 ConfigSubsection.__init__(self)
1542 def pickle_this(self, prefix, topickle, result):
1543 for (key, val) in topickle.items():
1544 name = ''.join((prefix, '.', key))
1545 if isinstance(val, dict):
1546 self.pickle_this(name, val, result)
1547 elif isinstance(val, tuple):
1548 result += [name, '=', val[0], '\n']
1550 result += [name, '=', val, '\n']
1554 self.pickle_this("config", self.saved_value, result)
1555 return ''.join(result)
1557 def unpickle(self, lines):
1560 if not l or l[0] == '#':
1564 val = l[n+1:].strip()
1566 names = l[:n].split('.')
1567 # if val.find(' ') != -1:
1568 # val = val[:val.find(' ')]
1572 for n in names[:-1]:
1573 base = base.setdefault(n, {})
1575 base[names[-1]] = val
1577 # we inherit from ConfigSubsection, so ...
1578 #object.__setattr__(self, "saved_value", tree["config"])
1579 if "config" in tree:
1580 self.setSavedValue(tree["config"])
1582 def saveToFile(self, filename):
1583 f = open(filename, "w")
1584 f.write(self.pickle())
1587 def loadFromFile(self, filename):
1588 f = open(filename, "r")
1589 self.unpickle(f.readlines())
1593 config.misc = ConfigSubsection()
1596 CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "settings")
1600 config.loadFromFile(self.CONFIG_FILE)
1602 print "unable to load config (%s), assuming defaults..." % str(e)
1606 config.saveToFile(self.CONFIG_FILE)
1608 def __resolveValue(self, pickles, cmap):
1609 if cmap.has_key(pickles[0]):
1610 if len(pickles) > 1:
1611 return self.__resolveValue(pickles[1:], cmap[pickles[0]].dict())
1613 return str(cmap[pickles[0]].value)
1616 def getResolvedKey(self, key):
1617 names = key.split('.')
1619 if names[0] == "config":
1620 ret=self.__resolveValue(names[1:], config.content.items)
1621 if ret and len(ret):
1623 print "getResolvedKey", key, "failed !! (Typo??)"
1626 def NoSave(element):
1627 element.disableSave()
1630 configfile = ConfigFile()
1634 def getConfigListEntry(*args):
1635 assert len(args) > 1, "getConfigListEntry needs a minimum of two arguments (descr, configElement)"
1638 def updateConfigElement(element, newelement):
1639 newelement.value = element.value
1645 #config.bla = ConfigSubsection()
1646 #config.bla.test = ConfigYesNo()
1647 #config.nim = ConfigSubList()
1648 #config.nim.append(ConfigSubsection())
1649 #config.nim[0].bla = ConfigYesNo()
1650 #config.nim.append(ConfigSubsection())
1651 #config.nim[1].bla = ConfigYesNo()
1652 #config.nim[1].blub = ConfigYesNo()
1653 #config.arg = ConfigSubDict()
1654 #config.arg["Hello"] = ConfigYesNo()
1656 #config.arg["Hello"].handleKey(KEY_RIGHT)
1657 #config.arg["Hello"].handleKey(KEY_RIGHT)
1659 ##config.saved_value
1663 #print config.pickle()