code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Screens/Satconfig.py

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