1 from enigma import runMainloop, eDVBDB, eTimer, quitMainloop, eDVBVolumecontrol, \
2 getDesktop, ePythonConfigQuery, eAVSwitch, eWindow, eServiceEvent
5 from Components.Language import language
8 print "language set to", language.getLanguage()
9 eServiceEvent.setEPGLanguage(language.getLanguage())
11 language.addCallback(setEPGLanguage)
13 from traceback import print_exc
14 import Screens.InfoBar
15 from Screens.SimpleSummary import SimpleSummary
17 from sys import stdout, exc_info
19 from Components.ParentalControl import InitParentalControl
22 from Navigation import Navigation
24 from skin import readSkin, applyAllAttributes
26 from Tools.Directories import InitFallbackFiles, resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE
27 from Components.config import config, configfile, ConfigText, ConfigSubsection, ConfigInteger
29 eDVBDB.getInstance().reloadBouquets()
31 config.misc.radiopic = ConfigText(default = resolveFilename(SCOPE_SKIN_IMAGE)+"radio.mvi")
34 import twisted.python.runtime
35 twisted.python.runtime.platform.supportsThreads = lambda: False
40 from twisted.internet import reactor
45 print "twisted not available"
49 # initialize autorun plugins and plugin menu entries
50 from Components.PluginComponent import plugins
52 from Screens.Wizard import wizardManager
53 from Screens.ImageWizard import *
54 from Screens.StartWizard import *
55 from Screens.TutorialWizard import *
56 from Tools.BoundFunction import boundFunction
57 from Plugins.Plugin import PluginDescriptor
61 def dump(dir, p = ""):
62 if isinstance(dir, dict):
63 for (entry, val) in dir.items():
64 dump(val, p + "(dict)/" + entry)
65 if hasattr(dir, "__dict__"):
66 for name, value in dir.__dict__.items():
67 if not had.has_key(str(value)):
69 dump(value, p + "/" + str(name))
71 print p + "/" + str(name) + ":" + str(dir.__class__) + "(cycle)"
73 print p + ":" + str(dir)
75 # + ":" + str(dir.__class__)
80 def create(self, screen): pass
84 class HTMLOutputDevice(OutputDevice):
85 def create(self, comp):
86 print comp.produceHTML()
88 html = HTMLOutputDevice()
90 class GUIOutputDevice(OutputDevice):
92 def create(self, comp, desktop):
93 comp.createGUIScreen(self.parent, desktop)
95 from Screens.Globals import Globals
96 from Screens.SessionGlobals import SessionGlobals
97 from Screens.Screen import Screen
99 Screen.global_screen = Globals()
102 # * push current active dialog ('current_dialog') onto stack
103 # * call execEnd for this dialog
104 # * clear in_exec flag
106 # * instantiate new dialog into 'current_dialog'
107 # * create screens, components
109 # * create GUI for screen
110 # * call execBegin for new dialog
113 # * call components' / screen's onExecBegin
114 # ... screen is active, until it calls 'close'...
117 # * save return value
118 # * start deferred close handler ('onClose')
127 def __init__(self, desktop = None, summary_desktop = None, navigation = None):
128 self.desktop = desktop
129 self.summary_desktop = summary_desktop
130 self.nav = navigation
131 self.delay_timer = eTimer()
132 self.delay_timer.timeout.get().append(self.processDelay)
134 self.current_dialog = None
136 self.dialog_stack = [ ]
137 self.summary_stack = [ ]
142 self.screen = SessionGlobals(self)
144 for p in plugins.getPlugins(PluginDescriptor.WHERE_SESSIONSTART):
145 p(reason=0, session=self)
147 def processDelay(self):
148 callback = self.current_dialog.callback
150 retval = self.current_dialog.returnValue
152 if self.current_dialog.isTmp:
153 self.current_dialog.doClose()
154 # dump(self.current_dialog)
155 del self.current_dialog
157 del self.current_dialog.callback
160 if callback is not None:
163 def execBegin(self, first=True, do_show = True):
164 assert not self.in_exec
166 c = self.current_dialog
168 # when this is an execbegin after a execend of a "higher" dialog,
169 # popSummary already did the right thing.
172 summary = c.createSummary() or SimpleSummary
173 self.summary = self.instantiateSummaryDialog(summary, c)
175 c.addSummary(self.summary)
179 # when execBegin opened a new dialog, don't bother showing the old one.
180 if c == self.current_dialog and do_show:
183 def execEnd(self, last=True):
187 self.current_dialog.execEnd()
188 self.current_dialog.hide()
191 self.current_dialog.removeSummary(self.summary)
194 def create(self, screen, arguments, **kwargs):
195 # creates an instance of 'screen' (which is a class)
197 return screen(self, *arguments, **kwargs)
199 errstr = "Screen %s(%s, %s): %s" % (str(screen), str(arguments), str(kwargs), exc_info()[0])
201 print_exc(file=stdout)
204 def instantiateDialog(self, screen, *arguments, **kwargs):
205 return self.doInstantiateDialog(screen, arguments, kwargs, self.desktop)
207 def deleteDialog(self, screen):
211 def instantiateSummaryDialog(self, screen, *arguments, **kwargs):
212 return self.doInstantiateDialog(screen, arguments, kwargs, self.summary_desktop)
214 def doInstantiateDialog(self, screen, arguments, kwargs, desktop):
218 dlg = self.create(screen, arguments, **kwargs)
220 print 'EXCEPTION IN DIALOG INIT CODE, ABORTING:'
222 print_exc(file=stdout)
230 readSkin(dlg, None, dlg.skinName, desktop)
232 # create GUI view of this dialog
233 assert desktop is not None
237 for (key, value) in dlg.skinAttributes:
238 if key == "zPosition":
243 dlg.instance = eWindow(desktop, z)
245 applyAllAttributes(dlg.instance, desktop, dlg.skinAttributes)
246 gui = GUIOutputDevice()
247 gui.parent = dlg.instance
248 gui.create(dlg, desktop)
252 def pushCurrent(self):
253 if self.current_dialog is not None:
254 self.dialog_stack.append((self.current_dialog, self.current_dialog.shown))
255 self.execEnd(last=False)
257 def popCurrent(self):
258 if len(self.dialog_stack):
259 (self.current_dialog, do_show) = self.dialog_stack.pop()
260 self.execBegin(first=False, do_show=do_show)
262 self.current_dialog = None
264 def execDialog(self, dialog):
266 self.current_dialog = dialog
267 self.current_dialog.isTmp = False
268 self.current_dialog.callback = None # would cause re-entrancy problems.
271 def openWithCallback(self, callback, screen, *arguments, **kwargs):
272 dlg = self.open(screen, *arguments, **kwargs)
273 dlg.callback = callback
276 def open(self, screen, *arguments, **kwargs):
277 if len(self.dialog_stack) and not self.in_exec:
278 raise "modal open are allowed only from a screen which is modal!"
279 # ...unless it's the very first screen.
282 dlg = self.current_dialog = self.instantiateDialog(screen, *arguments, **kwargs)
288 def close(self, screen, *retval):
290 print "close after exec!"
293 # be sure that the close is for the right dialog!
294 # if it's not, you probably closed after another dialog
295 # was opened. this can happen if you open a dialog
296 # onExecBegin, and forget to do this only once.
297 # after close of the top dialog, the underlying will
298 # gain focus again (for a short time), thus triggering
299 # the onExec, which opens the dialog again, closing the loop.
300 assert screen == self.current_dialog
302 self.current_dialog.returnValue = retval
303 self.delay_timer.start(0, 1)
306 def pushSummary(self):
307 if self.summary is not None:
309 self.summary_stack.append(self.summary)
312 def popSummary(self):
313 if self.summary is not None:
314 self.summary.doClose()
315 self.summary = self.summary_stack.pop()
316 if self.summary is not None:
319 from Screens.Volume import Volume
320 from Screens.Mute import Mute
321 from GlobalActions import globalActionMap
323 #TODO .. move this to a own .py file
325 """Volume control, handles volUp, volDown, volMute actions and display
326 a corresponding dialog"""
327 def __init__(self, session):
328 global globalActionMap
329 globalActionMap.actions["volumeUp"]=self.volUp
330 globalActionMap.actions["volumeDown"]=self.volDown
331 globalActionMap.actions["volumeMute"]=self.volMute
333 config.audio = ConfigSubsection()
334 config.audio.volume = ConfigInteger(default = 100, limits = (0, 100))
336 self.volumeDialog = session.instantiateDialog(Volume)
337 self.muteDialog = session.instantiateDialog(Mute)
339 self.hideVolTimer = eTimer()
340 self.hideVolTimer.timeout.get().append(self.volHide)
342 vol = config.audio.volume.value
343 self.volumeDialog.setValue(vol)
344 self.volctrl = eDVBVolumecontrol.getInstance()
345 self.volctrl.setVolume(vol, vol)
348 if self.volctrl.isMuted():
349 config.audio.volume.value = 0
351 config.audio.volume.value = self.volctrl.getVolume()
352 config.audio.volume.save()
360 def setVolume(self, direction):
361 oldvol = self.volctrl.getVolume()
363 self.volctrl.volumeUp()
365 self.volctrl.volumeDown()
366 is_muted = self.volctrl.isMuted()
367 vol = self.volctrl.getVolume()
368 self.volumeDialog.show()
370 self.volMute() # unmute
372 self.volMute(False, True) # mute but dont show mute symbol
373 if self.volctrl.isMuted():
374 self.volumeDialog.setValue(0)
376 self.volumeDialog.setValue(self.volctrl.getVolume())
378 self.hideVolTimer.start(3000, True)
381 self.volumeDialog.hide()
383 def volMute(self, showMuteSymbol=True, force=False):
384 vol = self.volctrl.getVolume()
386 self.volctrl.volumeToggleMute()
387 if self.volctrl.isMuted():
389 self.muteDialog.show()
390 self.volumeDialog.setValue(0)
392 self.muteDialog.hide()
393 self.volumeDialog.setValue(vol)
395 import Screens.Standby
396 from Screens.Menu import MainMenu, mdom
397 import xml.dom.minidom
400 """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
402 def __init__(self, session):
403 self.session = session
404 globalActionMap.actions["power_down"]=self.powerdown
405 globalActionMap.actions["power_up"]=self.powerup
406 globalActionMap.actions["power_long"]=self.powerlong
407 self.standbyblocked = 1
409 def MenuClosed(self, *val):
410 self.session.infobar = None
413 self.standbyblocked = 1
414 action = config.usage.on_long_powerpress.value
415 if action == "shutdown":
416 print "PowerOff - Now!"
417 if not Screens.Standby.inTryQuitMainloop:
418 self.session.open(Screens.Standby.TryQuitMainloop, 1)
419 elif action == "show_menu":
420 print "Show shutdown Menu"
421 menu = mdom.childNodes[0]
422 for x in menu.childNodes:
423 if x.nodeType != xml.dom.minidom.Element.nodeType:
425 elif x.tagName == 'menu':
426 for y in x.childNodes:
427 if y.nodeType != xml.dom.minidom.Element.nodeType:
429 elif y.tagName == 'id':
430 id = y.getAttribute("val")
431 if id and id == "shutdown":
432 self.session.infobar = self
433 menu_screen = self.session.openWithCallback(self.MenuClosed, MainMenu, x, x.childNodes)
434 menu_screen.setTitle(_("Standby / Restart"))
438 self.standbyblocked = 0
441 if self.standbyblocked == 0:
442 self.standbyblocked = 1
446 if not Screens.Standby.inStandby and self.session.current_dialog and self.session.current_dialog.ALLOW_SUSPEND:
447 self.session.open(Screens.Standby.Standby)
449 from Screens.Scart import Scart
451 class AutoScartControl:
452 def __init__(self, session):
454 self.current_vcr_sb = eAVSwitch.getInstance().getVCRSlowBlanking()
455 if self.current_vcr_sb and config.av.vcrswitch.value:
456 self.scartDialog = session.instantiateDialog(Scart, True)
458 self.scartDialog = session.instantiateDialog(Scart, False)
459 config.av.vcrswitch.addNotifier(self.recheckVCRSb)
460 eAVSwitch.getInstance().vcr_sb_notifier.get().append(self.VCRSbChanged)
462 def recheckVCRSb(self, configElement):
463 self.VCRSbChanged(self.current_vcr_sb)
465 def VCRSbChanged(self, value):
466 #print "vcr sb changed to", value
467 self.current_vcr_sb = value
468 if config.av.vcrswitch.value or value > 2:
470 self.scartDialog.showMessageBox()
472 self.scartDialog.switchToTV()
474 from enigma import eDVBCIInterfaces
477 plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
479 session = Session(desktop = getDesktop(0), summary_desktop = getDesktop(1), navigation = Navigation())
483 for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD):
484 screensToRun.append(p.__call__)
486 screensToRun += wizardManager.getWizards()
488 screensToRun.append(Screens.InfoBar.InfoBar)
490 ePythonConfigQuery.setQueryFunc(configfile.getResolvedKey)
492 # eDVBCIInterfaces.getInstance().setDescrambleRules(0 # Slot Number
493 # ,( ["1:0:1:24:4:85:C00000:0:0:0:"], #service_list
494 # ["PREMIERE"], #provider_list,
498 def runNextScreen(session, screensToRun, *result):
500 quitMainloop(*result)
503 screen = screensToRun[0]
505 if len(screensToRun):
506 session.openWithCallback(boundFunction(runNextScreen, session, screensToRun[1:]), screen)
510 runNextScreen(session, screensToRun)
512 vol = VolumeControl(session)
513 power = PowerKey(session)
515 # we need session.scart to access it from within menu.xml
516 session.scart = AutoScartControl(session)
522 from time import time
523 from Tools.DreamboxHardware import setFPWakeuptime
524 #get next record timer start time
525 nextRecordingTime = session.nav.RecordTimer.getNextRecordingTime()
526 #get next zap timer start time
527 nextZapTime = session.nav.RecordTimer.getNextZapTime()
530 if nextZapTime != -1 and nextRecordingTime != -1:
531 startTime = nextZapTime < nextRecordingTime and nextZapTime or nextRecordingTime
533 startTime = nextZapTime != -1 and nextZapTime or nextRecordingTime
535 if (startTime - nowTime < 330): # no time to switch box back on
536 setFPWakeuptime(nowTime + 30) # so switch back on in 30 seconds
538 setFPWakeuptime(startTime - 300)
539 session.nav.stopService()
540 session.nav.shutdown()
545 skin.loadSkinData(getDesktop(0))
547 import Components.InputDevice
548 Components.InputDevice.InitInputDevices()
550 import Components.AVSwitch
551 Components.AVSwitch.InitAVSwitch()
553 import Components.RecordingConfig
554 Components.RecordingConfig.InitRecordingConfig()
556 import Components.UsageConfig
557 Components.UsageConfig.InitUsageConfig()
560 keymapparser.readKeymap(config.usage.keymap.value)
562 import Components.Network
563 Components.Network.InitNetwork()
565 import Components.Lcd
566 Components.Lcd.InitLcd()
568 import Components.SetupDevices
569 Components.SetupDevices.InitSetupDevices()
571 import Components.RFmod
572 Components.RFmod.InitRFmod()
575 Screens.Ci.InitCiConfig()
577 # first, setup a screen
583 from Components.ParentalControl import parentalControl
584 parentalControl.save()
586 print 'EXCEPTION IN PYTHON STARTUP CODE:'
588 print_exc(file=stdout)