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 is None:
 461                         confirmed = (None, "no")
 462
 463                 if confirmed[1] == "yes" or confirmed[1] == "yestoall":
 464                         eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove)
 465
 466                 if self.satpos_to_remove is not None:
 467                         self.unconfed_sats.remove(self.satpos_to_remove)
 468
 469                 self.satpos_to_remove = None
 470                 for orbpos in self.unconfed_sats:
 471                         self.satpos_to_remove = orbpos
 472                         orbpos = self.satpos_to_remove
 473                         try:
 474                                 # why we need this cast?
 475                                 sat_name = str(nimmanager.getSatDescription(orbpos))
 476                         except:
 477                                 if orbpos > 1800: # west
 478                                         orbpos = 3600 - orbpos
 479                                         h = _("W")
 480                                 else:
 481                                         h = _("E")
 482                                 sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
 483
 484                         if confirmed[1] == "yes" or confirmed[1] == "no":
 485                                 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")])
 486                         if confirmed[1] == "yestoall" or confirmed[1] == "notoall":
 487                                 self.deleteConfirmed(confirmed)
 488                         break
 489                 else:
 490                         self.restoreService(_("Zap back to service before tuner setup?"))
 491
 492         def __init__(self, session, slotid):
 493                 Screen.__init__(self, session)
 494                 self.list = [ ]
 495
 496                 ServiceStopScreen.__init__(self)
 497                 self.stopService()
 498
 499                 ConfigListScreen.__init__(self, self.list)
 500
 501                 self["actions"] = ActionMap(["SetupActions", "SatlistShortcutAction"],
 502                 {
 503                         "ok": self.keySave,
 504                         "cancel": self.keyCancel,
 505                         "nothingconnected": self.nothingConnectedShortcut
 506                 }, -2)
 507
 508                 self.slotid = slotid
 509                 self.nim = nimmanager.nim_slots[slotid]
 510                 self.nimConfig = self.nim.config
 511                 self.createConfigMode()
 512                 self.createSetup()
 513
 514         def keyLeft(self):
 515                 if isFBCLink(self.nim):
 516                         checkList = (self.advancedLof, self.advancedConnected)
 517                         curEntry = self["config"].getCurrent()
 518                         if curEntry in checkList:
 519                                 return
 520
 521                 ConfigListScreen.keyLeft(self)
 522                 self.newConfig()
 523
 524         def keyRight(self):
 525                 if isFBCLink(self.nim):
 526                         checkList = (self.advancedLof, self.advancedConnected)
 527                         curEntry = self["config"].getCurrent()
 528                         if curEntry in checkList:
 529                                 return
 530
 531                 ConfigListScreen.keyRight(self)
 532                 self.newConfig()
 533
 534         def keyCancel(self):
 535                 if self["config"].isChanged():
 536                         self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
 537                 else:
 538                         self.restoreService(_("Zap back to service before tuner setup?"))
 539
 540         def saveAll(self):
 541                 if self.nim.isCompatible("DVB-S"):
 542                         # reset connectedTo to all choices to properly store the default value
 543                         choices = []
 544                         nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
 545                         for id in nimlist:
 546                                 choices.append((str(id), nimmanager.getNimDescription(id)))
 547                         self.nimConfig.connectedTo.setChoices(choices)
 548                 for x in self["config"].list:
 549                         x[1].save()
 550
 551         def cancelConfirm(self, result):
 552                 if not result:
 553                         return
 554
 555                 for x in self["config"].list:
 556                         x[1].cancel()
 557                 # we need to call saveAll to reset the connectedTo choices
 558                 self.saveAll()
 559                 self.restoreService(_("Zap back to service before tuner setup?"))
 560
 561         def nothingConnectedShortcut(self):
 562                 if type(self["config"].getCurrent()[1]) is ConfigSatlist:
 563                         self["config"].getCurrent()[1].setValue("3601")
 564                         self["config"].invalidateCurrent()
 565
 566 class NimSelection(Screen):
 567         def __init__(self, session):
 568                 Screen.__init__(self, session)
 569
 570                 self.list = [None] * nimmanager.getSlotCount()
 571                 self["nimlist"] = List(self.list)
 572                 self.loadFBCLinks()
 573                 self.updateList()
 574
 575                 self.setResultClass()
 576
 577                 self["actions"] = ActionMap(["OkCancelActions"],
 578                 {
 579                         "ok": self.okbuttonClick ,
 580                         "cancel": self.close
 581                 }, -2)
 582
 583         def loadFBCLinks(self):
 584                 for x in nimmanager.nim_slots:
 585                         slotid = x.slot
 586                         nimConfig = nimmanager.getNimConfig(x.slot)
 587                         configMode = nimConfig.configMode.value
 588                         if self.showNim(x):
 589                                 if x.isCompatible("DVB-S"):
 590                                         if isFBCLink(x) and configMode != "advanced":
 591                                                 from enigma import getLinkedSlotID
 592                                                 link = getLinkedSlotID(x.slot)
 593
 594                                                 if link == -1:
 595                                                         nimConfig.configMode.value = "nothing"
 596                                                 else:
 597                                                         nimConfig.configMode.value = "loopthrough"
 598                                                         nimConfig.connectedTo.value = str(link)
 599
 600         def setResultClass(self):
 601                 self.resultclass = NimSetup
 602
 603         def okbuttonClick(self):
 604                 nim = self["nimlist"].getCurrent()
 605                 nim = nim and nim[3]
 606
 607                 nimConfig = nimmanager.getNimConfig(nim.slot)
 608                 if isFBCLink(nim) and nimConfig.configMode.value == "loopthrough":
 609                         return
 610
 611                 if nim is not None and not nim.empty and nim.isSupported():
 612                         self.session.openWithCallback(self.NimSetupCB, self.resultclass, nim.slot)
 613
 614         def NimSetupCB(self):
 615                 self.loadFBCLinks()
 616                 self.updateList()
 617
 618         def showNim(self, nim):
 619                 return True
 620
 621         def updateList(self):
 622                 self.list = [ ]
 623                 for x in nimmanager.nim_slots:
 624                         slotid = x.slot
 625                         nimConfig = nimmanager.getNimConfig(x.slot)
 626                         text = nimConfig.configMode.value
 627                         if self.showNim(x):
 628                                 if x.isCompatible("DVB-S"):
 629                                         if nimConfig.configMode.value in ("loopthrough", "equal", "satposdepends"):
 630                                                 text = { "loopthrough": _("loopthrough to"),
 631                                                                  "equal": _("equal to"),
 632                                                                  "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value]
 633                                                 text += " " + _("Tuner") + " " + chr(ord('A')+int(nimConfig.connectedTo.value))
 634                                         elif nimConfig.configMode.value == "nothing":
 635                                                 text = _("not configured")
 636                                         elif nimConfig.configMode.value == "simple":
 637                                                 if nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 638                                                         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"
 639                                                         text += _("Sats") + ": "
 640                                                         satnames = []
 641                                                         if nimConfig.diseqcA.orbital_position != 3601:
 642                                                                 satnames.append(nimmanager.getSatName(int(nimConfig.diseqcA.value)))
 643                                                         if nimConfig.diseqcMode.value in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 644                                                                 if nimConfig.diseqcB.orbital_position != 3601:
 645                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcB.value)))
 646                                                         if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
 647                                                                 if nimConfig.diseqcC.orbital_position != 3601:
 648                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcC.value)))
 649                                                                 if nimConfig.diseqcD.orbital_position != 3601:
 650                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcD.value)))
 651                                                         if len(satnames) <= 2:
 652                                                                 text += ", ".join(satnames)
 653                                                         elif len(satnames) > 2:
 654                                                                 # we need a newline here, since multi content lists don't support automtic line wrapping
 655                                                                 text += ", ".join(satnames[:2]) + ",\n"
 656                                                                 text += "         " + ", ".join(satnames[2:])
 657                                                 elif nimConfig.diseqcMode.value == "positioner":
 658                                                         text = _("Positioner") + ":"
 659                                                         if nimConfig.positionerMode.value == "usals":
 660                                                                 text += _("USALS")
 661                                                         elif nimConfig.positionerMode.value == "manual":
 662                                                                 text += _("manual")
 663                                                 else:
 664                                                         text = _("simple")
 665                                         elif nimConfig.configMode.value == "advanced":
 666                                                 text = _("advanced")
 667                                         if isFBCLink(x) and nimConfig.configMode.value != "advanced":
 668                                                 text += _("\n<This tuner is configured automatically>")
 669                                 elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"):
 670                                         if nimConfig.configMode.value == "nothing":
 671                                                 text = _("nothing connected")
 672                                         elif nimConfig.configMode.value == "enabled":
 673                                                 text = _("enabled")
 674                                 if x.isMultiType():
 675                                         text = _("Switchable tuner types:") + "(" + ','.join(x.getMultiTypeList().values()) + ")" + "\n" + text
 676                                 if not x.isSupported():
 677                                         text = _("tuner is not supported")
 678
 679                                 self.list.append((slotid, x.friendly_full_description, text, x))
 680                 self["nimlist"].setList(self.list)
 681                 self["nimlist"].updateList(self.list)
 682