code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Screens/Satconfig.py

   1 from enigma import eDVBDB
   2 from Screen import Screen
   3 from Components.SystemInfo import SystemInfo
   4 from Components.ActionMap import ActionMap
   5 from Components.ConfigList import ConfigListScreen
   6 from Components.MenuList import MenuList
   7 from Components.NimManager import nimmanager
   8 from Components.config import getConfigListEntry, config, ConfigNothing, ConfigSelection, updateConfigElement,\
   9         ConfigSatlist
  10 from Components.Sources.List import List
  11 from Screens.MessageBox import MessageBox
  12 from Screens.ChoiceBox import ChoiceBox
  13 from Screens.ServiceStopScreen import ServiceStopScreen
  14
  15 from time import mktime, localtime
  16 from datetime import datetime
  17
  18 from Components.PluginComponent import plugins
  19 from Plugins.Plugin import PluginDescriptor
  20
  21 def isFBCTuner(nim):
  22         if nim.description.find("FBC") == -1:
  23                 return False
  24         return True
  25
  26 def isFBCRoot(nim):
  27         if nim.slot %8 < 2:
  28                 return True
  29         return False
  30
  31 def isFBCLink(nim):
  32         if isFBCTuner(nim) and not isFBCRoot(nim):
  33                 return True
  34         return False
  35
  36 class NimSetup(Screen, ConfigListScreen, ServiceStopScreen):
  37         def createSimpleSetup(self, list, mode):
  38                 nim = self.nimConfig
  39                 if mode == "single":
  40                         list.append(getConfigListEntry(_("Satellite"), nim.diseqcA))
  41                         list.append(getConfigListEntry(_("Send DiSEqC"), nim.simpleSingleSendDiSEqC))
  42                 else:
  43                         list.append(getConfigListEntry(_("Port A"), nim.diseqcA))
  44
  45                 if mode in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
  46                         list.append(getConfigListEntry(_("Port B"), nim.diseqcB))
  47                         if mode == "diseqc_a_b_c_d":
  48                                 list.append(getConfigListEntry(_("Port C"), nim.diseqcC))
  49                                 list.append(getConfigListEntry(_("Port D"), nim.diseqcD))
  50                         if mode != "toneburst_a_b":
  51                                 list.append(getConfigListEntry(_("Set Voltage and 22KHz"), nim.simpleDiSEqCSetVoltageTone))
  52                                 list.append(getConfigListEntry(_("Send DiSEqC only on satellite change"), nim.simpleDiSEqCOnlyOnSatChange))
  53
  54         def createPositionerSetup(self, list):
  55                 nim = self.nimConfig
  56                 list.append(getConfigListEntry(_("Longitude"), nim.longitude))
  57                 list.append(getConfigListEntry(" ", nim.longitudeOrientation))
  58                 list.append(getConfigListEntry(_("Latitude"), nim.latitude))
  59                 list.append(getConfigListEntry(" ", nim.latitudeOrientation))
  60                 if SystemInfo["CanMeasureFrontendInputPower"]:
  61                         self.advancedPowerMeasurement = getConfigListEntry(_("Use Power Measurement"), nim.powerMeasurement)
  62                         list.append(self.advancedPowerMeasurement)
  63                         if nim.powerMeasurement.value:
  64                                 list.append(getConfigListEntry(_("Power threshold in mA"), nim.powerThreshold))
  65                                 self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), nim.turningSpeed)
  66                                 list.append(self.turningSpeed)
  67                                 if nim.turningSpeed.value == "fast epoch":
  68                                         self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), nim.fastTurningBegin)
  69                                         self.turnFastEpochEnd = getConfigListEntry(_("End time"), nim.fastTurningEnd)
  70                                         list.append(self.turnFastEpochBegin)
  71                                         list.append(self.turnFastEpochEnd)
  72                 else:
  73                         if nim.powerMeasurement.value:
  74                                 nim.powerMeasurement.value = False
  75                                 nim.powerMeasurement.save()
  76
  77         def createConfigMode(self):
  78                 if self.nim.isCompatible("DVB-S"):
  79                         choices = { "nothing": _("not configured"),
  80                                                 "simple": _("simple"),
  81                                                 "advanced": _("advanced")}
  82                         #if len(nimmanager.getNimListOfType(nimmanager.getNimType(self.slotid), exception = x)) > 0:
  83                         #       choices["equal"] = _("equal to")
  84                         #       choices["satposdepends"] = _("second cable of motorized LNB")
  85                         if len(nimmanager.canEqualTo(self.slotid)) > 0:
  86                                 choices["equal"] = _("equal to")
  87                         if len(nimmanager.canDependOn(self.slotid)) > 0:
  88                                 choices["satposdepends"] = _("second cable of motorized LNB")
  89                         if len(nimmanager.canConnectTo(self.slotid)) > 0:
  90                                 choices["loopthrough"] = _("loopthrough to")
  91                         if isFBCLink(self.nim):
  92                                 choices = { "nothing": _("not configured"),
  93                                                 "advanced": _("advanced")}
  94                         self.nimConfig.configMode.setChoices(choices, default = "nothing")
  95
  96         def createSetup(self):
  97                 print "Creating setup"
  98                 self.list = [ ]
  99
 100                 self.multiType = None
 101                 self.configMode = None
 102                 self.diseqcModeEntry = None
 103                 self.advancedSatsEntry = None
 104                 self.advancedLnbsEntry = None
 105                 self.advancedDiseqcMode = None
 106                 self.advancedUsalsEntry = None
 107                 self.advancedLof = None
 108                 self.advancedPowerMeasurement = None
 109                 self.turningSpeed = None
 110                 self.turnFastEpochBegin = None
 111                 self.turnFastEpochEnd = None
 112                 self.uncommittedDiseqcCommand = None
 113                 self.cableScanType = None
 114                 self.have_advanced = False
 115                 self.advancedUnicable = None
 116                 self.advancedType = None
 117                 self.advancedManufacturer = None
 118                 self.advancedSCR = None
 119                 self.advancedDiction = None
 120                 self.advancedConnected = None
 121
 122                 if self.nim.isMultiType():
 123                         multiType = self.nimConfig.multiType
 124                         self.multiType = getConfigListEntry(_("Tuner type"), multiType)
 125                         self.list.append(self.multiType)
 126
 127                 if self.nim.isCompatible("DVB-S"):
 128                         self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
 129                         self.list.append(self.configMode)
 130
 131                         if self.nimConfig.configMode.value == "simple":                 #simple setup
 132                                 self.diseqcModeEntry = getConfigListEntry(_("Mode"), self.nimConfig.diseqcMode)
 133                                 self.list.append(self.diseqcModeEntry)
 134                                 if self.nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 135                                         self.createSimpleSetup(self.list, self.nimConfig.diseqcMode.value)
 136                                 if self.nimConfig.diseqcMode.value == "positioner":
 137                                         self.createPositionerSetup(self.list)
 138                         elif self.nimConfig.configMode.value == "equal":
 139                                 choices = []
 140                                 nimlist = nimmanager.canEqualTo(self.nim.slot)
 141                                 for id in nimlist:
 142                                         #choices.append((str(id), str(chr(65 + id))))
 143                                         choices.append((str(id), nimmanager.getNimDescription(id)))
 144                                 self.nimConfig.connectedTo.setChoices(choices)
 145                                 #self.nimConfig.connectedTo = updateConfigElement(self.nimConfig.connectedTo, ConfigSelection(choices = choices))
 146                                 self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo))
 147                         elif self.nimConfig.configMode.value == "satposdepends":
 148                                 choices = []
 149                                 nimlist = nimmanager.canDependOn(self.nim.slot)
 150                                 for id in nimlist:
 151                                         #choices.append((str(id), str(chr(65 + id))))
 152                                         choices.append((str(id), nimmanager.getNimDescription(id)))
 153                                 self.nimConfig.connectedTo.setChoices(choices)
 154                                 #self.nimConfig.connectedTo = updateConfigElement(self.nimConfig.connectedTo, ConfigSelection(choices = choices))
 155                                 self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo))
 156                         elif self.nimConfig.configMode.value == "loopthrough":
 157                                 choices = []
 158                                 print "connectable to:", nimmanager.canConnectTo(self.slotid)
 159                                 connectable = nimmanager.canConnectTo(self.slotid)
 160                                 for id in connectable:
 161                                         choices.append((str(id), nimmanager.getNimDescription(id)))
 162                                 self.nimConfig.connectedTo.setChoices(choices)
 163                                 #self.nimConfig.connectedTo = updateConfigElement(self.nimConfig.connectedTo, ConfigSelection(choices = choices))
 164                                 self.list.append(getConfigListEntry(_("Connected to"), self.nimConfig.connectedTo))
 165                         elif self.nimConfig.configMode.value == "nothing":
 166                                 pass
 167                         elif self.nimConfig.configMode.value == "advanced": # advanced
 168                                 # SATs
 169                                 self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats)
 170                                 self.list.append(self.advancedSatsEntry)
 171                                 cur_orb_pos = self.nimConfig.advanced.sats.orbital_position
 172                                 satlist = self.nimConfig.advanced.sat.keys()
 173                                 if cur_orb_pos is not None:
 174                                         if cur_orb_pos not in satlist:
 175                                                 cur_orb_pos = satlist[0]
 176                                         currSat = self.nimConfig.advanced.sat[cur_orb_pos]
 177                                         self.fillListWithAdvancedSatEntrys(currSat)
 178                                 self.have_advanced = True
 179                         if self.nim.description == "Alps BSBE2" and config.usage.setup_level.index >= 2: # expert
 180                                 self.list.append(getConfigListEntry(_("Tone Amplitude"), self.nimConfig.toneAmplitude))
 181                 elif self.nim.isCompatible("DVB-C"):
 182                         self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
 183                         self.list.append(self.configMode)
 184                         if self.nimConfig.configMode.value == "enabled":
 185                                 self.cableScanType=getConfigListEntry(_("Used service scan type"), self.nimConfig.cable.scan_type)
 186                                 self.list.append(self.cableScanType)
 187                                 if self.nimConfig.cable.scan_type.value == "provider":
 188                                         self.list.append(getConfigListEntry(_("Provider to scan"), self.nimConfig.cable.scan_provider))
 189                                 else:
 190                                         if self.nimConfig.cable.scan_type.value == "bands":
 191                                                 self.list.append(getConfigListEntry(_("Scan band EU VHF I"), self.nimConfig.cable.scan_band_EU_VHF_I))
 192                                                 self.list.append(getConfigListEntry(_("Scan band EU MID"), self.nimConfig.cable.scan_band_EU_MID))
 193                                                 self.list.append(getConfigListEntry(_("Scan band EU VHF III"), self.nimConfig.cable.scan_band_EU_VHF_III))
 194                                                 self.list.append(getConfigListEntry(_("Scan band EU UHF IV"), self.nimConfig.cable.scan_band_EU_UHF_IV))
 195                                                 self.list.append(getConfigListEntry(_("Scan band EU UHF V"), self.nimConfig.cable.scan_band_EU_UHF_V))
 196                                                 self.list.append(getConfigListEntry(_("Scan band EU SUPER"), self.nimConfig.cable.scan_band_EU_SUPER))
 197                                                 self.list.append(getConfigListEntry(_("Scan band EU HYPER"), self.nimConfig.cable.scan_band_EU_HYPER))
 198                                                 self.list.append(getConfigListEntry(_("Scan band US LOW"), self.nimConfig.cable.scan_band_US_LOW))
 199                                                 self.list.append(getConfigListEntry(_("Scan band US MID"), self.nimConfig.cable.scan_band_US_MID))
 200                                                 self.list.append(getConfigListEntry(_("Scan band US HIGH"), self.nimConfig.cable.scan_band_US_HIGH))
 201                                                 self.list.append(getConfigListEntry(_("Scan band US SUPER"), self.nimConfig.cable.scan_band_US_SUPER))
 202                                                 self.list.append(getConfigListEntry(_("Scan band US HYPER"), self.nimConfig.cable.scan_band_US_HYPER))
 203                                         elif self.nimConfig.cable.scan_type.value == "steps":
 204                                                 self.list.append(getConfigListEntry(_("Frequency scan step size(khz)"), self.nimConfig.cable.scan_frequency_steps))
 205                                         self.list.append(getConfigListEntry(_("Scan QAM16"), self.nimConfig.cable.scan_mod_qam16))
 206                                         self.list.append(getConfigListEntry(_("Scan QAM32"), self.nimConfig.cable.scan_mod_qam32))
 207                                         self.list.append(getConfigListEntry(_("Scan QAM64"), self.nimConfig.cable.scan_mod_qam64))
 208                                         self.list.append(getConfigListEntry(_("Scan QAM128"), self.nimConfig.cable.scan_mod_qam128))
 209                                         self.list.append(getConfigListEntry(_("Scan QAM256"), self.nimConfig.cable.scan_mod_qam256))
 210                                         self.list.append(getConfigListEntry(_("Scan SR6900"), self.nimConfig.cable.scan_sr_6900))
 211                                         self.list.append(getConfigListEntry(_("Scan SR6875"), self.nimConfig.cable.scan_sr_6875))
 212                                         self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext1))
 213                                         self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext2))
 214                         self.have_advanced = False
 215                 elif self.nim.isCompatible("DVB-T"):
 216                         self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
 217                         self.list.append(self.configMode)
 218                         self.have_advanced = False
 219                         if self.nimConfig.configMode.value == "enabled":
 220                                 self.list.append(getConfigListEntry(_("Terrestrial provider"), self.nimConfig.terrestrial))
 221                                 self.list.append(getConfigListEntry(_("Enable 5V for active antenna"), self.nimConfig.terrestrial_5V))
 222                 else:
 223                         self.have_advanced = False
 224                 self["config"].list = self.list
 225                 self["config"].l.setList(self.list)
 226
 227         def newConfig(self):
 228                 checkList = (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, \
 229                         self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry, \
 230                         self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, \
 231                         self.advancedType, self.advancedSCR, self.advancedDiction, self.advancedManufacturer, self.advancedUnicable, self.advancedConnected, \
 232                         self.uncommittedDiseqcCommand, self.cableScanType, self.multiType)
 233                 if self["config"].getCurrent() == self.multiType:
 234                         update_slots = [self.slotid]
 235                         from Components.NimManager import InitNimManager
 236                         InitNimManager(nimmanager, update_slots)
 237                         self.nim = nimmanager.nim_slots[self.slotid]
 238                         self.nimConfig = self.nim.config
 239
 240                 for x in checkList:
 241                         if self["config"].getCurrent() == x:
 242                                 self.createSetup()
 243                                 break
 244
 245         def run(self):
 246                 if self.have_advanced and self.nim.config_mode == "advanced":
 247                         self.fillAdvancedList()
 248                 for x in self.list:
 249                         if x in (self.turnFastEpochBegin, self.turnFastEpochEnd):
 250                                 # workaround for storing only hour*3600+min*60 value in configfile
 251                                 # not really needed.. just for cosmetics..
 252                                 tm = localtime(x[1].value)
 253                                 dt = datetime(1970, 1, 1, tm.tm_hour, tm.tm_min)
 254                                 x[1].value = int(mktime(dt.timetuple()))
 255                         x[1].save()
 256                 nimmanager.sec.update()
 257                 self.saveAll()
 258
 259         def fillListWithAdvancedSatEntrys(self, Sat):
 260                 lnbnum = int(Sat.lnb.value)
 261                 currLnb = self.nimConfig.advanced.lnb[lnbnum]
 262                 diction = None
 263                 if isinstance(currLnb, ConfigNothing):
 264                         currLnb = None
 265
 266                 # LNBs
 267                 self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb)
 268                 self.list.append(self.advancedLnbsEntry)
 269
 270                 if currLnb:
 271                         if isFBCLink(self.nim):
 272                                 if currLnb.lof.value != "unicable":
 273                                         currLnb.lof.value = "unicable"
 274
 275                         self.list.append(getConfigListEntry(_("Priority"), currLnb.prio))
 276                         self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof)
 277                         self.list.append(self.advancedLof)
 278                         if currLnb.lof.value == "user_defined":
 279                                 self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl))
 280                                 self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh))
 281                                 self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
 282 #                       self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v))
 283
 284                         if currLnb.lof.value == "unicable":
 285                                 self.advancedUnicable = getConfigListEntry("Unicable "+_("Configuration Mode"), currLnb.unicable)
 286                                 self.list.append(self.advancedUnicable)
 287                                 if currLnb.unicable.value == "unicable_user":
 288                                         self.advancedDiction = getConfigListEntry(_("Diction"), currLnb.dictionuser)
 289                                         self.list.append(self.advancedDiction)
 290
 291                                         if currLnb.dictionuser.value == "EN50494":
 292                                                 satcr = currLnb.satcruserEN50494
 293                                                 stcrvco = currLnb.satcrvcouserEN50494[currLnb.satcruserEN50494.index]
 294                                         elif currLnb.dictionuser.value == "EN50607":
 295                                                 satcr = currLnb.satcruserEN50607
 296                                                 stcrvco = currLnb.satcrvcouserEN50607[currLnb.satcruserEN50607.index]
 297
 298                                         self.advancedSCR = getConfigListEntry(_("Channel"), satcr)
 299                                         self.list.append(self.advancedSCR)
 300                                         self.list.append(getConfigListEntry(_("Frequency"), stcrvco))
 301
 302                                         self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl))
 303                                         self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh))
 304                                         self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
 305                                 elif currLnb.unicable.value == "unicable_matrix":
 306                                         manufacturer_name = currLnb.unicableMatrixManufacturer.value
 307                                         manufacturer = currLnb.unicableMatrix[manufacturer_name]
 308 #                                       if "product" in manufacturer.content:
 309                                         product_name = manufacturer.product.value
 310                                         self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableMatrixManufacturer)
 311                                         self.list.append(self.advancedManufacturer)
 312                                         if product_name in manufacturer.scr:
 313                                                 diction = manufacturer.diction[product_name].value
 314                                                 self.advancedType = getConfigListEntry(_("Type"), manufacturer.product)
 315                                                 self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name])
 316                                                 self.list.append(self.advancedType)
 317                                                 self.list.append(self.advancedSCR)
 318                                                 self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index]))
 319                                 elif currLnb.unicable.value == "unicable_lnb":
 320                                         manufacturer_name = currLnb.unicableLnbManufacturer.value
 321                                         manufacturer = currLnb.unicableLnb[manufacturer_name]
 322 #                                       if "product" in manufacturer.content:
 323                                         product_name = manufacturer.product.value
 324                                         self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableLnbManufacturer)
 325                                         self.list.append(self.advancedManufacturer)
 326                                         if product_name in manufacturer.scr:
 327                                                 diction = manufacturer.diction[product_name].value
 328                                                 self.advancedType = getConfigListEntry(_("Type"), manufacturer.product)
 329                                                 self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name])
 330                                                 self.list.append(self.advancedType)
 331                                                 self.list.append(self.advancedSCR)
 332                                                 self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index]))
 333
 334                                 choices = []
 335                                 connectable = nimmanager.canConnectTo(self.slotid)
 336                                 for id in connectable:
 337                                         choices.append((str(id), nimmanager.getNimDescription(id)))
 338                                 if len(choices):
 339                                         if isFBCLink(self.nim):
 340                                                 if self.nimConfig.advanced.unicableconnected.value != True:
 341                                                         self.nimConfig.advanced.unicableconnected.value = True
 342
 343                                         self.advancedConnected = getConfigListEntry(_("connected"), self.nimConfig.advanced.unicableconnected)
 344                                         self.list.append(self.advancedConnected)
 345                                         if self.nimConfig.advanced.unicableconnected.value == True:
 346                                                 self.nimConfig.advanced.unicableconnectedTo.setChoices(choices)
 347                                                 self.list.append(getConfigListEntry(_("Connected to"),self.nimConfig.advanced.unicableconnectedTo))
 348
 349                         else:   #kein Unicable
 350                                 self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage))
 351                                 self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage))
 352                                 self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode))
 353
 354                         if lnbnum < 65 and diction !="EN50607":
 355                                 self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode)
 356                                 self.list.append(self.advancedDiseqcMode)
 357                         if currLnb.diseqcMode.value != "none":
 358                                 self.list.append(getConfigListEntry(_("Toneburst"), currLnb.toneburst))
 359                                 self.list.append(getConfigListEntry(_("Committed DiSEqC command"), currLnb.commitedDiseqcCommand))
 360                                 self.list.append(getConfigListEntry(_("Fast DiSEqC"), currLnb.fastDiseqc))
 361                                 self.list.append(getConfigListEntry(_("Sequence repeat"), currLnb.sequenceRepeat))
 362                                 if currLnb.diseqcMode.value == "1_0":
 363                                         self.list.append(getConfigListEntry(_("Command order"), currLnb.commandOrder1_0))
 364                                 else:
 365                                         if currLnb.uncommittedDiseqcCommand.index:
 366                                                 if currLnb.commandOrder.value == "ct":
 367                                                         currLnb.commandOrder.value = "cut"
 368                                                 elif currLnb.commandOrder.value == "tc":
 369                                                         currLnb.commandOrder.value = "tcu"
 370                                         else:
 371                                                 if currLnb.commandOrder.index & 1:
 372                                                         currLnb.commandOrder.value = "tc"
 373                                                 else:
 374                                                         currLnb.commandOrder.value = "ct"
 375                                         self.list.append(getConfigListEntry(_("Command order"), currLnb.commandOrder))
 376                                         self.uncommittedDiseqcCommand = getConfigListEntry(_("Uncommitted DiSEqC command"), currLnb.uncommittedDiseqcCommand)
 377                                         self.list.append(self.uncommittedDiseqcCommand)
 378                                         self.list.append(getConfigListEntry(_("DiSEqC repeats"), currLnb.diseqcRepeats))
 379                                 if currLnb.diseqcMode.value == "1_2":
 380                                         self.list.append(getConfigListEntry(_("Longitude"), currLnb.longitude))
 381                                         self.list.append(getConfigListEntry(" ", currLnb.longitudeOrientation))
 382                                         self.list.append(getConfigListEntry(_("Latitude"), currLnb.latitude))
 383                                         self.list.append(getConfigListEntry(" ", currLnb.latitudeOrientation))
 384                                         if SystemInfo["CanMeasureFrontendInputPower"]:
 385                                                 self.advancedPowerMeasurement = getConfigListEntry(_("Use Power Measurement"), currLnb.powerMeasurement)
 386                                                 self.list.append(self.advancedPowerMeasurement)
 387                                                 if currLnb.powerMeasurement.value:
 388                                                         self.list.append(getConfigListEntry(_("Power threshold in mA"), currLnb.powerThreshold))
 389                                                         self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), currLnb.turningSpeed)
 390                                                         self.list.append(self.turningSpeed)
 391                                                         if currLnb.turningSpeed.value == "fast epoch":
 392                                                                 self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), currLnb.fastTurningBegin)
 393                                                                 self.turnFastEpochEnd = getConfigListEntry(_("End time"), currLnb.fastTurningEnd)
 394                                                                 self.list.append(self.turnFastEpochBegin)
 395                                                                 self.list.append(self.turnFastEpochEnd)
 396                                         else:
 397                                                 if currLnb.powerMeasurement.value:
 398                                                         currLnb.powerMeasurement.value = False
 399                                                         currLnb.powerMeasurement.save()
 400                                         self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals)
 401                                         self.list.append(self.advancedUsalsEntry)
 402                                         if not Sat.usals.value:
 403                                                 self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition))
 404
 405
 406
 407         def fillAdvancedList(self):
 408                 self.list = [ ]
 409                 self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
 410                 self.list.append(self.configMode)
 411                 self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats)
 412                 self.list.append(self.advancedSatsEntry)
 413                 for x in self.nimConfig.advanced.sat.keys():
 414                         Sat = self.nimConfig.advanced.sat[x]
 415                         self.fillListWithAdvancedSatEntrys(Sat)
 416                 self["config"].list = self.list
 417
 418         def checkLoopthrough(self):
 419                 if self.nimConfig.configMode.value == "loopthrough":
 420                         loopthrough_count = 0
 421                         dvbs_slots = nimmanager.getNimListOfType('DVB-S')
 422                         dvbs_slots_len = len(dvbs_slots)
 423
 424                         for x in dvbs_slots:
 425                                 try:
 426                                         nim_slot = nimmanager.nim_slots[x]
 427                                         if nim_slot == self.nimConfig:
 428                                                 self_idx = x
 429                                         if nim_slot.config.configMode.value == "loopthrough":
 430                                                 loopthrough_count += 1
 431                                 except: pass
 432                         if loopthrough_count >= dvbs_slots_len:
 433                                 return False
 434
 435                 self.slot_dest_list = []
 436                 def checkRecursiveConnect(slot_id):
 437                         if slot_id in self.slot_dest_list:
 438                                 return False
 439                         self.slot_dest_list.append(slot_id)
 440                         slot_config = nimmanager.nim_slots[slot_id].config
 441                         if slot_config.configMode.value == "loopthrough":
 442                                 return checkRecursiveConnect(int(slot_config.connectedTo.value))
 443                         return True
 444
 445                 return checkRecursiveConnect(self.slotid)
 446
 447         def keySave(self):
 448                 if not self.checkLoopthrough():
 449                         self.session.open(MessageBox, _("The loopthrough setting is wrong."),MessageBox.TYPE_ERROR,timeout=10)
 450                         return
 451
 452                 old_configured_sats = nimmanager.getConfiguredSats()
 453                 self.run()
 454                 new_configured_sats = nimmanager.getConfiguredSats()
 455                 self.unconfed_sats = old_configured_sats - new_configured_sats
 456                 self.satpos_to_remove = None
 457                 self.deleteConfirmed((None, "no"))
 458
 459         def deleteConfirmed(self, confirmed):
 460                 if confirmed[1] == "yes" or confirmed[1] == "yestoall":
 461                         eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove)
 462
 463                 if self.satpos_to_remove is not None:
 464                         self.unconfed_sats.remove(self.satpos_to_remove)
 465
 466                 self.satpos_to_remove = None
 467                 for orbpos in self.unconfed_sats:
 468                         self.satpos_to_remove = orbpos
 469                         orbpos = self.satpos_to_remove
 470                         try:
 471                                 # why we need this cast?
 472                                 sat_name = str(nimmanager.getSatDescription(orbpos))
 473                         except:
 474                                 if orbpos > 1800: # west
 475                                         orbpos = 3600 - orbpos
 476                                         h = _("W")
 477                                 else:
 478                                         h = _("E")
 479                                 sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
 480
 481                         if confirmed[1] == "yes" or confirmed[1] == "no":
 482                                 self.session.openWithCallback(self.deleteConfirmed, ChoiceBox, _("Delete no more configured satellite\n%s?") %(sat_name), [(_("Yes"), "yes"), (_("No"), "no"), (_("Yes to all"), "yestoall"), (_("No to all"), "notoall")])
 483                         if confirmed[1] == "yestoall" or confirmed[1] == "notoall":
 484                                 self.deleteConfirmed(confirmed)
 485                         break
 486                 else:
 487                         self.restoreService(_("Zap back to service before tuner setup?"))
 488
 489         def __init__(self, session, slotid):
 490                 Screen.__init__(self, session)
 491                 self.list = [ ]
 492
 493                 ServiceStopScreen.__init__(self)
 494                 self.stopService()
 495
 496                 ConfigListScreen.__init__(self, self.list)
 497
 498                 self["actions"] = ActionMap(["SetupActions", "SatlistShortcutAction"],
 499                 {
 500                         "ok": self.keySave,
 501                         "cancel": self.keyCancel,
 502                         "nothingconnected": self.nothingConnectedShortcut
 503                 }, -2)
 504
 505                 self.slotid = slotid
 506                 self.nim = nimmanager.nim_slots[slotid]
 507                 self.nimConfig = self.nim.config
 508                 self.createConfigMode()
 509                 self.createSetup()
 510
 511         def keyLeft(self):
 512                 if isFBCLink(self.nim):
 513                         checkList = (self.advancedLof, self.advancedConnected)
 514                         curEntry = self["config"].getCurrent()
 515                         if curEntry in checkList:
 516                                 return
 517
 518                 ConfigListScreen.keyLeft(self)
 519                 self.newConfig()
 520
 521         def keyRight(self):
 522                 if isFBCLink(self.nim):
 523                         checkList = (self.advancedLof, self.advancedConnected)
 524                         curEntry = self["config"].getCurrent()
 525                         if curEntry in checkList:
 526                                 return
 527
 528                 ConfigListScreen.keyRight(self)
 529                 self.newConfig()
 530
 531         def keyCancel(self):
 532                 if self["config"].isChanged():
 533                         self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
 534                 else:
 535                         self.restoreService(_("Zap back to service before tuner setup?"))
 536
 537         def saveAll(self):
 538                 if self.nim.isCompatible("DVB-S"):
 539                         # reset connectedTo to all choices to properly store the default value
 540                         choices = []
 541                         nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
 542                         for id in nimlist:
 543                                 choices.append((str(id), nimmanager.getNimDescription(id)))
 544                         self.nimConfig.connectedTo.setChoices(choices)
 545                 for x in self["config"].list:
 546                         x[1].save()
 547
 548         def cancelConfirm(self, result):
 549                 if not result:
 550                         return
 551
 552                 for x in self["config"].list:
 553                         x[1].cancel()
 554                 # we need to call saveAll to reset the connectedTo choices
 555                 self.saveAll()
 556                 self.restoreService(_("Zap back to service before tuner setup?"))
 557
 558         def nothingConnectedShortcut(self):
 559                 if type(self["config"].getCurrent()[1]) is ConfigSatlist:
 560                         self["config"].getCurrent()[1].setValue("3601")
 561                         self["config"].invalidateCurrent()
 562
 563 class NimSelection(Screen):
 564         def __init__(self, session):
 565                 Screen.__init__(self, session)
 566
 567                 self.list = [None] * nimmanager.getSlotCount()
 568                 self["nimlist"] = List(self.list)
 569                 self.loadFBCLinks()
 570                 self.updateList()
 571
 572                 self.setResultClass()
 573
 574                 self["actions"] = ActionMap(["OkCancelActions"],
 575                 {
 576                         "ok": self.okbuttonClick ,
 577                         "cancel": self.close
 578                 }, -2)
 579
 580         def loadFBCLinks(self):
 581                 for x in nimmanager.nim_slots:
 582                         slotid = x.slot
 583                         nimConfig = nimmanager.getNimConfig(x.slot)
 584                         configMode = nimConfig.configMode.value
 585                         if self.showNim(x):
 586                                 if x.isCompatible("DVB-S"):
 587                                         if isFBCLink(x) and configMode != "advanced":
 588                                                 from enigma import getLinkedSlotID
 589                                                 link = getLinkedSlotID(x.slot)
 590
 591                                                 if link == -1:
 592                                                         nimConfig.configMode.value = "nothing"
 593                                                 else:
 594                                                         nimConfig.configMode.value = "loopthrough"
 595                                                         nimConfig.connectedTo.value = str(link)
 596
 597         def setResultClass(self):
 598                 self.resultclass = NimSetup
 599
 600         def okbuttonClick(self):
 601                 nim = self["nimlist"].getCurrent()
 602                 nim = nim and nim[3]
 603
 604                 nimConfig = nimmanager.getNimConfig(nim.slot)
 605                 if isFBCLink(nim) and nimConfig.configMode.value == "loopthrough":
 606                         return
 607
 608                 if nim is not None and not nim.empty and nim.isSupported():
 609                         self.session.openWithCallback(self.NimSetupCB, self.resultclass, nim.slot)
 610
 611         def NimSetupCB(self):
 612                 self.loadFBCLinks()
 613                 self.updateList()
 614
 615         def showNim(self, nim):
 616                 return True
 617
 618         def updateList(self):
 619                 self.list = [ ]
 620                 for x in nimmanager.nim_slots:
 621                         slotid = x.slot
 622                         nimConfig = nimmanager.getNimConfig(x.slot)
 623                         text = nimConfig.configMode.value
 624                         if self.showNim(x):
 625                                 if x.isCompatible("DVB-S"):
 626                                         if nimConfig.configMode.value in ("loopthrough", "equal", "satposdepends"):
 627                                                 text = { "loopthrough": _("loopthrough to"),
 628                                                                  "equal": _("equal to"),
 629                                                                  "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value]
 630                                                 text += " " + _("Tuner") + " " + chr(ord('A')+int(nimConfig.connectedTo.value))
 631                                         elif nimConfig.configMode.value == "nothing":
 632                                                 text = _("not configured")
 633                                         elif nimConfig.configMode.value == "simple":
 634                                                 if nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 635                                                         text = {"single": _("Single"), "toneburst_a_b": _("Toneburst A/B"), "diseqc_a_b": _("DiSEqC A/B"), "diseqc_a_b_c_d": _("DiSEqC A/B/C/D")}[nimConfig.diseqcMode.value] + "\n"
 636                                                         text += _("Sats") + ": "
 637                                                         satnames = []
 638                                                         if nimConfig.diseqcA.orbital_position != 3601:
 639                                                                 satnames.append(nimmanager.getSatName(int(nimConfig.diseqcA.value)))
 640                                                         if nimConfig.diseqcMode.value in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 641                                                                 if nimConfig.diseqcB.orbital_position != 3601:
 642                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcB.value)))
 643                                                         if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
 644                                                                 if nimConfig.diseqcC.orbital_position != 3601:
 645                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcC.value)))
 646                                                                 if nimConfig.diseqcD.orbital_position != 3601:
 647                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcD.value)))
 648                                                         if len(satnames) <= 2:
 649                                                                 text += ", ".join(satnames)
 650                                                         elif len(satnames) > 2:
 651                                                                 # we need a newline here, since multi content lists don't support automtic line wrapping
 652                                                                 text += ", ".join(satnames[:2]) + ",\n"
 653                                                                 text += "         " + ", ".join(satnames[2:])
 654                                                 elif nimConfig.diseqcMode.value == "positioner":
 655                                                         text = _("Positioner") + ":"
 656                                                         if nimConfig.positionerMode.value == "usals":
 657                                                                 text += _("USALS")
 658                                                         elif nimConfig.positionerMode.value == "manual":
 659                                                                 text += _("manual")
 660                                                 else:
 661                                                         text = _("simple")
 662                                         elif nimConfig.configMode.value == "advanced":
 663                                                 text = _("advanced")
 664                                         if isFBCLink(x) and nimConfig.configMode.value != "advanced":
 665                                                 text += _("\n<This tuner is configured automatically>")
 666                                 elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"):
 667                                         if nimConfig.configMode.value == "nothing":
 668                                                 text = _("nothing connected")
 669                                         elif nimConfig.configMode.value == "enabled":
 670                                                 text = _("enabled")
 671                                 if x.isMultiType():
 672                                         text = _("Switchable tuner types:") + "(" + ','.join(x.getMultiTypeList().values()) + ")" + "\n" + text
 673                                 if not x.isSupported():
 674                                         text = _("tuner is not supported")
 675
 676                                 self.list.append((slotid, x.friendly_full_description, text, x))
 677                 self["nimlist"].setList(self.list)
 678                 self["nimlist"].updateList(self.list)
 679