implement and re-enable default ac3 option
[enigma2.git] / mytest.py
1 from Tools import RedirectOutput
2 from enigma import *
3 from tools import *
4
5 from Components.Language import language
6
7 def setEPGLanguage():
8         print "language set to", language.getLanguage()
9         eServiceEvent.setEPGLanguage(language.getLanguage())
10         
11 language.addCallback(setEPGLanguage)
12
13 import traceback
14 import Screens.InfoBar
15 from Screens.SimpleSummary import SimpleSummary
16
17 import sys
18 import time
19
20 import ServiceReference
21
22 from Navigation import Navigation
23
24 from skin import readSkin, applyAllAttributes
25
26 from Components.config import configfile
27 from Tools.Directories import InitFallbackFiles, resolveFilename, SCOPE_PLUGINS
28 InitFallbackFiles()
29 eDVBDB.getInstance().reloadBouquets()
30
31 try:
32         import e2reactor
33         e2reactor.install()
34         
35         from twisted.internet import reactor
36         
37         def runReactor():
38                 reactor.run()
39 except ImportError:
40         print "twisted not available"
41         def runReactor():
42                 runMainloop()
43
44 # initialize autorun plugins and plugin menu entries
45 from Components.PluginComponent import plugins
46
47 from Screens.Wizard import wizardManager
48 from Screens.ImageWizard import *
49 from Screens.StartWizard import *
50 from Screens.TutorialWizard import *
51 from Tools.BoundFunction import boundFunction
52 from Plugins.Plugin import PluginDescriptor
53
54 had = dict()
55
56 def dump(dir, p = ""):
57         if isinstance(dir, dict):
58                 for (entry, val) in dir.items():
59                         dump(val, p + "(dict)/" + entry)
60         if hasattr(dir, "__dict__"):
61                 for name, value in dir.__dict__.items():
62                         if not had.has_key(str(value)):
63                                 had[str(value)] = 1
64                                 dump(value, p + "/" + str(name))
65                         else:
66                                 print p + "/" + str(name) + ":" + str(dir.__class__) + "(cycle)"
67         else:
68                 print p + ":" + str(dir)
69
70 # + ":" + str(dir.__class__)
71
72 # display
73
74 class OutputDevice:
75         def create(self, screen): pass
76
77 # display: HTML
78
79 class HTMLOutputDevice(OutputDevice):
80         def create(self, comp):
81                 print comp.produceHTML()
82
83 html = HTMLOutputDevice()
84
85 class GUIOutputDevice(OutputDevice):
86         parent = None
87         def create(self, comp, desktop):
88                 comp.createGUIScreen(self.parent, desktop)
89
90 # Session.open:
91 # * push current active dialog ('current_dialog') onto stack
92 # * call execEnd for this dialog
93 #   * clear in_exec flag
94 #   * hide screen
95 # * instantiate new dialog into 'current_dialog'
96 #   * create screens, components
97 #   * read, apply skin
98 #   * create GUI for screen
99 # * call execBegin for new dialog
100 #   * set in_exec
101 #   * show gui screen
102 #   * call components' / screen's onExecBegin
103 # ... screen is active, until it calls 'close'...
104 # Session.close:
105 # * assert in_exec
106 # * save return value
107 # * start deferred close handler ('onClose')
108 # * execEnd
109 #   * clear in_exec
110 #   * hide screen
111 # .. a moment later:
112 # Session.doClose:
113 # * destroy screen
114
115 class Session:
116         def __init__(self, desktop = None, summary_desktop = None, navigation = None):
117                 self.desktop = desktop
118                 self.summary_desktop = summary_desktop
119                 self.nav = navigation
120                 self.delay_timer = eTimer()
121                 self.delay_timer.timeout.get().append(self.processDelay)
122                 
123                 self.current_dialog = None
124                 
125                 self.dialog_stack = [ ]
126                 self.summary_stack = [ ]
127                 self.summary = None
128                 
129                 self.in_exec = False
130                 
131                 for p in plugins.getPlugins(PluginDescriptor.WHERE_SESSIONSTART):
132                         p(reason=0, session=self)
133         
134         def processDelay(self):
135                 callback = self.current_dialog.callback
136
137                 retval = self.current_dialog.returnValue
138
139                 if self.current_dialog.isTmp:
140                         self.current_dialog.doClose()
141 #                       dump(self.current_dialog)
142                         del self.current_dialog
143                 else:
144                         del self.current_dialog.callback
145                 
146                 self.popCurrent()
147                 if callback is not None:
148                         callback(*retval)
149
150         def execBegin(self):
151                 assert not self.in_exec 
152                 self.in_exec = True
153                 c = self.current_dialog
154                 
155                 self.pushSummary()
156
157                 summary = c.createSummary() or SimpleSummary
158                 self.summary = self.instantiateSummaryDialog(summary, c)
159                 self.summary.show()
160
161                 c.addSummary(self.summary)
162                 c.execBegin()
163
164                 # when execBegin opened a new dialog, don't bother showing the old one.
165                 if c == self.current_dialog:
166                         c.show()
167                 
168         def execEnd(self):
169                 assert self.in_exec
170                 self.in_exec = False
171
172                 self.current_dialog.execEnd()
173                 self.current_dialog.hide()
174                 self.current_dialog.removeSummary(self.summary)
175                 self.popSummary()
176         
177         def create(self, screen, arguments, **kwargs):
178                 # creates an instance of 'screen' (which is a class)
179                 try:
180                         return screen(self, *arguments, **kwargs)
181                 except:
182                         errstr = "Screen %s(%s, %s): %s" % (str(screen), str(arguments), str(kwargs), sys.exc_info()[0])
183                         print errstr
184                         traceback.print_exc(file=sys.stdout)
185                         quitMainloop(5)
186         
187         def instantiateDialog(self, screen, *arguments, **kwargs):
188                 return self.doInstantiateDialog(screen, arguments, kwargs, self.desktop)
189         
190         def instantiateSummaryDialog(self, screen, *arguments, **kwargs):
191                 return self.doInstantiateDialog(screen, arguments, kwargs, self.summary_desktop)
192         
193         def doInstantiateDialog(self, screen, arguments, kwargs, desktop):
194                 # create dialog
195                 
196                 try:
197                         dlg = self.create(screen, arguments, **kwargs)
198                 except:
199                         print 'EXCEPTION IN DIALOG INIT CODE, ABORTING:'
200                         print '-'*60
201                         traceback.print_exc(file=sys.stdout)
202                         quitMainloop(5)
203                         print '-'*60
204                 
205                 if dlg is None:
206                         return
207
208                 # read skin data
209                 readSkin(dlg, None, dlg.skinName, desktop)
210
211                 # create GUI view of this dialog
212                 assert desktop is not None
213                 
214                 z = 0
215                 title = ""
216                 for (key, value) in dlg.skinAttributes:
217                         if key == "zPosition":
218                                 z = int(value)
219                         elif key == "title":
220                                 title = value
221                 
222                 dlg.instance = eWindow(desktop, z)
223                 dlg.title = title
224                 applyAllAttributes(dlg.instance, desktop, dlg.skinAttributes)
225                 gui = GUIOutputDevice()
226                 gui.parent = dlg.instance
227                 gui.create(dlg, desktop)
228                 
229                 return dlg
230          
231         def pushCurrent(self):
232                 if self.current_dialog is not None:
233                         self.dialog_stack.append(self.current_dialog)
234                         self.execEnd()
235         
236         def popCurrent(self):
237                 if len(self.dialog_stack):
238                         self.current_dialog = self.dialog_stack.pop()
239                         self.execBegin()
240                 else:
241                         self.current_dialog = None
242
243         def execDialog(self, dialog):
244                 self.pushCurrent()
245                 self.current_dialog = dialog
246                 self.current_dialog.isTmp = False
247                 self.current_dialog.callback = None # would cause re-entrancy problems.
248                 self.execBegin()
249
250         def openWithCallback(self, callback, screen, *arguments, **kwargs):
251                 dlg = self.open(screen, *arguments, **kwargs)
252                 dlg.callback = callback
253                 return dlg
254
255         def open(self, screen, *arguments, **kwargs):
256                 if len(self.dialog_stack) and not self.in_exec:
257                         raise "modal open are allowed only from a screen which is modal!"
258                         # ...unless it's the very first screen.
259                 
260                 self.pushCurrent()
261                 dlg = self.current_dialog = self.instantiateDialog(screen, *arguments, **kwargs)
262                 dlg.isTmp = True
263                 dlg.callback = None
264                 self.execBegin()
265                 return dlg
266
267         def keyEvent(self, code):
268                 print "code " + str(code)
269
270         def close(self, screen, *retval):
271                 if not self.in_exec:
272                         print "close after exec!"
273                         return
274                 
275                 # be sure that the close is for the right dialog!
276                 # if it's not, you probably closed after another dialog
277                 # was opened. this can happen if you open a dialog
278                 # onExecBegin, and forget to do this only once.
279                 # after close of the top dialog, the underlying will
280                 # gain focus again (for a short time), thus triggering
281                 # the onExec, which opens the dialog again, closing the loop.
282                 assert screen == self.current_dialog
283                 
284                 self.current_dialog.returnValue = retval
285                 self.delay_timer.start(0, 1)
286                 self.execEnd()
287
288         def pushSummary(self):
289                 if self.summary is not None:
290                         self.summary.hide()
291                 self.summary_stack.append(self.summary)
292                 self.summary = None
293
294         def popSummary(self):
295                 if self.summary is not None:
296                         self.summary.doClose()
297                 self.summary = self.summary_stack.pop()
298                 if self.summary is not None:
299                         self.summary.show()
300
301 from Screens.Volume import Volume
302 from Screens.Mute import Mute
303 from GlobalActions import globalActionMap
304 from Components.config import ConfigSubsection, configSequence, configElement, configsequencearg
305
306 #TODO .. move this to a own .py file
307 class VolumeControl:
308         """Volume control, handles volUp, volDown, volMute actions and display
309         a corresponding dialog"""
310         def __init__(self, session):
311                 global globalActionMap
312                 globalActionMap.actions["volumeUp"]=self.volUp
313                 globalActionMap.actions["volumeDown"]=self.volDown
314                 globalActionMap.actions["volumeMute"]=self.volMute
315
316                 config.audio = ConfigSubsection()
317                 config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
318
319                 self.volumeDialog = session.instantiateDialog(Volume)
320                 self.muteDialog = session.instantiateDialog(Mute)
321
322                 self.hideVolTimer = eTimer()
323                 self.hideVolTimer.timeout.get().append(self.volHide)
324
325                 vol = config.audio.volume.value[0]
326                 self.volumeDialog.setValue(vol)
327                 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
328
329         def volSave(self):
330                 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
331                 config.audio.volume.save()
332
333         def     volUp(self):
334                 if (eDVBVolumecontrol.getInstance().isMuted()):
335                         self.volMute()
336                 eDVBVolumecontrol.getInstance().volumeUp()
337                 self.volumeDialog.show()
338                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
339                 self.volSave()
340                 self.hideVolTimer.start(3000, True)
341
342         def     volDown(self):
343                 if (eDVBVolumecontrol.getInstance().isMuted()):
344                         self.volMute()
345                 eDVBVolumecontrol.getInstance().volumeDown()
346                 self.volumeDialog.show()
347                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
348                 self.volSave()
349                 self.hideVolTimer.start(3000, True)
350
351         def volHide(self):
352                 self.volumeDialog.hide()
353
354         def     volMute(self):
355                 eDVBVolumecontrol.getInstance().volumeToggleMute()
356                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
357
358                 if (eDVBVolumecontrol.getInstance().isMuted()):
359                         self.muteDialog.show()
360                 else:
361                         self.muteDialog.hide()
362
363 from Screens.Standby import Standby
364
365 class PowerKey:
366         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
367         
368         def __init__(self, session):
369                 self.session = session
370                 self.powerKeyTimer = eTimer()
371                 self.powerKeyTimer.timeout.get().append(self.powertimer)
372                 globalActionMap.actions["powerdown"]=self.powerdown
373                 globalActionMap.actions["powerup"]=self.powerup
374                 self.standbyblocked = 0
375 #               self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
376                         #{
377                                 #"powerdown": self.powerdown,
378                                 #"powerup": self.powerup,
379                                 #"discreteStandby": (self.standby, "Go standby"),
380                                 #"discretePowerOff": (self.quit, "Go to deep standby"),
381                         #})
382
383         def powertimer(self):   
384                 print "PowerOff - Now!"
385                 self.quit()
386         
387         def powerdown(self):
388                 self.standbyblocked = 0
389                 self.powerKeyTimer.start(3000, True)
390
391         def powerup(self):
392                 self.powerKeyTimer.stop()
393                 if self.standbyblocked == 0:
394                         self.standbyblocked = 1
395                         self.standby()
396
397         def standby(self):
398                 self.session.open(Standby, self)
399
400         def quit(self):
401                 # halt
402                 quitMainloop(1)
403
404 def runScreenTest():
405         plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
406
407         session = Session(desktop = getDesktop(0), summary_desktop = getDesktop(1), navigation = Navigation())
408         
409         screensToRun = [ ]
410         
411         for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD):
412                 screensToRun.append(p.__call__)
413         
414         screensToRun += wizardManager.getWizards()
415         
416         screensToRun.append(Screens.InfoBar.InfoBar)
417
418         ePythonConfigQuery.setQueryFunc(configfile.getResolvedKey)
419
420         def runNextScreen(session, screensToRun, *result):
421                 if result:
422                         quitMainloop(*result)
423                         return
424         
425                 screen = screensToRun[0]
426                 
427                 if len(screensToRun):
428                         session.openWithCallback(boundFunction(runNextScreen, session, screensToRun[1:]), screen)
429                 else:
430                         session.open(screen)
431         
432         runNextScreen(session, screensToRun)
433         
434         CONNECT(keyPressedSignal(), session.keyEvent)
435         
436         vol = VolumeControl(session)
437         power = PowerKey(session)
438         
439         runReactor()
440         
441         configfile.save()
442         
443         from Tools.DreamboxHardware import setFPWakeuptime
444         from time import time
445         nextRecordingTime = session.nav.RecordTimer.getNextRecordingTime()
446         if nextRecordingTime != -1:
447                 if (nextRecordingTime - time() < 330): # no time to switch box back on
448                         setFPWakeuptime(time() + 30) # so switch back on in 30 seconds
449                 else:
450                         setFPWakeuptime(nextRecordingTime - (300))
451         
452         session.nav.shutdown()
453         
454         return 0
455
456 import keymapparser
457 keymapparser.readKeymap()
458 import skin
459 skin.loadSkinData(getDesktop(0))
460
461 import Components.InputDevice
462 Components.InputDevice.InitInputDevices()
463
464 import Components.AVSwitch
465 Components.AVSwitch.InitAVSwitch()
466
467 import Components.RecordingConfig
468 Components.RecordingConfig.InitRecordingConfig()
469
470 import Components.UsageConfig
471 Components.UsageConfig.InitUsageConfig()
472
473 import Components.Network
474 Components.Network.InitNetwork()
475
476 import Components.Lcd
477 Components.Lcd.InitLcd()
478
479 import Components.SetupDevices
480 Components.SetupDevices.InitSetupDevices()
481
482 import Components.RFmod
483 Components.RFmod.InitRFmod()
484
485 import Components.NimManager
486
487 # first, setup a screen
488 try:
489         runScreenTest()
490
491         plugins.shutdown()
492 except:
493         print 'EXCEPTION IN PYTHON STARTUP CODE:'
494         print '-'*60
495         traceback.print_exc(file=sys.stdout)
496         quitMainloop(5)
497         print '-'*60