code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Components/config.py

   1 from time import *
   2 from Tools.NumericalTextInput import *
   3
   4 class configFile:
   5         def __init__(self):
   6                 self.changed = 0
   7                 self.configElements = { }
   8                 try:
   9                         self.file = open("config")
  10                 except IOError:
  11                         print "cannot open config file"
  12                         return
  13
  14                 while 1:
  15                         line = self.file.readline()
  16                         if line == "":
  17                                 break
  18
  19                         if line.startswith("#"):                #skip comments
  20                                 continue
  21
  22                         self.addElement(line)
  23                 self.file.close()
  24
  25         def addElement(self, line):
  26                 x = line.find("=")
  27                 if x > -1:
  28                         self.configElements[line[:x]] = line[x + 1:]
  29
  30         def getKey(self, key):
  31                 return self.configElements[key]
  32
  33         def setKey(self, key, value):
  34                 self.changed = 1
  35                 self.configElements[key] = value
  36
  37         def save(self):
  38                 if self.changed == 0:           #no changes, so no write to disk needed
  39                         return
  40
  41                 fileHandle = open("config", "w")
  42
  43                 keys = self.configElements.keys()
  44                 keys.sort()
  45                 for x in keys:
  46                         wstr = x + "=" + self.configElements[x]
  47
  48                         if wstr[len(wstr) - 1] != '\n':
  49                                 wstr = wstr + "\n"
  50
  51                         fileHandle.write(wstr)
  52
  53                 fileHandle.close()
  54
  55 class configSelection:
  56         def __init__(self, parent):
  57                 self.parent = parent
  58
  59         def checkValues(self):
  60                 if self.parent.value < 0:
  61                         self.parent.value = 0
  62
  63                 if(self.parent.value >= (len(self.parent.vals) - 1)):
  64                         self.parent.value = len(self.parent.vals) - 1
  65
  66         def cancel(self):
  67                 self.parent.reload()
  68
  69         def save(self):
  70                 self.parent.save()
  71
  72         def handleKey(self, key):
  73                 if key == config.key["prevElement"]:
  74                         self.parent.value = self.parent.value - 1
  75                 if key == config.key["nextElement"]:
  76                         self.parent.value = self.parent.value + 1
  77
  78                 self.checkValues()
  79
  80                 self.parent.change()
  81
  82         def __call__(self, selected):                   #needed by configlist
  83                 self.checkValues()
  84                 return ("text", self.parent.vals[self.parent.value])
  85
  86 class configDateTime:
  87         def __init__(self, parent):
  88                 self.parent = parent
  89
  90         def checkValues(self):
  91                 pass
  92 #               if self.parent.value < 0:
  93                         #self.parent.value = 0
  94
  95                 #if(self.parent.value >= (len(self.parent.vals) - 1)):
  96                         #self.parent.value = len(self.parent.vals) - 1
  97
  98         def cancel(self):
  99                 self.parent.reload()
 100
 101         def save(self):
 102                 self.parent.save()
 103
 104         def handleKey(self, key):
 105                 if key == config.key["prevElement"]:
 106                         self.parent.value = self.parent.value - self.parent.vals[1]
 107                 if key == config.key["nextElement"]:
 108                         self.parent.value = self.parent.value + self.parent.vals[1]
 109
 110                 self.checkValues()
 111
 112                 self.parent.change()
 113
 114         def __call__(self, selected):                   #needed by configlist
 115                 self.checkValues()
 116                 return ("text", strftime(self.parent.vals[0], localtime(self.parent.value)))
 117
 118 class configSatlist:
 119         def __init__(self, parent):
 120                 self.parent = parent
 121
 122         def checkValues(self):
 123                 if self.parent.value < 0:
 124                         self.parent.value = 0
 125
 126                 if(self.parent.value >= (len(self.parent.vals) - 1)):
 127                         self.parent.value = len(self.parent.vals) - 1
 128
 129         def cancel(self):
 130                 self.parent.reload()
 131
 132         def save(self):
 133                 self.parent.save()
 134
 135         def handleKey(self, key):
 136                 if key == config.key["prevElement"]:
 137                         self.parent.value = self.parent.value - 1
 138                 if key == config.key["nextElement"]:
 139                         self.parent.value = self.parent.value + 1
 140
 141                 self.checkValues()
 142
 143                 self.parent.change()
 144
 145         def __call__(self, selected):                   #needed by configlist
 146                 self.checkValues()
 147                 #fixme
 148                 return ("text", str(self.parent.vals[self.parent.value][0]))
 149
 150 class configSequenceArg:
 151         def get(self, type, args = ()):
 152                 # configsequencearg.get ("IP")
 153                 if (type == "IP"):
 154                         return (("."), [(1,255),(0,255),(0,255),(0,255)], "")
 155                 # configsequencearg.get ("MAC")
 156                 if (type == "MAC"):
 157                         return ((":"), [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], "")
 158                 # configsequencearg.get ("CLOCK")
 159                 if (type == "CLOCK"):
 160                         return ((":"), [(0,23),(0,59)], "")
 161                 # configsequencearg.get("INTEGER", (min, max)) => x with min <= x <= max
 162                 if (type == "INTEGER"):
 163                         return ((":"), [args], "")
 164                 # configsequencearg.get("PINCODE", (number, "*")) => pin with number = length of pincode and "*" as numbers shown as stars
 165                 # configsequencearg.get("PINCODE", (number, "")) => pin with number = length of pincode and numbers shown
 166                 if (type == "PINCODE"):
 167                         return ((":"), [(0, (10**args[0])-1)], args[1])
 168                 # configsequencearg.get("FLOAT", [(min,max),(min1,max1)]) => x.y with min <= x <= max and min1 <= y <= max1
 169                 if (type == "FLOAT"):
 170                         return (("."), args, "")
 171
 172 configsequencearg = configSequenceArg()
 173
 174 class configSequence:
 175         def __init__(self, parent):
 176                 self.parent = parent
 177                 self.markedPos = 0
 178                 self.seperator = self.parent.vals[0]
 179                 self.valueBounds = self.parent.vals[1]
 180                 self.censorChar = self.parent.vals[2]
 181
 182         def checkValues(self):
 183                 maxPos = 0
 184                 num = 0
 185                 for i in self.parent.value:
 186                         maxPos += len(str(self.valueBounds[num][1]))
 187                         while (self.valueBounds[num][0] > self.parent.value[num]):
 188                                 self.parent.value[num] += 1
 189
 190                         while (self.valueBounds[num][1] < self.parent.value[num]):
 191                                 self.parent.value[num] -= 1
 192
 193 #                       if (self.valueBounds[num][0] <= i <= self.valueBounds[num][1]):
 194                                 #pass
 195                         #else:
 196                                 #self.parent.value[num] = self.valueBounds[num][0]
 197                         num += 1
 198
 199                 if self.markedPos >= maxPos:
 200                         self.markedPos = maxPos - 1
 201                 if self.markedPos < 0:
 202                         self.markedPos = 0
 203
 204         def cancel(self):
 205                 self.parent.reload()
 206
 207         def save(self):
 208                 self.parent.save()
 209
 210         def handleKey(self, key):
 211                 #this will no change anything on the value itself
 212                 #so we can handle it here in gui element
 213                 if key == config.key["prevElement"]:
 214                         self.markedPos -= 1
 215                 if key == config.key["nextElement"]:
 216                         self.markedPos += 1
 217
 218                 if key >= config.key["0"] and key <= config.key["9"]:
 219                         number = 9 - config.key["9"] + key
 220                         # length of numberblock
 221                         numberLen = len(str(self.valueBounds[0][1]))
 222                         # position in the block
 223                         posinblock = self.markedPos % numberLen
 224                         # blocknumber
 225                         blocknumber = self.markedPos / numberLen
 226
 227                         oldvalue = self.parent.value[blocknumber]
 228                         olddec = oldvalue % 10 ** (numberLen - posinblock) - (oldvalue % 10 ** (numberLen - posinblock - 1))
 229                         newvalue = oldvalue - olddec + (10 ** (numberLen - posinblock - 1) * number)
 230
 231                         print "You actually pressed a number (" + str(number) + ") which will be added at block number " + str(blocknumber) + " on position " + str(posinblock)
 232                         print "Old value: " + str(oldvalue) + " olddec: " + str(olddec) + " newvalue: " + str(newvalue)
 233                         self.parent.value[blocknumber] = newvalue
 234                         self.markedPos += 1
 235
 236                 self.checkValues()
 237
 238                 print "markPos:",
 239                 print self.markedPos
 240
 241                 #FIXME: dont call when press left/right
 242                 self.parent.change()
 243
 244         def __call__(self, selected):                   #needed by configlist
 245                 value = ""
 246                 mPos = self.markedPos
 247                 print "Positon: " + str(mPos)
 248                 num = 0;
 249                 for i in self.parent.value:
 250                         if len(value):  #fixme no heading separator possible
 251                                 value += self.seperator
 252                                 if mPos >= len(value) - 1:
 253                                         mPos += 1
 254
 255                         #diff =         self.valueBounds - len(str(i))
 256                         #if diff > 0:
 257                                 ## if this helps?!
 258                                 #value += " " * diff
 259                         print (("%0" + str(len(str(self.valueBounds[num][1]))) + "d") % i)
 260                         if (self.censorChar == ""):
 261                                 value += ("%0" + str(len(str(self.valueBounds[num][1]))) + "d") % i
 262                         else:
 263                                 value += (self.censorChar * len(str(self.valueBounds[num][1])))
 264                         num += 1
 265                         # only mark cursor when we are selected
 266                         # (this code is heavily ink optimized!)
 267                 return ("mtext"[1-selected:], value, [mPos])
 268
 269 class configText:
 270         # used as first parameter
 271         # is the text of a fixed size or is the user able to extend the length of the text
 272         extendableSize = 1
 273         fixedSize = 2
 274
 275         def __init__(self, parent):
 276                 self.parent = parent
 277                 self.markedPos = 0
 278                 self.mode = self.parent.vals[0]
 279                 self.textInput = NumericalTextInput(self.nextEntry)
 280
 281         def checkValues(self):
 282                 if (self.markedPos < 0):
 283                         self.markedPos = 0
 284                 if (self.markedPos >= len(self.parent.value)):
 285                         self.markedPos = len(self.parent.value) - 1
 286
 287         def cancel(self):
 288                 self.parent.reload()
 289
 290         def save(self):
 291                 self.parent.save()
 292
 293         def nextEntry(self):
 294                 self.parent.vals[1]()
 295
 296         def handleKey(self, key):
 297                 #this will no change anything on the value itself
 298                 #so we can handle it here in gui element
 299                 if key == config.key["prevElement"]:
 300                         self.textInput.nextKey()
 301                         self.markedPos -= 1
 302
 303                 if key == config.key["nextElement"]:
 304                         self.textInput.nextKey()
 305                         self.markedPos += 1
 306                         if (self.mode == self.extendableSize):
 307                                 if (self.markedPos >= len(self.parent.value)):
 308                                         self.parent.value = self.parent.value.ljust(len(self.parent.value) + 1)
 309
 310
 311                 if key >= config.key["0"] and key <= config.key["9"]:
 312                         number = 9 - config.key["9"] + key
 313
 314                         self.parent.value = self.parent.value[0:self.markedPos] + str(self.textInput.getKey(number)) + self.parent.value[self.markedPos + 1:]
 315
 316                 self.checkValues()
 317
 318                 self.parent.change()
 319
 320         def __call__(self, selected):                   #needed by configlist
 321                 return ("mtext"[1-selected:], str(self.parent.value), [self.markedPos])
 322
 323 class configValue:
 324         def __init__(self, obj):
 325                 self.obj = obj
 326
 327         def __str__(self):
 328                 return self.obj
 329
 330 class Config:
 331         def __init__(self):
 332                 self.key = { "choseElement": 0,
 333                                          "prevElement": 1,
 334                                          "nextElement": 2,
 335                                          "0": 10,
 336                                          "1": 11,
 337                                          "2": 12,
 338                                          "3": 13,
 339                                          "4": 14,
 340                                          "5": 15,
 341                                          "6": 16,
 342                                          "7": 17,
 343                                          "8": 18,
 344                                          "9": 19 }
 345
 346 config = Config();
 347 configfile = configFile()
 348
 349 class ConfigSlider:
 350         def __init__(self, parent):
 351                 self.parent = parent
 352
 353         def cancel(self):
 354                 self.parent.reload()
 355
 356         def save(self):
 357                 self.parent.save()
 358
 359         def checkValues(self):
 360                 if self.parent.value < 0:
 361                         self.parent.value = 0
 362
 363                 if self.parent.value > 10:
 364                         self.parent.value = 10
 365
 366         def handleKey(self, key):
 367                 if key == config.key["prevElement"]:
 368                         self.parent.value = self.parent.value - 1
 369                 if key == config.key["nextElement"]:
 370                         self.parent.value = self.parent.value + 1
 371
 372                 self.checkValues()
 373                 self.parent.change()
 374
 375         def __call__(self, selected):                   #needed by configlist
 376                 self.checkValues()
 377                 return ("slider", self.parent.value * 10)
 378
 379 class ConfigSubsection:
 380         def __init__(self):
 381                 pass
 382
 383 class configElement:
 384
 385         def getIndexbyEntry(self, data):
 386                 cnt = 0;
 387                 tcnt = -1; #for defaultval
 388                 for x in self.vals:
 389                         if int(x[1]) == int(data):
 390                                         return cnt
 391                         if int(x[1]) == int(self.defaultValue):
 392                                         tcnt = cnt
 393                         cnt += 1
 394                 if tcnt != -1:
 395                         return tcnt
 396                 return 0        #prevent bigger then array
 397
 398         def datafromFile(self, control, data):
 399                 if control == ConfigSlider:
 400                         return int(data)
 401                 elif control == configSelection:
 402                         return int(data)
 403                 elif control == configDateTime:
 404                         return int(data)
 405                 elif control == configText:
 406                         return str(data)
 407                 elif control == configSequence:
 408                         list = [ ]
 409                         part = data.split(self.vals[0])
 410                         for x in part:
 411                                 list.append(int(x))
 412                         return list
 413                 elif control == configSatlist:
 414                         return self.getIndexbyEntry(data)
 415                 else:
 416                         return ""
 417
 418         def datatoFile(self, control, data):
 419                 if control == ConfigSlider:
 420                         return str(data)
 421                 elif control == configSelection:
 422                         return str(data)
 423                 elif control == configDateTime:
 424                         return str(data)
 425                 elif control == configText:
 426                         return str(data.strip())
 427
 428                 elif control == configSequence:
 429                         value = ((len(data) * ("%d" + self.vals[0]))[0:-1]) % tuple(data)
 430 #                       just in case you don't understand the above, here an equivalent:
 431 #                       value = ""
 432 #                       for i in data:
 433 #                               if value !="":
 434 #                                       value += self.vals[0]
 435 #                               value += str(i)
 436                         return value
 437                 elif control == configSatlist:
 438                         return str(self.vals[self.value][1]);
 439                 else:
 440                         return ""
 441
 442         def loadData(self):
 443                 try:
 444                         value = self.datafromFile(self.controlType, configfile.getKey(self.configPath))
 445                 except:
 446                         value = ""
 447
 448                 if value == "":
 449                         #print "value not found - using default"
 450
 451                         if self.controlType == configSatlist:
 452                                 self.value = self.getIndexbyEntry(self.defaultValue)
 453                         else:
 454                                 self.value = self.defaultValue
 455
 456                         self.save()             #add missing value to dict
 457                 else:
 458                         self.value = value
 459
 460                 #is this right? activate settings after load/cancel and use default
 461                 self.change()
 462
 463         def __init__(self, configPath, control, defaultValue, vals):
 464                 self.configPath = configPath
 465                 self.defaultValue = defaultValue
 466                 self.controlType = control
 467                 self.vals = vals
 468                 self.notifierList = [ ]
 469                 self.enabled = True
 470                 self.loadData()
 471
 472         def getConfigPath(self):
 473                 return self.configPath
 474
 475         def addNotifier(self, notifier):
 476                 self.notifierList.append(notifier);
 477                 notifier(self);
 478         def change(self):
 479                 for notifier in self.notifierList:
 480                         notifier(self)
 481         def reload(self):
 482                 self.loadData()
 483         def save(self):
 484                 configfile.setKey(self.configPath, self.datatoFile(self.controlType,self.value))
 485
 486 class configElement_nonSave(configElement):
 487         def __init__(self, configPath, control, defaultValue, vals):
 488                 configElement.__init__(self, configPath, control, defaultValue, vals)
 489
 490         def save(self):
 491                 pass
 492
 493 def getConfigListEntry(description, element):
 494         b = element
 495         item = b.controlType(b)
 496         return ((description, item))