factorize the conditionalPixmap
[enigma2.git] / lib / python / Screens / InfoBarGenerics.py
1 from Screen import Screen
2 from Components.ActionMap import ActionMap, HelpableActionMap
3 from Components.ActionMap import NumberActionMap
4 from Components.Label import Label
5 from Components.config import configfile, configsequencearg
6 from Components.config import config, configElement, ConfigSubsection, configSequence
7 from ChannelSelection import ChannelSelection
8
9 from Components.Pixmap import Pixmap, PixmapConditional
10 from Components.BlinkingPixmap import BlinkingPixmapConditional
11 from Components.ServiceName import ServiceName
12 from Components.EventInfo import EventInfo
13
14 from ServiceReference import ServiceReference
15 from EpgSelection import EPGSelection
16
17 from Screens.MessageBox import MessageBox
18 from Screens.Volume import Volume
19 from Screens.Mute import Mute
20 from Screens.Dish import Dish
21 from Screens.Standby import Standby
22 from Screens.EventView import EventView
23
24 from Tools import Notifications
25
26 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
27 from enigma import *
28
29 import time
30 import os
31
32 # hack alert!
33 from Menu import MainMenu, mdom
34
35 class InfoBarVolumeControl:
36         """Volume control, handles volUp, volDown, volMute actions and display 
37         a corresponding dialog"""
38         def __init__(self):
39                 config.audio = ConfigSubsection()
40                 config.audio.volume = configElement("config.audio.volume", configSequence, [5], configsequencearg.get("INTEGER", (0, 100)))
41
42                 self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
43                         {
44                                 "volumeUp": self.volUp,
45                                 "volumeDown": self.volDown,
46                                 "volumeMute": self.volMute,
47                         })
48
49                 self.volumeDialog = self.session.instantiateDialog(Volume)
50                 self.muteDialog = self.session.instantiateDialog(Mute)
51
52                 self.hideVolTimer = eTimer()
53                 self.hideVolTimer.timeout.get().append(self.volHide)
54
55                 vol = config.audio.volume.value[0]
56                 self.volumeDialog.setValue(vol)
57                 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
58         
59         def volSave(self):
60                 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
61                 config.audio.volume.save()
62                 
63         def     volUp(self):
64                 if (eDVBVolumecontrol.getInstance().isMuted()):
65                         self.volMute()
66                 eDVBVolumecontrol.getInstance().volumeUp()
67                 self.volumeDialog.instance.show()
68                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
69                 self.volSave()
70                 self.hideVolTimer.start(3000)
71
72         def     volDown(self):
73                 if (eDVBVolumecontrol.getInstance().isMuted()):
74                         self.volMute()
75                 eDVBVolumecontrol.getInstance().volumeDown()
76                 self.volumeDialog.instance.show()
77                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
78                 self.volSave()
79                 self.hideVolTimer.start(3000)
80                 
81         def volHide(self):
82                 self.volumeDialog.instance.hide()
83
84         def     volMute(self):
85                 eDVBVolumecontrol.getInstance().volumeToggleMute()
86                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
87                 
88                 if (eDVBVolumecontrol.getInstance().isMuted()):
89                         self.muteDialog.instance.show()
90                 else:
91                         self.muteDialog.instance.hide()
92
93 class InfoBarDish:
94         def __init__(self):
95                 self.dishDialog = self.session.instantiateDialog(Dish)
96                 self.onShown.append(self.dishDialog.instance.show)
97
98 class InfoBarShowHide:
99         """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
100         fancy animations. """
101         STATE_HIDDEN = 0
102         STATE_HIDING = 1
103         STATE_SHOWING = 2
104         STATE_SHOWN = 3
105         
106         def __init__(self):
107                 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
108                         {
109                                 "toggleShow": self.toggleShow,
110                                 "hide": self.hide,
111                         })
112
113                 self.state = self.STATE_SHOWN
114                 
115                 self.onExecBegin.append(self.show)
116                 self.onClose.append(self.delHideTimer)
117                 
118                 self.hideTimer = eTimer()
119                 self.hideTimer.timeout.get().append(self.doTimerHide)
120                 self.hideTimer.start(5000)
121
122         def delHideTimer(self):
123                 del self.hideTimer
124
125         def hide(self): 
126                 self.instance.hide()
127                 
128         def show(self):
129                 self.state = self.STATE_SHOWN
130                 self.hideTimer.stop()
131                 self.hideTimer.start(5000)
132
133         def doTimerHide(self):
134                 self.hideTimer.stop()
135                 if self.state == self.STATE_SHOWN:
136                         self.instance.hide()
137                         self.state = self.STATE_HIDDEN
138
139         def toggleShow(self):
140                 if self.state == self.STATE_SHOWN:
141                         self.instance.hide()
142                         #pls check animation support, sorry
143 #                       self.startHide()
144                         self.hideTimer.stop()
145                         self.state = self.STATE_HIDDEN
146                 elif self.state == self.STATE_HIDDEN:
147                         self.instance.show()
148                         self.show()
149                         
150         def startShow(self):
151                 self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
152                 self.state = self.STATE_SHOWN
153         
154         def startHide(self):
155                 self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
156                 self.state = self.STATE_HIDDEN
157
158 class NumberZap(Screen):
159         def quit(self):
160                 self.Timer.stop()
161                 self.close(0)
162
163         def keyOK(self):
164                 self.Timer.stop()
165                 self.close(int(self["number"].getText()))
166
167         def keyNumberGlobal(self, number):
168                 self.Timer.start(3000)          #reset timer
169                 self.field = self.field + str(number)
170                 self["number"].setText(self.field)
171                 if len(self.field) >= 4:
172                         self.keyOK()
173
174         def __init__(self, session, number):
175                 Screen.__init__(self, session)
176                 self.field = str(number)
177
178                 self["channel"] = Label(_("Channel:"))
179
180                 self["number"] = Label(self.field)
181
182                 self["actions"] = NumberActionMap( [ "SetupActions" ], 
183                         {
184                                 "cancel": self.quit,
185                                 "ok": self.keyOK,
186                                 "1": self.keyNumberGlobal,
187                                 "2": self.keyNumberGlobal,
188                                 "3": self.keyNumberGlobal,
189                                 "4": self.keyNumberGlobal,
190                                 "5": self.keyNumberGlobal,
191                                 "6": self.keyNumberGlobal,
192                                 "7": self.keyNumberGlobal,
193                                 "8": self.keyNumberGlobal,
194                                 "9": self.keyNumberGlobal,
195                                 "0": self.keyNumberGlobal
196                         })
197
198                 self.Timer = eTimer()
199                 self.Timer.timeout.get().append(self.keyOK)
200                 self.Timer.start(3000)
201
202 class InfoBarPowerKey:
203         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
204         
205         def __init__(self):
206                 self.powerKeyTimer = eTimer()
207                 self.powerKeyTimer.timeout.get().append(self.powertimer)
208                 self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
209                         {
210                                 "powerdown": self.powerdown,
211                                 "powerup": self.powerup,
212                                 "discreteStandby": (self.standby, "Go standby"),
213                                 "discretePowerOff": (self.quit, "Go to deep standby"),
214                         })
215
216         def powertimer(self):   
217                 print "PowerOff - Now!"
218                 self.quit()
219         
220         def powerdown(self):
221                 self.standbyblocked = 0
222                 self.powerKeyTimer.start(3000)
223
224         def powerup(self):
225                 self.powerKeyTimer.stop()
226                 if self.standbyblocked == 0:
227                         self.standbyblocked = 1
228                         self.standby()
229
230         def standby(self):
231                 self.session.open(Standby, self)
232
233         def quit(self):
234                 # halt
235                 quitMainloop(1)
236
237 class InfoBarNumberZap:
238         """ Handles an initial number for NumberZapping """
239         def __init__(self):
240                 self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
241                         {
242                                 "1": self.keyNumberGlobal,
243                                 "2": self.keyNumberGlobal,
244                                 "3": self.keyNumberGlobal,
245                                 "4": self.keyNumberGlobal,
246                                 "5": self.keyNumberGlobal,
247                                 "6": self.keyNumberGlobal,
248                                 "7": self.keyNumberGlobal,
249                                 "8": self.keyNumberGlobal,
250                                 "9": self.keyNumberGlobal,
251                                 "0": self.keyNumberGlobal,
252                         })
253
254         def keyNumberGlobal(self, number):
255 #               print "You pressed number " + str(number)
256                 self.session.openWithCallback(self.numberEntered, NumberZap, number)
257
258         def numberEntered(self, retval):
259 #               print self.servicelist
260                 if retval > 0:
261                         self.zapToNumber(retval)
262
263         def searchNumberHelper(self, serviceHandler, num, bouquet):
264                 servicelist = serviceHandler.list(bouquet)
265                 if not servicelist is None:
266                         while num:
267                                 serviceIterator = servicelist.getNext()
268                                 if not serviceIterator.valid(): #check end of list
269                                         break
270                                 if serviceIterator.flags: #assume normal dvb service have no flags set
271                                         continue
272                                 num -= 1;
273                         if not num: #found service with searched number ?
274                                 return serviceIterator, 0
275                 return None, num
276
277         def zapToNumber(self, number):
278                 bouquet = self.servicelist.bouquet_root
279                 service = None
280                 serviceHandler = eServiceCenter.getInstance()
281                 if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
282                         service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
283                 else:
284                         bouquetlist = serviceHandler.list(bouquet)
285                         if not bouquetlist is None:
286                                 while number:
287                                         bouquet = bouquetlist.getNext()
288                                         if not bouquet.valid(): #check end of list
289                                                 break
290                                         if ((bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
291                                                 continue
292                                         service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
293                 if not service is None:
294                         self.session.nav.playService(service) #play service
295                         if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
296                                 self.servicelist.setRoot(bouquet)
297                         self.servicelist.setCurrentSelection(service) #select the service in servicelist
298
299 class InfoBarChannelSelection:
300         """ ChannelSelection - handles the channelSelection dialog and the initial 
301         channelChange actions which open the channelSelection dialog """
302         def __init__(self):
303                 #instantiate forever
304                 self.servicelist = self.session.instantiateDialog(ChannelSelection)
305
306                 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
307                         {
308                                 "switchChannelUp": self.switchChannelUp,
309                                 "switchChannelDown": self.switchChannelDown,
310                                 "zapUp": (self.zapUp, _("next channel")),
311                                 "zapDown": (self.zapDown, _("previous channel")),
312                         })
313                         
314         def switchChannelUp(self):      
315                 self.servicelist.moveUp()
316                 self.session.execDialog(self.servicelist)
317
318         def switchChannelDown(self):    
319                 self.servicelist.moveDown()
320                 self.session.execDialog(self.servicelist)
321
322         def     zapUp(self):
323                 self.servicelist.moveUp()
324                 self.servicelist.zap()
325                 self.instance.show()
326                 self.show()
327
328         def     zapDown(self):
329                 self.servicelist.moveDown()
330                 self.servicelist.zap()
331                 self.instance.show()
332                 self.show()
333                 
334 class InfoBarMenu:
335         """ Handles a menu action, to open the (main) menu """
336         def __init__(self):
337                 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
338                         {
339                                 "mainMenu": (self.mainMenu, "Enter main menu..."),
340                         })
341
342         def mainMenu(self):
343                 print "loading mainmenu XML..."
344                 menu = mdom.childNodes[0]
345                 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
346                 self.session.open(MainMenu, menu, menu.childNodes)
347
348 class InfoBarEPG:
349         """ EPG - Opens an EPG list when the showEPGList action fires """
350         def __init__(self):
351                 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
352                         {
353                                 "showEPGList": (self.showEPGList, _("show EPG...")),
354                         })
355
356         def showEPGList(self):
357                 ref=self.session.nav.getCurrentlyPlayingServiceReference()
358                 ptr=eEPGCache.getInstance()
359                 if ptr.startTimeQuery(ref) != -1:
360                         self.session.open(EPGSelection, ref)
361                 else: # try to show now/next
362                         print 'no epg for service', ref.toString()
363                         try:
364                                 self.epglist = [ ]
365                                 service = self.session.nav.getCurrentService()
366                                 info = service.info()
367                                 ptr=info.getEvent(0)
368                                 if ptr:
369                                         self.epglist.append(ptr)
370                                 ptr=info.getEvent(1)
371                                 if ptr:
372                                         self.epglist.append(ptr)
373                                 if len(self.epglist) > 0:
374                                         self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
375                         except:
376                                 pass
377
378         def eventViewCallback(self, setEvent, val): #used for now/next displaying
379                 if len(self.epglist) > 1:
380                         tmp = self.epglist[0]
381                         self.epglist[0]=self.epglist[1]
382                         self.epglist[1]=tmp
383                         setEvent(self.epglist[0])
384
385 class InfoBarEvent:
386         """provides a current/next event info display"""
387         def __init__(self):
388                 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
389                 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
390                                 
391                 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
392                 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
393
394                 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
395                 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
396
397 class InfoBarServiceName:
398         def __init__(self):
399                 self["ServiceName"] = ServiceName(self.session.nav)
400
401 class InfoBarPVR:
402         """handles PVR specific actions like seeking, pause"""
403         def __init__(self):
404                 self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions", 
405                         {
406                                 "pauseService": (self.pauseService, "pause"),
407                                 "unPauseService": (self.unPauseService, "continue"),
408                                 
409                                 "seekFwd": (self.seekFwd, "skip forward"),
410                                 "seekBack": (self.seekBack, "skip backward"),
411                         })
412                 
413         def pauseService(self):
414                 self.session.nav.pause(1)
415                 
416         def unPauseService(self):
417                 self.session.nav.pause(0)
418         
419         def doSeek(self, dir, seektime):
420                 service = self.session.nav.getCurrentService()
421                 if service is None:
422                         return
423                 
424                 seekable = service.seek()
425                 if seekable is None:
426                         return
427                 seekable.seekRelative(dir, 90 * seektime)
428
429         def seekFwd(self):
430                 self.doSeek(+1, 60000)
431         
432         def seekBack(self):
433                 self.doSeek(-1, 60000)
434
435 class InfoBarInstantRecord:
436         """Instant Record - handles the instantRecord action in order to 
437         start/stop instant records"""
438         def __init__(self):
439                 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
440                         {
441                                 "instantRecord": (self.instantRecord, "Instant Record..."),
442                         })
443                 self.recording = None
444                 
445                 self["BlinkingPoint"] = BlinkingPixmapConditional()
446                 self.onShown.append(self["BlinkingPoint"].hideWidget)
447                 self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
448                 
449         def stopCurrentRecording(self): 
450                 self.session.nav.RecordTimer.removeEntry(self.recording)
451                 self.recording = None
452                         
453         def startInstantRecording(self):
454                 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
455                         
456                 # try to get event info
457                 epg = None
458                 try:
459                         service = self.session.nav.getCurrentService()
460                         info = service.info()
461                         ev = info.getEvent(0)
462                         epg = ev
463                 except:
464                         pass
465                 
466                 # fix me, description. 
467                 self.recording = self.session.nav.recordWithTimer(time.time(), time.time() + 3600, serviceref, epg, "instant record")
468                 self.recording.dontSave = True
469                 
470                 #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
471                 
472         def isInstantRecordRunning(self):
473                 if self.recording != None:
474                         if self.recording.isRunning():
475                                 return True
476                 return False
477
478         def recordQuestionCallback(self, answer):
479                 if answer == False:
480                         return
481                 
482                 if self.isInstantRecordRunning():
483                         self.stopCurrentRecording()
484                 else:
485                         self.startInstantRecording()
486
487         def instantRecord(self):
488                 try:
489                         stat = os.stat("/hdd/movies")
490                 except:
491                         self.session.open(MessageBox, "No HDD found!")
492                         return
493         
494                 if self.isInstantRecordRunning():
495                         self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?"))
496                 else:
497                         self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?"))
498
499 from Screens.AudioSelection import AudioSelection
500
501 class InfoBarAudioSelection:
502         def __init__(self):
503                 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
504                         {
505                                 "audioSelection": (self.audioSelection, "Audio Options..."),
506                         })
507
508         def audioSelection(self):
509                 service = self.session.nav.getCurrentService()
510                 audio = service.audioTracks()
511                 n = audio.getNumberOfTracks()
512                 if n > 0:
513                         self.session.open(AudioSelection, audio)
514
515 from Screens.SubserviceSelection import SubserviceSelection
516
517 class InfoBarSubserviceSelection:
518         def __init__(self):
519                 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
520                         {
521                                 "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
522                         })
523
524         def subserviceSelection(self):
525                 service = self.session.nav.getCurrentService()
526                 subservices = service.subServices()
527                 n = subservices.getNumberOfSubservices()
528                 if n > 0:
529                         self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
530
531         def subserviceSelected(self, service):
532                 if not service is None:
533                         self.session.nav.playService(service)
534
535 class InfoBarAdditionalInfo:
536         def __init__(self):
537                 self["DolbyActive"] = PixmapConditional()
538                 # TODO: get the info from c++ somehow
539                 self["DolbyActive"].setConnect(lambda: False)
540                 
541                 self["CryptActive"] = PixmapConditional()
542                 # TODO: get the info from c++ somehow
543                 self["CryptActive"].setConnect(lambda: False)
544                 
545                 self["FormatActive"] = PixmapConditional()
546                 # TODO: get the info from c++ somehow
547                 self["FormatActive"].setConnect(lambda: False)
548                 
549                 self["ButtonRed"] = Pixmap()
550                 self["ButtonRedText"] = Label(_("Record"))
551                 self["ButtonGreen"] = Pixmap()
552                 self["ButtonGreenText"] = Label(_("Subservices"))
553 #               self["ButtonGreenText"].hide()
554 #               self["ButtonGreen"].hidePixmap()
555 #               self["ButtonYellow"] = Pixmap()
556 #               self["ButtonBlue"] = Pixmap()
557
558 class InfoBarNotifications:
559         def __init__(self):
560                 self.onExecBegin.append(self.checkNotifications)
561                 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
562         
563         def checkNotificationsIfExecing(self):
564                 if self.execing:
565                         self.checkNotifications()
566
567         def checkNotifications(self):
568                 if len(Notifications.notifications):
569                         n = Notifications.notifications[0]
570                         Notifications.notifications = Notifications.notifications[1:]
571                         print "open",n
572                         cb = n[0]
573                         if cb is not None:
574                                 self.session.openWithCallback(cb, *n[1:])
575                         else:
576                                 self.session.open(*n[1:])