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