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

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