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