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 keySave(self):
 371                 old_configured_sats = nimmanager.getConfiguredSats()
 372                 self.run()
 373                 new_configured_sats = nimmanager.getConfiguredSats()
 374                 self.unconfed_sats = old_configured_sats - new_configured_sats
 375                 self.satpos_to_remove = None
 376                 self.restoreService(_("Zap back to service before tuner setup?"))
 377                 self.deleteConfirmed((None, "no"))
 378
 379         def deleteConfirmed(self, confirmed):
 380                 if confirmed[1] == "yes" or confirmed[1] == "yestoall":
 381                         eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove)
 382
 383                 if self.satpos_to_remove is not None:
 384                         self.unconfed_sats.remove(self.satpos_to_remove)
 385
 386                 self.satpos_to_remove = None
 387                 for orbpos in self.unconfed_sats:
 388                         self.satpos_to_remove = orbpos
 389                         orbpos = self.satpos_to_remove
 390                         try:
 391                                 # why we need this cast?
 392                                 sat_name = str(nimmanager.getSatDescription(orbpos))
 393                         except:
 394                                 if orbpos > 1800: # west
 395                                         orbpos = 3600 - orbpos
 396                                         h = _("W")
 397                                 else:
 398                                         h = _("E")
 399                                 sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
 400
 401                         if confirmed[1] == "yes" or confirmed[1] == "no":
 402                                 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")])
 403                         if confirmed[1] == "yestoall" or confirmed[1] == "notoall":
 404                                 self.deleteConfirmed(confirmed)
 405                         break
 406
 407         def __init__(self, session, slotid):
 408                 Screen.__init__(self, session)
 409                 self.list = [ ]
 410
 411                 ServiceStopScreen.__init__(self)
 412                 self.stopService()
 413
 414                 ConfigListScreen.__init__(self, self.list)
 415
 416                 self["actions"] = ActionMap(["SetupActions", "SatlistShortcutAction"],
 417                 {
 418                         "ok": self.keySave,
 419                         "cancel": self.keyCancel,
 420                         "nothingconnected": self.nothingConnectedShortcut
 421                 }, -2)
 422
 423                 self.slotid = slotid
 424                 self.nim = nimmanager.nim_slots[slotid]
 425                 self.nimConfig = self.nim.config
 426                 self.createConfigMode()
 427                 self.createSetup()
 428
 429         def keyLeft(self):
 430                 ConfigListScreen.keyLeft(self)
 431                 self.newConfig()
 432
 433         def keyRight(self):
 434                 ConfigListScreen.keyRight(self)
 435                 self.newConfig()
 436
 437         def keyCancel(self):
 438                 if self["config"].isChanged():
 439                         self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
 440                 else:
 441                         self.restoreService(_("Zap back to service before tuner setup?"))
 442
 443         def saveAll(self):
 444                 if self.nim.isCompatible("DVB-S"):
 445                         # reset connectedTo to all choices to properly store the default value
 446                         choices = []
 447                         nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
 448                         for id in nimlist:
 449                                 choices.append((str(id), nimmanager.getNimDescription(id)))
 450                         self.nimConfig.connectedTo.setChoices(choices)
 451                 for x in self["config"].list:
 452                         x[1].save()
 453
 454         def cancelConfirm(self, result):
 455                 if not result:
 456                         return
 457
 458                 for x in self["config"].list:
 459                         x[1].cancel()
 460                 # we need to call saveAll to reset the connectedTo choices
 461                 self.saveAll()
 462                 self.restoreService(_("Zap back to service before tuner setup?"))
 463
 464         def nothingConnectedShortcut(self):
 465                 if type(self["config"].getCurrent()[1]) is ConfigSatlist:
 466                         self["config"].getCurrent()[1].setValue("3601")
 467                         self["config"].invalidateCurrent()
 468
 469 class NimSelection(Screen):
 470         def __init__(self, session):
 471                 Screen.__init__(self, session)
 472
 473                 self.list = [None] * nimmanager.getSlotCount()
 474                 self["nimlist"] = List(self.list)
 475                 self.updateList()
 476
 477                 self.setResultClass()
 478
 479                 self["actions"] = ActionMap(["OkCancelActions"],
 480                 {
 481                         "ok": self.okbuttonClick ,
 482                         "cancel": self.close
 483                 }, -2)
 484
 485         def setResultClass(self):
 486                 self.resultclass = NimSetup
 487
 488         def okbuttonClick(self):
 489                 nim = self["nimlist"].getCurrent()
 490                 nim = nim and nim[3]
 491                 if nim is not None and not nim.empty:
 492                         self.session.openWithCallback(self.updateList, self.resultclass, nim.slot)
 493
 494         def showNim(self, nim):
 495                 return True
 496
 497         def updateList(self):
 498                 self.list = [ ]
 499                 for x in nimmanager.nim_slots:
 500                         slotid = x.slot
 501                         nimConfig = nimmanager.getNimConfig(x.slot)
 502                         text = nimConfig.configMode.value
 503                         if self.showNim(x):
 504                                 if x.isCompatible("DVB-S"):
 505                                         if nimConfig.configMode.value in ("loopthrough", "equal", "satposdepends"):
 506                                                 text = { "loopthrough": _("loopthrough to"),
 507                                                                  "equal": _("equal to"),
 508                                                                  "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value]
 509                                                 text += " " + _("Tuner") + " " + ["A", "B", "C", "D"][int(nimConfig.connectedTo.value)]
 510                                         elif nimConfig.configMode.value == "nothing":
 511                                                 text = _("not configured")
 512                                         elif nimConfig.configMode.value == "simple":
 513                                                 if nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 514                                                         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"
 515                                                         text += _("Sats") + ": "
 516                                                         satnames = []
 517                                                         if nimConfig.diseqcA.orbital_position != 3601:
 518                                                                 satnames.append(nimmanager.getSatName(int(nimConfig.diseqcA.value)))
 519                                                         if nimConfig.diseqcMode.value in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
 520                                                                 if nimConfig.diseqcB.orbital_position != 3601:
 521                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcB.value)))
 522                                                         if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
 523                                                                 if nimConfig.diseqcC.orbital_position != 3601:
 524                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcC.value)))
 525                                                                 if nimConfig.diseqcD.orbital_position != 3601:
 526                                                                         satnames.append(nimmanager.getSatName(int(nimConfig.diseqcD.value)))
 527                                                         if len(satnames) <= 2:
 528                                                                 text += ", ".join(satnames)
 529                                                         elif len(satnames) > 2:
 530                                                                 # we need a newline here, since multi content lists don't support automtic line wrapping
 531                                                                 text += ", ".join(satnames[:2]) + ",\n"
 532                                                                 text += "         " + ", ".join(satnames[2:])
 533                                                 elif nimConfig.diseqcMode.value == "positioner":
 534                                                         text = _("Positioner") + ":"
 535                                                         if nimConfig.positionerMode.value == "usals":
 536                                                                 text += _("USALS")
 537                                                         elif nimConfig.positionerMode.value == "manual":
 538                                                                 text += _("manual")
 539                                                 else:
 540                                                         text = _("simple")
 541                                         elif nimConfig.configMode.value == "advanced":
 542                                                 text = _("advanced")
 543                                 elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"):
 544                                         if nimConfig.configMode.value == "nothing":
 545                                                 text = _("nothing connected")
 546                                         elif nimConfig.configMode.value == "enabled":
 547                                                 text = _("enabled")
 548                                 if x.isMultiType():
 549                                         text = _("Switchable tuner types:") + "(" + ','.join(x.getMultiTypeList().values()) + ")" + "\n" + text
 550
 551                                 self.list.append((slotid, x.friendly_full_description, text, x))
 552                 self["nimlist"].setList(self.list)
 553                 self["nimlist"].updateList(self.list)