# saved_value is a text representation of _value, stored in the config file
#
# and has (at least) the following methods:
-# save() stores _value into saved_value,
+# save() stores _value into saved_value,
# (or stores 'None' if it should not be stored)
# load() loads _value from saved_value, or loads
# the default if saved_value is 'None' (default)
self.__notifiers = [ ]
return self.__notifiers
- notifiers = property(getNotifiers)
+ def setNotifiers(self, val):
+ self.__notifiers = val
+
+ notifiers = property(getNotifiers, setNotifiers)
def getNotifiersFinal(self):
if self.__notifiers_final is None:
self.__notifiers_final = [ ]
return self.__notifiers_final
- notifiers_final = property(getNotifiersFinal)
+ def setNotifiersFinal(self, val):
+ self.__notifiers_final = val
+
+ notifiers_final = property(getNotifiersFinal, setNotifiersFinal)
# you need to override this to do input validation
def setValue(self, value):
def getValue(self):
return self._value
-
+
value = property(getValue, setValue)
# you need to override this if self.value is not a string
if self.__notifiers:
for x in self.notifiers:
x(self)
-
+
def changedFinal(self):
if self.__notifiers_final:
for x in self.notifiers_final:
x(self)
-
+
def addNotifier(self, notifier, initial_call = True, immediate_feedback = True):
assert callable(notifier), "notifiers must be callable"
if immediate_feedback:
def __list__(self):
if self.type == choicesList.LIST_TYPE_LIST:
- ret = [isinstance(x, tuple) and x[0] or x for x in self.choices]
+ ret = [not isinstance(x, tuple) and x or x[0] for x in self.choices]
else:
ret = self.choices.keys()
return ret or [""]
def __iter__(self):
if self.type == choicesList.LIST_TYPE_LIST:
- ret = [isinstance(x, tuple) and x[0] or x for x in self.choices]
+ ret = [not isinstance(x, tuple) and x or x[0] for x in self.choices]
else:
ret = self.choices
return iter(ret or [""])
class descriptionList(choicesList): # XXX: we might want a better name for this
def __list__(self):
if self.type == choicesList.LIST_TYPE_LIST:
- ret = [isinstance(x, tuple) and x[1] or x for x in self.choices]
+ ret = [not isinstance(x, tuple) and x or x[1] for x in self.choices]
else:
ret = self.choices.values()
return ret or [""]
if default is None:
default = self.choices.default()
+ self._descr = None
self.default = self._value = self.last_value = default
self.changed()
self._value = value
else:
self._value = self.default
+ self._descr = None
self.changed()
def tostring(self, val):
def setCurrentText(self, text):
i = self.choices.index(self.value)
self.choices[i] = text
- self.description[text] = text
+ self._descr = self.description[text] = text
self._value = text
value = property(getValue, setValue)
-
+
def getIndex(self):
return self.choices.index(self.value)
-
+
index = property(getIndex)
# GUI
self.value = self.choices[(i + 1) % nchoices]
def getText(self):
- descr = self.description[self.value]
+ if self._descr is not None:
+ return self._descr
+ descr = self._descr = self.description[self.value]
if descr:
return _(descr)
return descr
def getMulti(self, selected):
- descr = self.description[self.value]
+ if self._descr is not None:
+ descr = self._descr
+ else:
+ descr = self._descr = self.description[self.value]
if descr:
return ("text", _(descr))
return ("text", descr)
self.value = self.last_value = self.default = default
def handleKey(self, key):
- if key in [KEY_LEFT, KEY_RIGHT]:
+ if key in (KEY_LEFT, KEY_RIGHT):
self.value = not self.value
elif key == KEY_HOME:
self.value = False
num += 1
if self.marked_pos >= max_pos:
- if endNotifier:
+ if self.endNotifier:
for x in self.endNotifier:
x(self)
self.marked_pos = max_pos - 1
self.marked_pos = total_len - 1
def addEndNotifier(self, notifier):
- if endNotifier is None:
- endNotifier = []
+ if self.endNotifier is None:
+ self.endNotifier = []
self.endNotifier.append(notifier)
def handleKey(self, key):
self.marked_pos -= 1
self.validatePos()
- if key == KEY_RIGHT:
+ elif key == KEY_RIGHT:
self.marked_pos += 1
self.validatePos()
- if key == KEY_HOME:
+ elif key == KEY_HOME:
self.marked_pos = 0
self.validatePos()
- if key == KEY_END:
+ elif key == KEY_END:
max_pos = 0
num = 0
for i in self._value:
self.marked_pos = max_pos - 1
self.validatePos()
- if key in KEY_NUMBERS or key == KEY_ASCII:
+ elif key in KEY_NUMBERS or key == KEY_ASCII:
if key == KEY_ASCII:
code = getPrevAsciiCode()
if code < 48 or code > 57:
else:
number = getKeyNumber(key)
- block_len = []
- for x in self.limits:
- block_len.append(len(str(x[1])))
-
+ block_len = [len(str(x[1])) for x in self.limits]
total_len = sum(block_len)
pos = 0
class ConfigIP(ConfigSequence):
def __init__(self, default, auto_jump = False):
ConfigSequence.__init__(self, seperator = ".", limits = ip_limits, default = default)
- self.block_len = []
- for x in self.limits:
- self.block_len.append(len(str(x[1])))
+ self.block_len = [len(str(x[1])) for x in self.limits]
self.marked_block = 0
self.overwrite = True
self.auto_jump = auto_jump
def handleKey(self, key):
-
if key == KEY_LEFT:
if self.marked_block > 0:
self.marked_block -= 1
self.overwrite = True
- if key == KEY_RIGHT:
+ elif key == KEY_RIGHT:
if self.marked_block < len(self.limits)-1:
self.marked_block += 1
self.overwrite = True
- if key == KEY_HOME:
+ elif key == KEY_HOME:
self.marked_block = 0
self.overwrite = True
- if key == KEY_END:
+ elif key == KEY_END:
self.marked_block = len(self.limits)-1
self.overwrite = True
- if key in KEY_NUMBERS or key == KEY_ASCII:
+ elif key in KEY_NUMBERS or key == KEY_ASCII:
if key == KEY_ASCII:
code = getPrevAsciiCode()
if code < 48 or code > 57:
return
number = code - 48
- else:
+ else:
number = getKeyNumber(key)
oldvalue = self._value[self.marked_block]
-
+
if self.overwrite:
self._value[self.marked_block] = number
- self.overwrite = False
+ self.overwrite = False
else:
oldvalue *= 10
newvalue = oldvalue + number
value = ""
block_strlen = []
for i in self._value:
- block_strlen.append(len(str(i)))
+ block_strlen.append(len(str(i)))
if value:
value += self.seperator
value += str(i)
rightPos = sum(block_strlen[:(self.marked_block+1)])+self.marked_block
mBlock = range(leftPos, rightPos)
return (value, mBlock)
-
+
def getMulti(self, selected):
(value, mBlock) = self.genText()
if self.enabled:
class ConfigInteger(ConfigSequence):
def __init__(self, default, limits = integer_limits):
ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
-
+
# you need to override this to do input validation
def setValue(self, value):
self._value = [value]
def __init__(self, default = "", fixed_size = True, visible_width = False):
ConfigElement.__init__(self)
NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
-
+
self.marked_pos = 0
self.allmarked = (default != "")
self.fixed_size = fixed_size
self.value = self.last_value = self.default = default
def validateMarker(self):
+ textlen = len(self.text)
if self.fixed_size:
- if self.marked_pos > len(self.text)-1:
- self.marked_pos = len(self.text)-1
+ if self.marked_pos > textlen-1:
+ self.marked_pos = textlen-1
else:
- if self.marked_pos > len(self.text):
- self.marked_pos = len(self.text)
+ if self.marked_pos > textlen:
+ self.marked_pos = textlen
if self.marked_pos < 0:
self.marked_pos = 0
if self.visible_width:
if self.marked_pos < self.offset:
self.offset = self.marked_pos
if self.marked_pos >= self.offset + self.visible_width:
- if self.marked_pos == len(self.text):
+ if self.marked_pos == textlen:
self.offset = self.marked_pos - self.visible_width
else:
self.offset = self.marked_pos - self.visible_width + 1
- if self.offset > 0 and self.offset + self.visible_width > len(self.text):
- self.offset = max(0, len(self.text) - self.visible_width)
+ if self.offset > 0 and self.offset + self.visible_width > textlen:
+ self.offset = max(0, len - self.visible_width)
def insertChar(self, ch, pos, owr):
if owr or self.overwrite:
def getValue(self):
return int(self.text)
-
+
def setValue(self, val):
self.text = str(val)
class ConfigDirectory(ConfigText):
def __init__(self, default="", visible_width=60):
ConfigText.__init__(self, default, fixed_size = True, visible_width = visible_width)
+
def handleKey(self, key):
pass
+
def getValue(self):
if self.text == "":
return None
else:
return ConfigText.getValue(self)
+
def setValue(self, val):
if val == None:
val = ""
ConfigText.setValue(self, val)
+
def getMulti(self, selected):
if self.text == "":
return ("mtext"[1-selected:], _("List of Storage Devices"), range(0))
if self.value == "":
return None
return int(self.value)
-
+
orbital_position = property(getOrbitalPosition)
class ConfigSet(ConfigElement):
self.value = default[:]
def toggleChoice(self, choice):
- if choice in self.value:
- self.value.remove(choice)
+ value = self.value
+ if choice in value:
+ value.remove(choice)
else:
- self.value.append(choice)
- self.value.sort()
+ value.append(choice)
+ value.sort()
self.changed()
def handleKey(self, key):
if self.pos != -1:
self.toggleChoice(self.choices[self.pos])
elif key == KEY_LEFT:
- self.pos -= 1
- if self.pos < -1:
- self.pos = len(self.choices)-1
+ if self.pos < 0:
+ self.pos = len(self.choices)-1
+ else:
+ self.pos -= 1
elif key == KEY_RIGHT:
- self.pos += 1
- if self.pos >= len(self.choices):
- self.pos = -1
- elif key in [KEY_HOME, KEY_END]:
+ if self.pos >= len(self.choices)-1:
+ self.pos = -1
+ else:
+ self.pos += 1
+ elif key in (KEY_HOME, KEY_END):
self.pos = -1
def genString(self, lst):
chstr = " "+self.description[ch]+" "
else:
chstr = "("+self.description[ch]+")"
- return ("mtext", val1+chstr+val2, range(len(val1),len(val1)+len(chstr)))
+ len_val1 = len(val1)
+ return ("mtext", val1+chstr+val2, range(len_val1, len_val1 + len(chstr)))
def onDeselect(self, session):
self.pos = -1
if not self.last_value == self.value:
self.changedFinal()
self.last_value = self.value[:]
-
+
def tostring(self, value):
return str(value)
self.locations = []
self.mountpoints = []
harddiskmanager.on_partition_list_change.append(self.mountpointsChanged)
- self.value = default+[]
+ self.value = default[:]
def setValue(self, value):
- loc = [x[0] for x in self.locations if x[3]]
+ locations = self.locations
+ loc = [x[0] for x in locations if x[3]]
add = [x for x in value if not x in loc]
diff = add + [x for x in loc if not x in value]
- self.locations = [x for x in self.locations if not x[0] in diff] + [[x, self.getMountpoint(x), True, True] for x in add]
- self.locations.sort(key = lambda x: x[0])
+ locations = [x for x in locations if not x[0] in diff] + [[x, self.getMountpoint(x), True, True] for x in add]
+ locations.sort(key = lambda x: x[0])
+ self.locations = locations
self.changed()
def getValue(self):
self.checkChangedMountpoints()
- for x in self.locations:
+ locations = self.locations
+ for x in locations:
x[3] = x[2]
- return [x[0] for x in self.locations if x[3]]
-
+ return [x[0] for x in locations if x[3]]
+
value = property(getValue, setValue)
def tostring(self, value):
tmp = self.default
else:
tmp = self.fromstring(sv)
- self.locations = [[x, None, False, False] for x in tmp]
+ locations = [[x, None, False, False] for x in tmp]
self.refreshMountpoints()
- for x in self.locations:
+ for x in locations:
if os_path.exists(x[0]):
x[1] = self.getMountpoint(x[0])
x[2] = True
+ self.locations = locations
def save(self):
- if self.save_disabled or self.locations == []:
+ locations = self.locations
+ if self.save_disabled or not locations:
self.saved_value = None
else:
- self.saved_value = self.tostring([x[0] for x in self.locations])
+ self.saved_value = self.tostring([x[0] for x in locations])
def isChanged(self):
sv = self.saved_value
- if val is None and self.locations == []:
+ locations = self.locations
+ if val is None and not locations:
return False
- return self.tostring([x[0] for x in self.locations]) != sv
+ return self.tostring([x[0] for x in locations]) != sv
def mountpointsChanged(self, action, dev):
print "Mounts changed: ", action, dev
for x in self.locations:
if x[1] == mp:
x[2] = False
-
+
def refreshMountpoints(self):
self.mountpoints = [p.mountpoint + "/" for p in harddiskmanager.getMountedPartitions() if p.mountpoint != "/"]
self.mountpoints.sort(key = lambda x: -len(x))
def checkChangedMountpoints(self):
oldmounts = self.mountpoints
self.refreshMountpoints()
- if oldmounts == self.mountpoints:
+ newmounts = self.mountpoints
+ if oldmounts == newmounts:
return
for x in oldmounts:
- if not x in self.mountpoints:
+ if not x in newmounts:
self.removedMount(x)
- for x in self.mountpoints:
+ for x in newmounts:
if not x in oldmounts:
self.addedMount(x)
if key == KEY_LEFT:
self.pos -= 1
if self.pos < -1:
- self.pos = len(self.value)-1
+ self.pos = len(self.value)-1
elif key == KEY_RIGHT:
self.pos += 1
if self.pos >= len(self.value):
- self.pos = -1
- elif key in [KEY_HOME, KEY_END]:
+ self.pos = -1
+ elif key in (KEY_HOME, KEY_END):
self.pos = -1
def getText(self):
def onDeselect(self, session):
self.pos = -1
-
+
# nothing.
class ConfigNothing(ConfigSelection):
def __init__(self):
- ConfigSelection.__init__(self, choices = [""])
+ ConfigSelection.__init__(self, choices = [("","")])
# until here, 'saved_value' always had to be a *string*.
# now, in ConfigSubsection, and only there, saved_value
def save(self):
for x in self:
x.save()
-
+
def load(self):
for x in self:
x.load()
def getSavedValue(self):
res = { }
- for i in range(len(self)):
- sv = self[i].saved_value
+ for i, val in enumerate(self):
+ sv = val.saved_value
if sv is not None:
res[str(i)] = sv
return res
item.load()
def dict(self):
- return dict([(str(index), value) for index, value in self.enumerate()])
+ return dict([(str(index), value) for index, value in enumerate(self)])
# same as ConfigSubList, just as a dictionary.
# care must be taken that the 'key' has a proper
def save(self):
for x in self.values():
x.save()
-
+
def load(self):
for x in self.values():
x.load()
# loading of added elements. this is why this class
# is so complex.
#
-# we need the 'content' because we overwrite
+# we need the 'content' because we overwrite
# __setattr__.
# If you don't understand this, try adding
# __setattr__ to a usual exisiting class and you will.
self.__dict__["content"] = ConfigSubsectionContent()
self.content.items = { }
self.content.stored_values = { }
-
+
def __setattr__(self, name, value):
if name == "saved_value":
return self.setSavedValue(value)
def pickle_this(self, prefix, topickle, result):
for (key, val) in topickle.items():
- name = ''.join((prefix, '.', key))
+ name = '.'.join((prefix, key))
if isinstance(val, dict):
self.pickle_this(name, val, result)
elif isinstance(val, tuple):
for l in lines:
if not l or l[0] == '#':
continue
-
+
n = l.find('=')
val = l[n+1:].strip()
# val = val[:val.find(' ')]
base = tree
-
+
for n in names[:-1]:
base = base.setdefault(n, {})
-
+
base[names[-1]] = val
# we inherit from ConfigSubsection, so ...
self.setSavedValue(tree["config"])
def saveToFile(self, filename):
+ text = self.pickle()
f = open(filename, "w")
- f.write(self.pickle())
+ f.write(text)
f.close()
def loadFromFile(self, filename):
config.loadFromFile(self.CONFIG_FILE)
except IOError, e:
print "unable to load config (%s), assuming defaults..." % str(e)
-
+
def save(self):
# config.save()
config.saveToFile(self.CONFIG_FILE)
-
+
def __resolveValue(self, pickles, cmap):
- if cmap.has_key(pickles[0]):
+ key = pickles[0]
+ if cmap.has_key(key):
if len(pickles) > 1:
- return self.__resolveValue(pickles[1:], cmap[pickles[0]].dict())
+ return self.__resolveValue(pickles[1:], cmap[key].dict())
else:
- return str(cmap[pickles[0]].value)
+ return str(cmap[key].value)
return None
-
+
def getResolvedKey(self, key):
names = key.split('.')
if len(names) > 1:
git.cweiske.de / enigma2.git / blobdiff