allow extensions on blue button for movie player (usable on dm8000 rc)
[enigma2.git] / lib / python / Screens / InfoBar.py
1 from Tools.Profile import profile
2
3 # workaround for required config entry dependencies.
4 from Screens.MovieSelection import MovieSelection
5
6 from Screen import Screen
7
8 profile("LOAD:enigma")
9 from enigma import iPlayableService
10
11 profile("LOAD:InfoBarGenerics")
12 from Screens.InfoBarGenerics import InfoBarShowHide, \
13         InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarRdsDecoder, \
14         InfoBarEPG, InfoBarSeek, InfoBarInstantRecord, \
15         InfoBarAudioSelection, InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, \
16         InfoBarSubserviceSelection, InfoBarShowMovies, InfoBarTimeshift,  \
17         InfoBarServiceNotifications, InfoBarPVRState, InfoBarCueSheetSupport, InfoBarSimpleEventView, \
18         InfoBarSummarySupport, InfoBarMoviePlayerSummarySupport, InfoBarTimeshiftState, InfoBarTeletextPlugin, InfoBarExtensions, \
19         InfoBarSubtitleSupport, InfoBarPiP, InfoBarPlugins, InfoBarSleepTimer, InfoBarServiceErrorPopupSupport, InfoBarJobman
20
21 profile("LOAD:InitBar_Components")
22 from Components.ActionMap import HelpableActionMap
23 from Components.config import config
24 from Components.ServiceEventTracker import ServiceEventTracker, InfoBarBase
25
26 profile("LOAD:HelpableScreen")
27 from Screens.HelpMenu import HelpableScreen
28
29 class InfoBar(InfoBarBase, InfoBarShowHide,
30         InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder,
31         InfoBarInstantRecord, InfoBarAudioSelection, 
32         HelpableScreen, InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish,
33         InfoBarSubserviceSelection, InfoBarTimeshift, InfoBarSeek,
34         InfoBarSummarySupport, InfoBarTimeshiftState, InfoBarTeletextPlugin, InfoBarExtensions,
35         InfoBarPiP, InfoBarPlugins, InfoBarSubtitleSupport, InfoBarSleepTimer, InfoBarServiceErrorPopupSupport, InfoBarJobman,
36         Screen):
37         
38         ALLOW_SUSPEND = True
39         instance = None
40
41         def __init__(self, session):
42                 Screen.__init__(self, session)
43                 self["actions"] = HelpableActionMap(self, "InfobarActions",
44                         {
45                                 "showMovies": (self.showMovies, _("Play recorded movies...")),
46                                 "showRadio": (self.showRadio, _("Show the radio player...")),
47                                 "showTv": (self.showTv, _("Show the tv player...")),
48                         }, prio=2)
49                 
50                 for x in HelpableScreen, \
51                                 InfoBarBase, InfoBarShowHide, \
52                                 InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, \
53                                 InfoBarInstantRecord, InfoBarAudioSelection, \
54                                 InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, \
55                                 InfoBarTimeshift, InfoBarSeek, InfoBarSummarySupport, InfoBarTimeshiftState, \
56                                 InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, \
57                                 InfoBarSleepTimer, InfoBarPlugins, InfoBarServiceErrorPopupSupport:
58                         x.__init__(self)
59
60                 self.helpList.append((self["actions"], "InfobarActions", [("showMovies", _("view recordings..."))]))
61                 self.helpList.append((self["actions"], "InfobarActions", [("showRadio", _("hear radio..."))]))
62
63                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
64                         {
65                                 iPlayableService.evUpdatedEventInfo: self.__eventInfoChanged
66                         })
67
68                 self.current_begin_time=0
69                 assert InfoBar.instance is None, "class InfoBar is a singleton class and just one instance of this class is allowed!"
70                 InfoBar.instance = self
71
72         def __onClose(self):
73                 InfoBar.instance = None
74
75         def __eventInfoChanged(self):
76                 if self.execing:
77                         service = self.session.nav.getCurrentService()
78                         old_begin_time = self.current_begin_time
79                         info = service and service.info()
80                         ptr = info and info.getEvent(0)
81                         self.current_begin_time = ptr and ptr.getBeginTime() or 0
82                         if config.usage.show_infobar_on_event_change.value:
83                                 if old_begin_time and old_begin_time != self.current_begin_time:
84                                         self.doShow()
85
86         def __checkServiceStarted(self):
87                 self.__serviceStarted(True)
88                 self.onExecBegin.remove(self.__checkServiceStarted)
89
90         def serviceStarted(self):  #override from InfoBarShowHide
91                 new = self.servicelist.newServicePlayed()
92                 if self.execing:
93                         InfoBarShowHide.serviceStarted(self)
94                         self.current_begin_time=0
95                 elif not self.__checkServiceStarted in self.onShown and new:
96                         self.onShown.append(self.__checkServiceStarted)
97
98         def __checkServiceStarted(self):
99                 self.serviceStarted()
100                 self.onShown.remove(self.__checkServiceStarted)
101
102         def showTv(self):
103                 self.showTvChannelList(True)
104
105         def showRadio(self):
106                 if config.usage.e1like_radio_mode.value:
107                         self.showRadioChannelList(True)
108                 else:
109                         self.rds_display.hide() # in InfoBarRdsDecoder
110                         from Screens.ChannelSelection import ChannelSelectionRadio
111                         self.session.openWithCallback(self.ChannelSelectionRadioClosed, ChannelSelectionRadio, self)
112
113         def ChannelSelectionRadioClosed(self, *arg):
114                 self.rds_display.show()  # in InfoBarRdsDecoder
115
116         def showMovies(self):
117                 from Screens.MovieSelection import MovieSelection
118                 self.session.openWithCallback(self.movieSelected, MovieSelection)
119
120         def movieSelected(self, service):
121                 if service is not None:
122                         self.session.open(MoviePlayer, service)
123
124 class MoviePlayer(InfoBarBase, InfoBarShowHide, \
125                 InfoBarMenu, \
126                 InfoBarSeek, InfoBarShowMovies, InfoBarAudioSelection, HelpableScreen, InfoBarNotifications,
127                 InfoBarServiceNotifications, InfoBarPVRState, InfoBarCueSheetSupport, InfoBarSimpleEventView,
128                 InfoBarMoviePlayerSummarySupport, InfoBarSubtitleSupport, Screen, InfoBarTeletextPlugin,
129                 InfoBarServiceErrorPopupSupport, InfobarExtensions):
130
131         ENABLE_RESUME_SUPPORT = True
132         ALLOW_SUSPEND = True
133                 
134         def __init__(self, session, service):
135                 Screen.__init__(self, session)
136                 
137                 self["actions"] = HelpableActionMap(self, "MoviePlayerActions",
138                         {
139                                 "leavePlayer": (self.leavePlayer, _("leave movie player..."))
140                         })
141                 
142                 for x in HelpableScreen, InfoBarShowHide, InfoBarMenu, \
143                                 InfoBarBase, InfoBarSeek, InfoBarShowMovies, \
144                                 InfoBarAudioSelection, InfoBarNotifications, InfoBarSimpleEventView, \
145                                 InfoBarServiceNotifications, InfoBarPVRState, InfoBarCueSheetSupport, \
146                                 InfoBarMoviePlayerSummarySupport, InfoBarSubtitleSupport, \
147                                 InfoBarTeletextPlugin, InfoBarServiceErrorPopupSupport, InfobarExtensions:
148                         x.__init__(self)
149
150                 self.lastservice = self.session.nav.getCurrentlyPlayingServiceReference()
151                 self.session.nav.playService(service)
152                 self.returning = False
153                 self.onClose.append(self.__onClose)
154
155         def __onClose(self):
156                 self.session.nav.playService(self.lastservice)
157
158         def handleLeave(self, how):
159                 self.is_closing = True
160                 if how == "ask":
161                         list = []
162                         list.append((_("Yes"), "quit"))
163                         if config.usage.setup_level.index >= 2: # expert+
164                                 list.append((_("Yes, returning to movie list"), "movielist"))
165                         if config.usage.setup_level.index >= 2: # expert+
166                                 list.append((_("Yes, and delete this movie"), "quitanddelete"))
167                         list.append((_("No"), "continue"))
168                         if config.usage.setup_level.index >= 2: # expert+
169                                 list.append((_("No, but restart from begin"), "restart"))
170
171                         from Screens.ChoiceBox import ChoiceBox
172                         self.session.openWithCallback(self.leavePlayerConfirmed, ChoiceBox, title=_("Stop playing this movie?"), list = list)
173                 else:
174                         self.leavePlayerConfirmed([True, how])
175
176         def leavePlayer(self):
177                 self.handleLeave(config.usage.on_movie_stop.value)
178
179         def deleteConfirmed(self, answer):
180                 if answer:
181                         self.leavePlayerConfirmed((True, "quitanddeleteconfirmed"))
182
183         def leavePlayerConfirmed(self, answer):
184                 answer = answer and answer[1]
185
186                 if answer in ["quitanddelete", "quitanddeleteconfirmed"]:
187                         ref = self.session.nav.getCurrentlyPlayingServiceReference()
188                         from enigma import eServiceCenter
189                         serviceHandler = eServiceCenter.getInstance()
190                         info = serviceHandler.info(ref)
191                         name = info and info.getName(ref) or _("this recording")
192
193                 if answer == "quitanddelete":
194                         from Screens.MessageBox import MessageBox
195                         self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Do you really want to delete %s?") % name)
196                         return
197
198                 if answer == "quitanddeleteconfirmed":
199                         offline = serviceHandler.offlineOperations(ref)
200                         if offline.deleteFromDisk(0):
201                                 from Screens.MessageBox import MessageBox
202                                 self.session.openWithCallback(self.close, MessageBox, _("You cannot delete this!"), MessageBox.TYPE_ERROR)
203                                 return
204
205                 if answer in ["quit", "quitanddeleteconfirmed"]:
206                         config.movielist.last_videodir.cancel()
207                         self.close()
208                 elif answer == "movielist":
209                         ref = self.session.nav.getCurrentlyPlayingServiceReference()
210                         self.returning = True
211                         from Screens.MovieSelection import MovieSelection
212                         self.session.openWithCallback(self.movieSelected, MovieSelection, ref)
213                         self.session.nav.stopService()
214                 elif answer == "restart":
215                         self.doSeek(0)
216
217         def doEofInternal(self, playing):
218                 if not self.execing:
219                         return
220                 if not playing :
221                         return
222                 self.handleLeave(config.usage.on_movie_eof.value)
223
224         def showMovies(self):
225                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
226                 from Screens.MovieSelection import MovieSelection
227                 self.session.openWithCallback(self.movieSelected, MovieSelection, ref)
228
229         def movieSelected(self, service):
230                 if service is not None:
231                         self.is_closing = False
232                         self.session.nav.playService(service)
233                         self.returning = False
234                 elif self.returning:
235                         self.close()