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()