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