lib/python/Screens/InfoBarGenerics.py

   1 from ChannelSelection import ChannelSelection, BouquetSelector
   2
   3 from Components.ActionMap import ActionMap, HelpableActionMap
   4 from Components.ActionMap import NumberActionMap
   5 from Components.BlinkingPixmap import BlinkingPixmapConditional
   6 from Components.Harddisk import harddiskmanager
   7 from Components.Input import Input
   8 from Components.Label import *
   9 from Components.Pixmap import Pixmap, PixmapConditional
  10 from Components.PluginComponent import plugins
  11 from Components.ProgressBar import *
  12 from Components.ServiceEventTracker import ServiceEventTracker
  13 from Components.Sources.CurrentService import CurrentService
  14 from Components.Sources.EventInfo import EventInfo
  15 from Components.Sources.RadioText import RadioText
  16 from Components.Sources.FrontendStatus import FrontendStatus
  17 from Components.Sources.Boolean import Boolean
  18 from Components.Sources.Clock import Clock
  19 from Components.TimerList import TimerEntryComponent
  20 from Components.config import config, ConfigBoolean
  21
  22 from EpgSelection import EPGSelection
  23 from Plugins.Plugin import PluginDescriptor
  24
  25 from Screen import Screen
  26 from Screens.ChoiceBox import ChoiceBox
  27 from Screens.Dish import Dish
  28 from Screens.EventView import EventViewEPGSelect, EventViewSimple
  29 from Screens.InputBox import InputBox
  30 from Screens.MessageBox import MessageBox
  31 from Screens.MinuteInput import MinuteInput
  32 from Screens.TimerSelection import TimerSelection
  33 from Screens.PictureInPicture import PictureInPicture
  34 from Screens.SubtitleDisplay import SubtitleDisplay
  35 from ServiceReference import ServiceReference
  36
  37 from Tools import Notifications
  38 from Tools.Directories import *
  39
  40 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
  41 from enigma import *
  42
  43 import time
  44 import os
  45 import bisect
  46
  47 # hack alert!
  48 from Menu import MainMenu, mdom
  49
  50 class InfoBarDish:
  51         def __init__(self):
  52                 self.dishDialog = self.session.instantiateDialog(Dish)
  53                 self.onLayoutFinish.append(self.dishDialog.show)
  54
  55 class InfoBarShowHide:
  56         """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
  57         fancy animations. """
  58         STATE_HIDDEN = 0
  59         STATE_HIDING = 1
  60         STATE_SHOWING = 2
  61         STATE_SHOWN = 3
  62
  63         def __init__(self):
  64                 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
  65                         {
  66                                 "toggleShow": self.toggleShow,
  67                                 "hide": self.hide,
  68                         })
  69
  70                 self.__state = self.STATE_SHOWN
  71                 self.__locked = 0
  72
  73                 self.onExecBegin.append(self.show)
  74
  75                 self.hideTimer = eTimer()
  76                 self.hideTimer.timeout.get().append(self.doTimerHide)
  77                 self.hideTimer.start(5000, True)
  78
  79                 self.onShow.append(self.__onShow)
  80                 self.onHide.append(self.__onHide)
  81
  82         def __onShow(self):
  83                 self.__state = self.STATE_SHOWN
  84                 self.startHideTimer()
  85
  86         def startHideTimer(self):
  87                 if self.__state == self.STATE_SHOWN and not self.__locked:
  88                         idx = config.usage.infobar_timeout.index
  89                         if idx:
  90                                 self.hideTimer.start(idx*1000, True)
  91
  92         def __onHide(self):
  93                 self.__state = self.STATE_HIDDEN
  94
  95         def doShow(self):
  96                 self.show()
  97                 self.startHideTimer()
  98
  99         def doTimerHide(self):
 100                 self.hideTimer.stop()
 101                 if self.__state == self.STATE_SHOWN:
 102                         self.hide()
 103
 104         def toggleShow(self):
 105                 if self.__state == self.STATE_SHOWN:
 106                         self.hide()
 107                         self.hideTimer.stop()
 108                 elif self.__state == self.STATE_HIDDEN:
 109                         self.show()
 110
 111         def lockShow(self):
 112                 self.__locked = self.__locked + 1
 113                 if self.execing:
 114                         self.show()
 115                         self.hideTimer.stop()
 116
 117         def unlockShow(self):
 118                 self.__locked = self.__locked - 1
 119                 if self.execing:
 120                         self.startHideTimer()
 121
 122 #       def startShow(self):
 123 #               self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
 124 #               self.__state = self.STATE_SHOWN
 125 #
 126 #       def startHide(self):
 127 #               self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
 128 #               self.__state = self.STATE_HIDDEN
 129
 130 class NumberZap(Screen):
 131         def quit(self):
 132                 self.Timer.stop()
 133                 self.close(0)
 134
 135         def keyOK(self):
 136                 self.Timer.stop()
 137                 self.close(int(self["number"].getText()))
 138
 139         def keyNumberGlobal(self, number):
 140                 self.Timer.start(3000, True)            #reset timer
 141                 self.field = self.field + str(number)
 142                 self["number"].setText(self.field)
 143                 if len(self.field) >= 4:
 144                         self.keyOK()
 145
 146         def __init__(self, session, number):
 147                 Screen.__init__(self, session)
 148                 self.field = str(number)
 149
 150                 self["channel"] = Label(_("Channel:"))
 151
 152                 self["number"] = Label(self.field)
 153
 154                 self["actions"] = NumberActionMap( [ "SetupActions" ],
 155                         {
 156                                 "cancel": self.quit,
 157                                 "ok": self.keyOK,
 158                                 "1": self.keyNumberGlobal,
 159                                 "2": self.keyNumberGlobal,
 160                                 "3": self.keyNumberGlobal,
 161                                 "4": self.keyNumberGlobal,
 162                                 "5": self.keyNumberGlobal,
 163                                 "6": self.keyNumberGlobal,
 164                                 "7": self.keyNumberGlobal,
 165                                 "8": self.keyNumberGlobal,
 166                                 "9": self.keyNumberGlobal,
 167                                 "0": self.keyNumberGlobal
 168                         })
 169
 170                 self.Timer = eTimer()
 171                 self.Timer.timeout.get().append(self.keyOK)
 172                 self.Timer.start(3000, True)
 173
 174 class InfoBarNumberZap:
 175         """ Handles an initial number for NumberZapping """
 176         def __init__(self):
 177                 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
 178                         {
 179                                 "1": self.keyNumberGlobal,
 180                                 "2": self.keyNumberGlobal,
 181                                 "3": self.keyNumberGlobal,
 182                                 "4": self.keyNumberGlobal,
 183                                 "5": self.keyNumberGlobal,
 184                                 "6": self.keyNumberGlobal,
 185                                 "7": self.keyNumberGlobal,
 186                                 "8": self.keyNumberGlobal,
 187                                 "9": self.keyNumberGlobal,
 188                                 "0": self.keyNumberGlobal,
 189                         })
 190
 191         def keyNumberGlobal(self, number):
 192 #               print "You pressed number " + str(number)
 193                 if number == 0:
 194                         self.servicelist.recallPrevService()
 195                         if config.usage.show_infobar_on_zap.value:
 196                                 self.doShow()
 197                 else:
 198                         self.session.openWithCallback(self.numberEntered, NumberZap, number)
 199
 200         def numberEntered(self, retval):
 201 #               print self.servicelist
 202                 if retval > 0:
 203                         self.zapToNumber(retval)
 204
 205         def searchNumberHelper(self, serviceHandler, num, bouquet):
 206                 servicelist = serviceHandler.list(bouquet)
 207                 if not servicelist is None:
 208                         while num:
 209                                 serviceIterator = servicelist.getNext()
 210                                 if not serviceIterator.valid(): #check end of list
 211                                         break
 212                                 if serviceIterator.flags: #assume normal dvb service have no flags set
 213                                         continue
 214                                 num -= 1;
 215                         if not num: #found service with searched number ?
 216                                 return serviceIterator, 0
 217                 return None, num
 218
 219         def zapToNumber(self, number):
 220                 bouquet = self.servicelist.bouquet_root
 221                 service = None
 222                 serviceHandler = eServiceCenter.getInstance()
 223                 if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
 224                         service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
 225                 else:
 226                         bouquetlist = serviceHandler.list(bouquet)
 227                         if not bouquetlist is None:
 228                                 while number:
 229                                         bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext())
 230                                         if not bouquet.valid(): #check end of list
 231                                                 break
 232                                         if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
 233                                                 continue
 234                                         service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
 235                 if not service is None:
 236                         if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
 237                                 self.servicelist.clearPath()
 238                                 if self.servicelist.bouquet_root != bouquet:
 239                                         self.servicelist.enterPath(self.servicelist.bouquet_root)
 240                                 self.servicelist.enterPath(bouquet)
 241                         self.servicelist.setCurrentSelection(service) #select the service in servicelist
 242                         self.servicelist.zap()
 243
 244 config.misc.initialchannelselection = ConfigBoolean(default = True)
 245
 246 class InfoBarChannelSelection:
 247         """ ChannelSelection - handles the channelSelection dialog and the initial
 248         channelChange actions which open the channelSelection dialog """
 249         def __init__(self):
 250                 #instantiate forever
 251                 self.servicelist = self.session.instantiateDialog(ChannelSelection)
 252
 253                 if config.misc.initialchannelselection.value:
 254                         self.onShown.append(self.firstRun)
 255
 256                 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
 257                         {
 258                                 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
 259                                 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
 260                                 "zapUp": (self.zapUp, _("previous channel")),
 261                                 "zapDown": (self.zapDown, _("next channel")),
 262                                 "historyBack": (self.historyBack, _("previous channel in history")),
 263                                 "historyNext": (self.historyNext, _("next channel in history")),
 264                                 "openServiceList": (self.openServiceList, _("open servicelist")),
 265                         })
 266
 267         def showTvChannelList(self, zap=False):
 268                 self.servicelist.setModeTv()
 269                 if zap:
 270                         self.servicelist.zap()
 271                 self.session.execDialog(self.servicelist)
 272
 273         def showRadioChannelList(self, zap=False):
 274                 self.servicelist.setModeRadio()
 275                 if zap:
 276                         self.servicelist.zap()
 277                 self.session.execDialog(self.servicelist)
 278
 279         def firstRun(self):
 280                 self.onShown.remove(self.firstRun)
 281                 config.misc.initialchannelselection.value = False
 282                 config.misc.initialchannelselection.save()
 283                 self.switchChannelDown()
 284
 285         def historyBack(self):
 286                 self.servicelist.historyBack()
 287
 288         def historyNext(self):
 289                 self.servicelist.historyNext()
 290
 291         def switchChannelUp(self):
 292                 self.servicelist.moveUp()
 293                 self.session.execDialog(self.servicelist)
 294
 295         def switchChannelDown(self):
 296                 self.servicelist.moveDown()
 297                 self.session.execDialog(self.servicelist)
 298
 299         def openServiceList(self):
 300                 self.session.execDialog(self.servicelist)
 301
 302         def zapUp(self):
 303                 if self.servicelist.inBouquet():
 304                         prev = self.servicelist.getCurrentSelection()
 305                         if prev:
 306                                 prev = prev.toString()
 307                                 while True:
 308                                         if config.usage.quickzap_bouquet_change.value:
 309                                                 if self.servicelist.atBegin():
 310                                                         self.servicelist.prevBouquet()
 311                                         self.servicelist.moveUp()
 312                                         cur = self.servicelist.getCurrentSelection()
 313                                         if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
 314                                                 break
 315                 else:
 316                         self.servicelist.moveUp()
 317                 self.servicelist.zap()
 318                 if config.usage.show_infobar_on_zap.value:
 319                         self.doShow()
 320
 321         def zapDown(self):
 322                 if self.servicelist.inBouquet():
 323                         prev = self.servicelist.getCurrentSelection()
 324                         if prev:
 325                                 prev = prev.toString()
 326                                 while True:
 327                                         if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
 328                                                 self.servicelist.nextBouquet()
 329                                         else:
 330                                                 self.servicelist.moveDown()
 331                                         cur = self.servicelist.getCurrentSelection()
 332                                         if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
 333                                                 break
 334                 else:
 335                         self.servicelist.moveDown()
 336                 self.servicelist.zap()
 337                 if config.usage.show_infobar_on_zap.value:
 338                         self.doShow()
 339
 340 class InfoBarMenu:
 341         """ Handles a menu action, to open the (main) menu """
 342         def __init__(self):
 343                 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
 344                         {
 345                                 "mainMenu": (self.mainMenu, _("Enter main menu...")),
 346                         })
 347
 348         def mainMenu(self):
 349                 print "loading mainmenu XML..."
 350                 menu = mdom.childNodes[0]
 351                 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
 352                 self.session.open(MainMenu, menu, menu.childNodes)
 353
 354 class InfoBarSimpleEventView:
 355         """ Opens the Eventview for now/next """
 356         def __init__(self):
 357                 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
 358                         {
 359                                 "showEventInfo": (self.openEventView, _("show event details")),
 360                         })
 361
 362         def openEventView(self):
 363                 self.epglist = [ ]
 364                 service = self.session.nav.getCurrentService()
 365                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 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(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
 375
 376         def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 377                 if len(self.epglist) > 1:
 378                         tmp = self.epglist[0]
 379                         self.epglist[0]=self.epglist[1]
 380                         self.epglist[1]=tmp
 381                         setEvent(self.epglist[0])
 382
 383 class InfoBarEPG:
 384         """ EPG - Opens an EPG list when the showEPGList action fires """
 385         def __init__(self):
 386                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
 387                         {
 388                                 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
 389                         })
 390
 391                 self.is_now_next = False
 392                 self.dlg_stack = [ ]
 393                 self.bouquetSel = None
 394                 self.eventView = None
 395                 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
 396                         {
 397                                 "showEventInfo": (self.openEventView, _("show EPG...")),
 398                         })
 399
 400         def zapToService(self, service):
 401                 if not service is None:
 402                         if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
 403                                 self.servicelist.clearPath()
 404                                 if self.servicelist.bouquet_root != self.epg_bouquet:
 405                                         self.servicelist.enterPath(self.servicelist.bouquet_root)
 406                                 self.servicelist.enterPath(self.epg_bouquet)
 407                         self.servicelist.setCurrentSelection(service) #select the service in servicelist
 408                         self.servicelist.zap()
 409
 410         def getBouquetServices(self, bouquet):
 411                 services = [ ]
 412                 servicelist = eServiceCenter.getInstance().list(bouquet)
 413                 if not servicelist is None:
 414                         while True:
 415                                 service = servicelist.getNext()
 416                                 if not service.valid(): #check if end of list
 417                                         break
 418                                 if service.flags: #ignore non playable services
 419                                         continue
 420                                 services.append(ServiceReference(service))
 421                 return services
 422
 423         def openBouquetEPG(self, bouquet, withCallback=True):
 424                 services = self.getBouquetServices(bouquet)
 425                 if len(services):
 426                         self.epg_bouquet = bouquet
 427                         if withCallback:
 428                                 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
 429                         else:
 430                                 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
 431
 432         def changeBouquetCB(self, direction, epg):
 433                 if self.bouquetSel:
 434                         if direction > 0:
 435                                 self.bouquetSel.down()
 436                         else:
 437                                 self.bouquetSel.up()
 438                         bouquet = self.bouquetSel.getCurrent()
 439                         services = self.getBouquetServices(bouquet)
 440                         if len(services):
 441                                 self.epg_bouquet = bouquet
 442                                 epg.setServices(services)
 443
 444         def closed(self, ret=False):
 445                 closedScreen = self.dlg_stack.pop()
 446                 if self.bouquetSel and closedScreen == self.bouquetSel:
 447                         self.bouquetSel = None
 448                 elif self.eventView and closedScreen == self.eventView:
 449                         self.eventView = None
 450                 if ret:
 451                         dlgs=len(self.dlg_stack)
 452                         if dlgs > 0:
 453                                 self.dlg_stack[dlgs-1].close(dlgs > 1)
 454
 455         def openMultiServiceEPG(self, withCallback=True):
 456                 bouquets = self.servicelist.getBouquetList()
 457                 if bouquets is None:
 458                         cnt = 0
 459                 else:
 460                         cnt = len(bouquets)
 461                 if cnt > 1: # show bouquet list
 462                         if withCallback:
 463                                 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
 464                                 self.dlg_stack.append(self.bouquetSel)
 465                         else:
 466                                 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
 467                 elif cnt == 1:
 468                         self.openBouquetEPG(bouquets[0][1], withCallback)
 469
 470         def openSingleServiceEPG(self):
 471                 ref=self.session.nav.getCurrentlyPlayingServiceReference()
 472                 self.session.open(EPGSelection, ref)
 473
 474         def openSimilarList(self, eventid, refstr):
 475                 self.session.open(EPGSelection, refstr, None, eventid)
 476
 477         def getNowNext(self):
 478                 self.epglist = [ ]
 479                 service = self.session.nav.getCurrentService()
 480                 info = service and service.info()
 481                 ptr = info and info.getEvent(0)
 482                 if ptr:
 483                         self.epglist.append(ptr)
 484                 ptr = info and info.getEvent(1)
 485                 if ptr:
 486                         self.epglist.append(ptr)
 487
 488         def __evEventInfoChanged(self):
 489                 if self.is_now_next and len(self.dlg_stack) == 1:
 490                         self.getNowNext()
 491                         assert self.eventView
 492                         if len(self.epglist):
 493                                 self.eventView.setEvent(self.epglist[0])
 494
 495         def openEventView(self):
 496                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 497                 self.getNowNext()
 498                 if len(self.epglist) == 0:
 499                         self.is_now_next = False
 500                         epg = eEPGCache.getInstance()
 501                         ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
 502                         if ptr:
 503                                 self.epglist.append(ptr)
 504                                 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
 505                                 if ptr:
 506                                         self.epglist.append(ptr)
 507                 else:
 508                         self.is_now_next = True
 509                 if len(self.epglist) > 0:
 510                         self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
 511                         self.dlg_stack.append(self.eventView)
 512                 else:
 513                         print "no epg for the service avail.. so we show multiepg instead of eventinfo"
 514                         self.openMultiServiceEPG(False)
 515
 516         def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 517                 if len(self.epglist) > 1:
 518                         tmp = self.epglist[0]
 519                         self.epglist[0]=self.epglist[1]
 520                         self.epglist[1]=tmp
 521                         setEvent(self.epglist[0])
 522
 523 class InfoBarTuner:
 524         """provides a snr/agc/ber display"""
 525         def __init__(self):
 526                 self["FrontendStatus"] = FrontendStatus(service_source = self.session.nav.getCurrentService)
 527
 528 class InfoBarEvent:
 529         """provides a current/next event info display"""
 530         def __init__(self):
 531                 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
 532                 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)
 533
 534 class InfoBarRadioText:
 535         """provides radio (RDS) text info display"""
 536         def __init__(self):
 537                 self["RadioText"] = RadioText(self.session.nav)
 538
 539 class InfoBarServiceName:
 540         def __init__(self):
 541                 self["CurrentService"] = CurrentService(self.session.nav)
 542
 543 class InfoBarSeek:
 544         """handles actions like seeking, pause"""
 545
 546         # ispause, isff, issm
 547         SEEK_STATE_PLAY = (0, 0, 0, ">")
 548         SEEK_STATE_PAUSE = (1, 0, 0, "||")
 549         SEEK_STATE_FF_2X = (0, 2, 0, ">> 2x")
 550         SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x")
 551         SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x")
 552         SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x")
 553         SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x")
 554         SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x")
 555
 556         SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x")
 557         SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x")
 558         SEEK_STATE_BACK_64X = (0, -64, 0, "<< 64x")
 559         SEEK_STATE_BACK_128X = (0, -128, 0, "<< 128x")
 560
 561         SEEK_STATE_SM_HALF = (0, 0, 2, "/2")
 562         SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4")
 563         SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8")
 564
 565         def __init__(self):
 566                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
 567                         {
 568                                 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
 569                                 iPlayableService.evStart: self.__serviceStarted,
 570
 571                                 iPlayableService.evEOF: self.__evEOF,
 572                                 iPlayableService.evSOF: self.__evSOF,
 573                         })
 574
 575                 class InfoBarSeekActionMap(HelpableActionMap):
 576                         def __init__(self, screen, *args, **kwargs):
 577                                 HelpableActionMap.__init__(self, screen, *args, **kwargs)
 578                                 self.screen = screen
 579
 580                         def action(self, contexts, action):
 581                                 if action[:5] == "seek:":
 582                                         time = int(action[5:])
 583                                         self.screen.seekRelative(time * 90000)
 584                                         return 1
 585                                 else:
 586                                         return HelpableActionMap.action(self, contexts, action)
 587
 588                 self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions",
 589                         {
 590                                 "pauseService": (self.pauseService, _("pause")),
 591                                 "unPauseService": (self.unPauseService, _("continue")),
 592
 593                                 "seekFwd": (self.seekFwd, _("skip forward")),
 594                                 "seekFwdDown": self.seekFwdDown,
 595                                 "seekFwdUp": self.seekFwdUp,
 596                                 "seekBack": (self.seekBack, _("skip backward")),
 597                                 "seekBackDown": self.seekBackDown,
 598                                 "seekBackUp": self.seekBackUp,
 599                         }, prio=-1)
 600                         # give them a little more priority to win over color buttons
 601
 602                 self.seekstate = self.SEEK_STATE_PLAY
 603                 self.onClose.append(self.delTimer)
 604
 605                 self.fwdtimer = False
 606                 self.fwdKeyTimer = eTimer()
 607                 self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
 608
 609                 self.rwdtimer = False
 610                 self.rwdKeyTimer = eTimer()
 611                 self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
 612
 613                 self.onPlayStateChanged = [ ]
 614
 615                 self.lockedBecauseOfSkipping = False
 616
 617         def up(self):
 618                 pass
 619
 620         def down(self):
 621                 pass
 622
 623         def delTimer(self):
 624                 del self.fwdKeyTimer
 625                 del self.rwdKeyTimer
 626
 627         def getSeek(self):
 628                 service = self.session.nav.getCurrentService()
 629                 if service is None:
 630                         return None
 631
 632                 seek = service.seek()
 633
 634                 if seek is None or not seek.isCurrentlySeekable():
 635                         return None
 636
 637                 return seek
 638
 639         def isSeekable(self):
 640                 if self.getSeek() is None:
 641                         return False
 642                 return True
 643
 644         def __seekableStatusChanged(self):
 645                 print "seekable status changed!"
 646                 if not self.isSeekable():
 647                         self["SeekActions"].setEnabled(False)
 648                         print "not seekable, return to play"
 649                         self.setSeekState(self.SEEK_STATE_PLAY)
 650                 else:
 651                         self["SeekActions"].setEnabled(True)
 652                         print "seekable"
 653
 654         def __serviceStarted(self):
 655                 self.seekstate = self.SEEK_STATE_PLAY
 656
 657         def setSeekState(self, state):
 658                 service = self.session.nav.getCurrentService()
 659
 660                 if service is None:
 661                         return False
 662
 663                 if not self.isSeekable():
 664                         if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
 665                                 state = self.SEEK_STATE_PLAY
 666
 667                 pauseable = service.pause()
 668
 669                 if pauseable is None:
 670                         print "not pauseable."
 671                         state = self.SEEK_STATE_PLAY
 672
 673                 oldstate = self.seekstate
 674                 self.seekstate = state
 675
 676                 for i in range(3):
 677                         if oldstate[i] != self.seekstate[i]:
 678                                 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
 679
 680                 for c in self.onPlayStateChanged:
 681                         c(self.seekstate)
 682
 683                 self.checkSkipShowHideLock()
 684
 685                 return True
 686
 687         def pauseService(self):
 688                 if self.seekstate == self.SEEK_STATE_PAUSE:
 689                         print "pause, but in fact unpause"
 690                         self.unPauseService()
 691                 else:
 692                         if self.seekstate == self.SEEK_STATE_PLAY:
 693                                 print "yes, playing."
 694                         else:
 695                                 print "no", self.seekstate
 696                         print "pause"
 697                         self.setSeekState(self.SEEK_STATE_PAUSE);
 698
 699         def unPauseService(self):
 700                 print "unpause"
 701                 if self.seekstate == self.SEEK_STATE_PLAY:
 702                         return 0
 703                 self.setSeekState(self.SEEK_STATE_PLAY)
 704
 705         def doSeek(self, seektime):
 706                 print "doseek", seektime
 707                 service = self.session.nav.getCurrentService()
 708                 if service is None:
 709                         return
 710
 711                 seekable = self.getSeek()
 712                 if seekable is None:
 713                         return
 714
 715                 seekable.seekTo(90 * seektime)
 716
 717         def seekFwdDown(self):
 718                 print "start fwd timer"
 719                 self.fwdtimer = True
 720                 self.fwdKeyTimer.start(1000)
 721
 722         def seekBackDown(self):
 723                 print "start rewind timer"
 724                 self.rwdtimer = True
 725                 self.rwdKeyTimer.start(1000)
 726
 727         def seekFwdUp(self):
 728                 print "seekFwdUp"
 729                 if self.fwdtimer:
 730                         self.fwdKeyTimer.stop()
 731                         self.fwdtimer = False
 732                         self.seekFwd()
 733
 734         def seekFwd(self):
 735                 lookup = {
 736                                 self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
 737                                 self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
 738                                 self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
 739                                 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
 740                                 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
 741                                 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
 742                                 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
 743                                 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
 744                                 self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY,
 745                                 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
 746                                 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
 747                                 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
 748                                 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
 749                                 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
 750                                 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
 751                         }
 752                 self.setSeekState(lookup[self.seekstate])
 753
 754         def seekBackUp(self):
 755                 print "seekBackUp"
 756                 if self.rwdtimer:
 757                         self.rwdKeyTimer.stop()
 758                         self.rwdtimer = False
 759                         self.seekBack()
 760
 761         def seekBack(self):
 762                 lookup = {
 763                                 self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
 764                                 self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
 765                                 self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
 766                                 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
 767                                 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
 768                                 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
 769                                 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
 770                                 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
 771                                 self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
 772                                 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
 773                                 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
 774                                 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
 775                                 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
 776                                 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
 777                                 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
 778                         }
 779                 self.setSeekState(lookup[self.seekstate])
 780
 781                 if self.seekstate == self.SEEK_STATE_PAUSE:
 782                         seekable = self.getSeek()
 783                         if seekable is not None:
 784                                 seekable.seekRelative(-1, 3)
 785
 786         def fwdTimerFire(self):
 787                 print "Display seek fwd"
 788                 self.fwdKeyTimer.stop()
 789                 self.fwdtimer = False
 790                 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
 791
 792         def fwdSeekTo(self, minutes):
 793                 print "Seek", minutes, "minutes forward"
 794                 if minutes != 0:
 795                         seekable = self.getSeek()
 796                         if seekable is not None:
 797                                 seekable.seekRelative(1, minutes * 60 * 90000)
 798
 799         def rwdTimerFire(self):
 800                 print "rwdTimerFire"
 801                 self.rwdKeyTimer.stop()
 802                 self.rwdtimer = False
 803                 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
 804
 805         def rwdSeekTo(self, minutes):
 806                 print "rwdSeekTo"
 807                 self.fwdSeekTo(0 - minutes)
 808
 809         def checkSkipShowHideLock(self):
 810                 wantlock = self.seekstate != self.SEEK_STATE_PLAY
 811
 812                 if config.usage.show_infobar_on_zap.value:
 813                         if self.lockedBecauseOfSkipping and not wantlock:
 814                                 self.unlockShow()
 815                                 self.lockedBecauseOfSkipping = False
 816
 817                         if wantlock and not self.lockedBecauseOfSkipping:
 818                                 self.lockShow()
 819                                 self.lockedBecauseOfSkipping = True
 820
 821         def __evEOF(self):
 822                 if self.seekstate != self.SEEK_STATE_PLAY:
 823                         self.setSeekState(self.SEEK_STATE_PAUSE)
 824                         # HACK
 825                         #self.getSeek().seekRelative(1, -90000)
 826                         self.setSeekState(self.SEEK_STATE_PLAY)
 827                 else:
 828                         self.setSeekState(self.SEEK_STATE_PAUSE)
 829
 830         def __evSOF(self):
 831                 self.setSeekState(self.SEEK_STATE_PLAY)
 832                 self.doSeek(0)
 833
 834         def seekRelative(self, diff):
 835                 seekable = self.getSeek()
 836                 if seekable is not None:
 837                         seekable.seekRelative(1, diff)
 838
 839         def seekAbsolute(self, abs):
 840                 seekable = self.getSeek()
 841                 if seekable is not None:
 842                         seekable.seekTo(abs)
 843
 844 from Screens.PVRState import PVRState, TimeshiftState
 845
 846 class InfoBarPVRState:
 847         def __init__(self, screen=PVRState):
 848                 self.onPlayStateChanged.append(self.__playStateChanged)
 849                 self.pvrStateDialog = self.session.instantiateDialog(screen)
 850                 self.onShow.append(self.__mayShow)
 851                 self.onHide.append(self.pvrStateDialog.hide)
 852
 853         def __mayShow(self):
 854                 if self.seekstate != self.SEEK_STATE_PLAY and self.execing:
 855                         self.pvrStateDialog.show()
 856
 857         def __playStateChanged(self, state):
 858                 playstateString = state[3]
 859                 self.pvrStateDialog["state"].setText(playstateString)
 860                 self.__mayShow()
 861
 862 class InfoBarTimeshiftState(InfoBarPVRState):
 863         def __init__(self):
 864                 InfoBarPVRState.__init__(self, screen=TimeshiftState)
 865
 866 class InfoBarShowMovies:
 867
 868         # i don't really like this class.
 869         # it calls a not further specified "movie list" on up/down/movieList,
 870         # so this is not more than an action map
 871         def __init__(self):
 872                 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
 873                         {
 874                                 "movieList": (self.showMovies, "movie list"),
 875                                 "up": (self.showMovies, "movie list"),
 876                                 "down": (self.showMovies, "movie list")
 877                         })
 878
 879 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
 880
 881 # Hrmf.
 882 #
 883 # Timeshift works the following way:
 884 #                                         demux0   demux1                    "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
 885 # - normal playback                       TUNER    unused      PLAY               enable                disable              disable
 886 # - user presses "yellow" button.         TUNER    record      PAUSE              enable                disable              enable
 887 # - user presess pause again              FILE     record      PLAY               enable                disable              enable
 888 # - user fast forwards                    FILE     record      FF                 enable                disable              enable
 889 # - end of timeshift buffer reached       TUNER    record      PLAY               enable                enable               disable
 890 # - user backwards                        FILE     record      BACK  # !!         enable                disable              enable
 891 #
 892
 893 # in other words:
 894 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
 895 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
 896 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
 897 # - the user can now PVR around
 898 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
 899 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
 900 # after!
 901 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
 902 # - if the user rewinds, or press pause, timeshift will be activated again
 903
 904 # note that a timeshift can be enabled ("recording") and
 905 # activated (currently time-shifting).
 906
 907 class InfoBarTimeshift:
 908         def __init__(self):
 909                 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
 910                         {
 911                                 "timeshiftStart": (self.startTimeshift, _("start timeshift")),  # the "yellow key"
 912                                 "timeshiftStop": (self.stopTimeshift, _("stop timeshift"))      # currently undefined :), probably 'TV'
 913                         }, prio=1)
 914                 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
 915                         {
 916                                 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key"
 917                                 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause  # something like "backward key"
 918                         }, prio=-1) # priority over record
 919
 920                 self.timeshift_enabled = 0
 921                 self.timeshift_state = 0
 922                 self.ts_pause_timer = eTimer()
 923                 self.ts_pause_timer.timeout.get().append(self.pauseService)
 924
 925                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
 926                         {
 927                                 iPlayableService.evStart: self.__serviceStarted,
 928                                 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
 929                         })
 930
 931         def getTimeshift(self):
 932                 service = self.session.nav.getCurrentService()
 933                 return service and service.timeshift()
 934
 935         def startTimeshift(self):
 936                 print "enable timeshift"
 937                 ts = self.getTimeshift()
 938                 if ts is None:
 939                         self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
 940                         print "no ts interface"
 941                         return 0;
 942
 943                 if self.timeshift_enabled:
 944                         print "hu, timeshift already enabled?"
 945                 else:
 946                         if not ts.startTimeshift():
 947                                 import time
 948                                 self.timeshift_enabled = 1
 949
 950                                 # we remove the "relative time" for now.
 951                                 #self.pvrStateDialog["timeshift"].setRelative(time.time())
 952
 953                                 # PAUSE.
 954                                 self.setSeekState(self.SEEK_STATE_PAUSE)
 955
 956                                 # enable the "TimeshiftEnableActions", which will override
 957                                 # the startTimeshift actions
 958                                 self.__seekableStatusChanged()
 959                         else:
 960                                 print "timeshift failed"
 961
 962         def stopTimeshift(self):
 963                 if not self.timeshift_enabled:
 964                         return 0
 965                 print "disable timeshift"
 966                 ts = self.getTimeshift()
 967                 if ts is None:
 968                         return 0
 969                 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
 970
 971         def stopTimeshiftConfirmed(self, confirmed):
 972                 if not confirmed:
 973                         return
 974
 975                 ts = self.getTimeshift()
 976                 if ts is None:
 977                         return
 978
 979                 ts.stopTimeshift()
 980                 self.timeshift_enabled = 0
 981
 982                 # disable actions
 983                 self.__seekableStatusChanged()
 984
 985         # activates timeshift, and seeks to (almost) the end
 986         def activateTimeshiftEnd(self):
 987                 ts = self.getTimeshift()
 988
 989                 if ts is None:
 990                         return
 991
 992                 if ts.isTimeshiftActive():
 993                         print "!! activate timeshift called - but shouldn't this be a normal pause?"
 994                         self.pauseService()
 995                 else:
 996                         self.setSeekState(self.SEEK_STATE_PLAY)
 997                         ts.activateTimeshift()
 998                         self.seekRelative(0)
 999
1000         # same as activateTimeshiftEnd, but pauses afterwards.
1001         def activateTimeshiftEndAndPause(self):
1002                 state = self.seekstate
1003                 self.activateTimeshiftEnd()
1004
1005                 # well, this is "andPause", but it could be pressed from pause,
1006                 # when pausing on the (fake-)"live" picture, so an un-pause
1007                 # is perfectly ok.
1008
1009                 print "now, pauseService"
1010                 if state == self.SEEK_STATE_PLAY:
1011                         print "is PLAYING, start pause timer"
1012                         self.ts_pause_timer.start(200, 1)
1013                 else:
1014                         print "unpause"
1015                         self.unPauseService()
1016
1017         def __seekableStatusChanged(self):
1018                 enabled = False
1019
1020                 print "self.isSeekable", self.isSeekable()
1021                 print "self.timeshift_enabled", self.timeshift_enabled
1022
1023                 # when this service is not seekable, but timeshift
1024                 # is enabled, this means we can activate
1025                 # the timeshift
1026                 if not self.isSeekable() and self.timeshift_enabled:
1027                         enabled = True
1028
1029                 print "timeshift activate:", enabled
1030                 self["TimeshiftActivateActions"].setEnabled(enabled)
1031
1032         def __serviceStarted(self):
1033                 self.timeshift_enabled = False
1034                 self.__seekableStatusChanged()
1035
1036 from Screens.PiPSetup import PiPSetup
1037
1038 class InfoBarExtensions:
1039         EXTENSION_SINGLE = 0
1040         EXTENSION_LIST = 1
1041
1042         def __init__(self):
1043                 self.list = []
1044
1045                 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1046                         {
1047                                 "extensions": (self.showExtensionSelection, _("view extensions...")),
1048                         })
1049
1050         def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1051                 self.list.append((type, extension, key))
1052
1053         def updateExtension(self, extension, key = None):
1054                 self.extensionsList.append(extension)
1055                 if key is not None:
1056                         if self.extensionKeys.has_key(key):
1057                                 key = None
1058
1059                 if key is None:
1060                         for x in self.availableKeys:
1061                                 if not self.extensionKeys.has_key(x):
1062                                         key = x
1063                                         break
1064
1065                 if key is not None:
1066                         self.extensionKeys[key] = len(self.extensionsList) - 1
1067
1068         def updateExtensions(self):
1069                 self.extensionsList = []
1070                 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1071                 self.extensionKeys = {}
1072                 for x in self.list:
1073                         if x[0] == self.EXTENSION_SINGLE:
1074                                 self.updateExtension(x[1], x[2])
1075                         else:
1076                                 for y in x[1]():
1077                                         self.updateExtension(y[0], y[1])
1078
1079
1080         def showExtensionSelection(self):
1081                 self.updateExtensions()
1082                 extensionsList = self.extensionsList[:]
1083                 keys = []
1084                 list = []
1085                 for x in self.availableKeys:
1086                         if self.extensionKeys.has_key(x):
1087                                 entry = self.extensionKeys[x]
1088                                 extension = self.extensionsList[entry]
1089                                 if extension[2]():
1090                                         name = str(extension[0]())
1091                                         list.append((extension[0](), extension))
1092                                         keys.append(x)
1093                                         extensionsList.remove(extension)
1094                                 else:
1095                                         extensionsList.remove(extension)
1096                 for x in extensionsList:
1097                         list.append((x[0](), x))
1098                 keys += [""] * len(extensionsList)
1099                 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
1100
1101         def extensionCallback(self, answer):
1102                 if answer is not None:
1103                         answer[1][1]()
1104
1105 from Tools.BoundFunction import boundFunction
1106
1107 # depends on InfoBarExtensions
1108 from Components.PluginComponent import plugins
1109
1110 class InfoBarPlugins:
1111         def __init__(self):
1112                 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1113
1114
1115         def getPluginName(self, name):
1116                 return name
1117
1118         def getPluginList(self):
1119                 list = []
1120                 for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
1121                         list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
1122                 return list
1123
1124         def runPlugin(self, plugin):
1125                 plugin(session = self.session)
1126
1127 # depends on InfoBarExtensions and InfoBarSubtitleSupport
1128 class InfoBarSubtitles:
1129         def __init__(self):
1130                 self.addExtension((self.getDisableSubtitleName, self.disableSubtitles, self.subtitlesEnabled), "4")
1131                 self.addExtension(extension = self.getSubtitleList, type = InfoBarExtensions.EXTENSION_LIST)
1132
1133         def getDisableSubtitleName(self):
1134                 return _("Disable subtitles")
1135
1136         def getSubtitleList(self):
1137                 list = []
1138                 s = self.getCurrentServiceSubtitle()
1139                 l = s and s.getSubtitleList() or [ ]
1140
1141                 for x in l:
1142                         list.append(((boundFunction(self.getSubtitleEntryName, x[0]), boundFunction(self.enableSubtitle, x[1]), lambda: True), None))
1143                 return list
1144
1145         def getSubtitleEntryName(self, name):
1146                 return "Enable Subtitles: " + name
1147
1148         def enableSubtitle(self, subtitles):
1149                 print "enable subtitles", subtitles
1150                 self.selected_subtitle = subtitles
1151                 self.subtitles_enabled = True
1152
1153         def subtitlesEnabled(self):
1154                 return self.subtitles_enabled
1155
1156         def disableSubtitles(self):
1157                 self.subtitles_enabled = False
1158
1159 # depends on InfoBarExtensions
1160 class InfoBarPiP:
1161         def __init__(self):
1162                 self.session.pipshown = False
1163
1164                 self.addExtension((self.getShowHideName, self.showPiP, self.available), "red")
1165                 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1166                 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1167
1168         def available(self):
1169                 return True
1170
1171         def pipShown(self):
1172                 return self.session.pipshown
1173
1174         def getShowHideName(self):
1175                 if self.session.pipshown:
1176                         return _("Disable Picture in Picture")
1177                 else:
1178                         return _("Activate Picture in Picture")
1179
1180         def getSwapName(self):
1181                 return _("Swap Services")
1182
1183         def getMoveName(self):
1184                 return _("Move Picture in Picture")
1185
1186         def showPiP(self):
1187                 if self.session.pipshown:
1188                         del self.session.pip
1189                         self.session.pipshown = False
1190                 else:
1191                         self.session.pip = self.session.instantiateDialog(PictureInPicture)
1192                         newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1193                         if self.session.pip.playService(newservice):
1194                                 self.session.pipshown = True
1195                                 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1196                         else:
1197                                 self.session.pipshown = False
1198                                 del self.session.pip
1199                         self.session.nav.playService(newservice)
1200
1201         def swapPiP(self):
1202                 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1203                 if self.session.pip.servicePath:
1204                         servicepath = self.servicelist.getCurrentServicePath()
1205                         ref=servicepath[len(servicepath)-1]
1206                         pipref=self.session.pip.getCurrentService()
1207                         self.session.pip.playService(swapservice)
1208                         self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1209                         if pipref.toString() != ref.toString(): # is a subservice ?
1210                                 self.session.nav.stopService() # stop portal
1211                                 self.session.nav.playService(pipref) # start subservice
1212                         self.session.pip.servicePath=servicepath
1213
1214         def movePiP(self):
1215                 self.session.open(PiPSetup, pip = self.session.pip)
1216
1217 from RecordTimer import parseEvent
1218
1219 class InfoBarInstantRecord:
1220         """Instant Record - handles the instantRecord action in order to
1221         start/stop instant records"""
1222         def __init__(self):
1223                 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1224                         {
1225                                 "instantRecord": (self.instantRecord, _("Instant Record...")),
1226                         })
1227                 self.recording = []
1228                 self["BlinkingPoint"] = BlinkingPixmapConditional()
1229                 self["BlinkingPoint"].hide()
1230                 self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
1231
1232         def stopCurrentRecording(self, entry = -1):
1233                 if entry is not None and entry != -1:
1234                         self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1235                         self.recording.remove(self.recording[entry])
1236
1237         def startInstantRecording(self, limitEvent = False):
1238                 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1239
1240                 # try to get event info
1241                 event = None
1242                 try:
1243                         service = self.session.nav.getCurrentService()
1244                         epg = eEPGCache.getInstance()
1245                         event = epg.lookupEventTime(serviceref, -1, 0)
1246                         if event is None:
1247                                 info = service.info()
1248                                 ev = info.getEvent(0)
1249                                 event = ev
1250                 except:
1251                         pass
1252
1253                 begin = time.time()
1254                 end = time.time() + 3600 * 10
1255                 name = "instant record"
1256                 description = ""
1257                 eventid = None
1258
1259                 if event is not None:
1260                         curEvent = parseEvent(event)
1261                         name = curEvent[2]
1262                         description = curEvent[3]
1263                         eventid = curEvent[4]
1264                         if limitEvent:
1265                                 end = curEvent[1]
1266                 else:
1267                         if limitEvent:
1268                                 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1269
1270                 data = (begin, end, name, description, eventid)
1271
1272                 recording = self.session.nav.recordWithTimer(serviceref, *data)
1273                 recording.dontSave = True
1274                 self.recording.append(recording)
1275
1276                 #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
1277
1278         def isInstantRecordRunning(self):
1279                 print "self.recording:", self.recording
1280                 if len(self.recording) > 0:
1281                         for x in self.recording:
1282                                 if x.isRunning():
1283                                         return True
1284                 return False
1285
1286         def recordQuestionCallback(self, answer):
1287                 print "pre:\n", self.recording
1288
1289                 if answer is None or answer[1] == "no":
1290                         return
1291                 list = []
1292                 recording = self.recording[:]
1293                 for x in recording:
1294                         if not x in self.session.nav.RecordTimer.timer_list:
1295                                 self.recording.remove(x)
1296                         elif x.dontSave and x.isRunning():
1297                                 list.append(TimerEntryComponent(x, False))
1298
1299                 if answer[1] == "changeduration":
1300                         if len(self.recording) == 1:
1301                                 self.changeDuration(0)
1302                         else:
1303                                 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1304                 elif answer[1] == "stop":
1305                         if len(self.recording) == 1:
1306                                 self.stopCurrentRecording(0)
1307                         else:
1308                                 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1309                 if answer[1] == "indefinitely" or answer[1] == "manualduration" or answer[1] == "event":
1310                         limitEvent = False
1311                         if answer[1] == "event":
1312                                 limitEvent = True
1313                         if answer[1] == "manualduration":
1314                                 self.selectedEntry = len(self.recording)
1315                                 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1316                         self.startInstantRecording(limitEvent = limitEvent)
1317
1318                 print "after:\n", self.recording
1319
1320         def changeDuration(self, entry):
1321                 if entry is not None:
1322                         self.selectedEntry = entry
1323                         self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1324
1325         def inputCallback(self, value):
1326                 if value is not None:
1327                         print "stopping recording after", int(value), "minutes."
1328                         self.recording[self.selectedEntry].end = time.time() + 60 * int(value)
1329                         self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1330
1331         def instantRecord(self):
1332                 try:
1333                         stat = os.stat(resolveFilename(SCOPE_HDD))
1334                 except:
1335                         self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1336                         return
1337
1338                 if self.isInstantRecordRunning():
1339                         self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("A recording is currently running.\nWhat do you want to do?"), list=[(_("stop recording"), "stop"), (_("change recording (duration)"), "changeduration"), (_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"), (_("do nothing"), "no")])
1340                 else:
1341                         self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")])
1342
1343 from Tools.ISO639 import LanguageCodes
1344
1345 class InfoBarAudioSelection:
1346         def __init__(self):
1347                 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1348                         {
1349                                 "audioSelection": (self.audioSelection, _("Audio Options...")),
1350                         })
1351
1352         def audioSelection(self):
1353                 service = self.session.nav.getCurrentService()
1354                 audio = service and service.audioTracks()
1355                 self.audioTracks = audio
1356                 n = audio and audio.getNumberOfTracks() or 0
1357                 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1358                 tlist = []
1359                 print "tlist:", tlist
1360                 if n > 0:
1361                         self.audioChannel = service.audioChannel()
1362
1363                         for x in range(n):
1364                                 i = audio.getTrackInfo(x)
1365                                 language = i.getLanguage()
1366                                 description = i.getDescription()
1367
1368                                 if len(language) == 3:
1369                                         if language in LanguageCodes:
1370                                                 language = LanguageCodes[language][0]
1371
1372                                 if len(description):
1373                                         description += " (" + language + ")"
1374                                 else:
1375                                         description = language
1376
1377                                 tlist.append((description, x))
1378
1379                         selectedAudio = tlist[0][1]
1380                         tlist.sort(lambda x,y : cmp(x[0], y[0]))
1381
1382                         selection = 2
1383                         for x in tlist:
1384                                 if x[1] != selectedAudio:
1385                                         selection += 1
1386                                 else:
1387                                         break
1388
1389                         tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1390                         self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
1391                 else:
1392                         del self.audioTracks
1393
1394         def audioSelected(self, audio):
1395                 if audio is not None:
1396                         if isinstance(audio[1], str):
1397                                 if audio[1] == "mode":
1398                                         keys = ["red", "green", "yellow"]
1399                                         selection = self.audioChannel.getCurrentChannel()
1400                                         tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
1401                                         self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
1402                         else:
1403                                 del self.audioChannel
1404                                 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1405                                         self.audioTracks.selectTrack(audio[1])
1406                 else:
1407                         del self.audioChannel
1408                 del self.audioTracks
1409
1410         def modeSelected(self, mode):
1411                 if mode is not None:
1412                         self.audioChannel.selectChannel(mode[1])
1413                 del self.audioChannel
1414
1415 class InfoBarSubserviceSelection:
1416         def __init__(self):
1417                 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1418                         {
1419                                 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1420                         })
1421
1422                 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1423                         {
1424                                 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1425                                 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1426                         }, -1)
1427                 self["SubserviceQuickzapAction"].setEnabled(False)
1428
1429                 self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
1430
1431         def checkSubservicesAvail(self, ev):
1432                 if ev == iPlayableService.evUpdatedEventInfo:
1433                         service = self.session.nav.getCurrentService()
1434                         subservices = service and service.subServices()
1435                         if not subservices or subservices.getNumberOfSubservices() == 0:
1436                                 self["SubserviceQuickzapAction"].setEnabled(False)
1437
1438         def nextSubservice(self):
1439                 self.changeSubservice(+1)
1440
1441         def prevSubservice(self):
1442                 self.changeSubservice(-1)
1443
1444         def changeSubservice(self, direction):
1445                 service = self.session.nav.getCurrentService()
1446                 subservices = service and service.subServices()
1447                 n = subservices and subservices.getNumberOfSubservices()
1448                 if n and n > 0:
1449                         selection = -1
1450                         ref = self.session.nav.getCurrentlyPlayingServiceReference()
1451                         for x in range(n):
1452                                 if subservices.getSubservice(x).toString() == ref.toString():
1453                                         selection = x
1454                         if selection != -1:
1455                                 selection += direction
1456                                 if selection >= n:
1457                                         selection=0
1458                                 elif selection < 0:
1459                                         selection=n-1
1460                                 newservice = subservices.getSubservice(selection)
1461                                 if newservice.valid():
1462                                         del subservices
1463                                         del service
1464                                         if config.usage.show_infobar_on_zap.value:
1465                                                 self.doShow()
1466                                         self.session.nav.playService(newservice)
1467
1468         def subserviceSelection(self):
1469                 service = self.session.nav.getCurrentService()
1470                 subservices = service and service.subServices()
1471
1472                 n = subservices and subservices.getNumberOfSubservices()
1473                 selection = 0
1474                 if n and n > 0:
1475                         ref = self.session.nav.getCurrentlyPlayingServiceReference()
1476                         tlist = []
1477                         for x in range(n):
1478                                 i = subservices.getSubservice(x)
1479                                 if i.toString() == ref.toString():
1480                                         selection = x
1481                                 tlist.append((i.getName(), i))
1482
1483                         tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1484
1485                         keys = ["red", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1486
1487                         self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection + 2, keys = keys)
1488
1489         def subserviceSelected(self, service):
1490                 if not service is None:
1491                         if isinstance(service[1], str):
1492                                 if service[1] == "quickzap":
1493                                         from Screens.SubservicesQuickzap import SubservicesQuickzap
1494                                         self.session.open(SubservicesQuickzap, service[2])
1495                         else:
1496                                 self["SubserviceQuickzapAction"].setEnabled(True)
1497                                 if config.usage.show_infobar_on_zap.value:
1498                                         self.doShow()
1499                                 self.session.nav.playService(service[1])
1500
1501 class InfoBarAdditionalInfo:
1502         def __init__(self):
1503                 self["NimA"] = Pixmap()
1504                 self["NimB"] = Pixmap()
1505                 self["NimA_Active"] = Pixmap()
1506                 self["NimB_Active"] = Pixmap()
1507
1508                 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
1509                 self["TimeshiftPossible"] = self["RecordingPossible"]
1510                 self["ExtensionsAvailable"] = Boolean(fixed=1)
1511
1512                 self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
1513                 res_mgr = eDVBResourceManagerPtr()
1514                 if eDVBResourceManager.getInstance(res_mgr) == 0:
1515                         res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged)
1516
1517         def tunerUseMaskChanged(self, mask):
1518                 if mask&1:
1519                         self["NimA_Active"].show()
1520                 else:
1521                         self["NimA_Active"].hide()
1522                 if mask&2:
1523                         self["NimB_Active"].show()
1524                 else:
1525                         self["NimB_Active"].hide()
1526
1527         def checkTunerState(self, service):
1528                 info = service.frontendInfo()
1529                 feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber)
1530                 if feNumber is None:
1531                         self["NimA"].hide()
1532                         self["NimB"].hide()
1533                 elif feNumber == 0:
1534                         self["NimB"].hide()
1535                         self["NimA"].show()
1536                 elif feNumber == 1:
1537                         self["NimA"].hide()
1538                         self["NimB"].show()
1539
1540         def gotServiceEvent(self, ev):
1541                 service = self.session.nav.getCurrentService()
1542                 if ev == iPlayableService.evStart:
1543                         self.checkTunerState(service)
1544
1545 class InfoBarNotifications:
1546         def __init__(self):
1547                 self.onExecBegin.append(self.checkNotifications)
1548                 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1549                 self.onClose.append(self.__removeNotification)
1550
1551         def __removeNotification(self):
1552                 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1553
1554         def checkNotificationsIfExecing(self):
1555                 if self.execing:
1556                         self.checkNotifications()
1557
1558         def checkNotifications(self):
1559                 if len(Notifications.notifications):
1560                         n = Notifications.notifications[0]
1561                         Notifications.notifications = Notifications.notifications[1:]
1562                         cb = n[0]
1563                         if cb is not None:
1564                                 self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1565                         else:
1566                                 self.session.open(n[1], *n[2], **n[3])
1567
1568 class InfoBarServiceNotifications:
1569         def __init__(self):
1570                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1571                         {
1572                                 iPlayableService.evEnd: self.serviceHasEnded
1573                         })
1574
1575         def serviceHasEnded(self):
1576                 print "service end!"
1577
1578                 try:
1579                         self.setSeekState(self.SEEK_STATE_PLAY)
1580                 except:
1581                         pass
1582
1583 class InfoBarCueSheetSupport:
1584         CUT_TYPE_IN = 0
1585         CUT_TYPE_OUT = 1
1586         CUT_TYPE_MARK = 2
1587         CUT_TYPE_LAST = 3
1588
1589         ENABLE_RESUME_SUPPORT = False
1590
1591         def __init__(self):
1592                 self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions",
1593                         {
1594                                 "jumpPreviousMark": (self.jumpPreviousMark, "jump to next marked position"),
1595                                 "jumpNextMark": (self.jumpNextMark, "jump to previous marked position"),
1596                                 "toggleMark": (self.toggleMark, "toggle a cut mark at the current position")
1597                         }, prio=1)
1598
1599                 self.cut_list = [ ]
1600                 self.is_closing = False
1601                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1602                         {
1603                                 iPlayableService.evStart: self.__serviceStarted,
1604                         })
1605
1606         def __serviceStarted(self):
1607                 if self.is_closing:
1608                         return
1609                 print "new service started! trying to download cuts!"
1610                 self.downloadCuesheet()
1611
1612                 if self.ENABLE_RESUME_SUPPORT:
1613                         last = None
1614
1615                         for (pts, what) in self.cut_list:
1616                                 if what == self.CUT_TYPE_LAST:
1617                                         last = pts
1618
1619                         if last is not None:
1620                                 self.resume_point = last
1621                                 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1622
1623         def playLastCB(self, answer):
1624                 if answer == True:
1625                         seekable = self.__getSeekable()
1626                         if seekable is not None:
1627                                 seekable.seekTo(self.resume_point)
1628
1629         def __getSeekable(self):
1630                 service = self.session.nav.getCurrentService()
1631                 if service is None:
1632                         return None
1633                 return service.seek()
1634
1635         def cueGetCurrentPosition(self):
1636                 seek = self.__getSeekable()
1637                 if seek is None:
1638                         return None
1639                 r = seek.getPlayPosition()
1640                 if r[0]:
1641                         return None
1642                 return long(r[1])
1643
1644         def jumpPreviousNextMark(self, cmp, alternative=None):
1645                 current_pos = self.cueGetCurrentPosition()
1646                 if current_pos is None:
1647                         return
1648                 mark = self.getNearestCutPoint(current_pos, cmp=cmp)
1649                 if mark is not None:
1650                         pts = mark[0]
1651                 elif alternative is not None:
1652                         pts = alternative
1653                 else:
1654                         return
1655
1656                 seekable = self.__getSeekable()
1657                 if seekable is not None:
1658                         seekable.seekTo(pts)
1659
1660         def jumpPreviousMark(self):
1661                 # we add 2 seconds, so if the play position is <2s after
1662                 # the mark, the mark before will be used
1663                 self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0)
1664
1665         def jumpNextMark(self):
1666                 self.jumpPreviousNextMark(lambda x: x)
1667
1668         def getNearestCutPoint(self, pts, cmp=abs):
1669                 # can be optimized
1670                 nearest = None
1671                 for cp in self.cut_list:
1672                         diff = cmp(cp[0] - pts)
1673                         if diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
1674                                 nearest = cp
1675                 return nearest
1676
1677         def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
1678                 current_pos = self.cueGetCurrentPosition()
1679                 if current_pos is None:
1680                         print "not seekable"
1681                         return
1682
1683                 nearest_cutpoint = self.getNearestCutPoint(current_pos)
1684
1685                 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
1686                         if onlyreturn:
1687                                 return nearest_cutpoint
1688                         if not onlyadd:
1689                                 self.removeMark(nearest_cutpoint)
1690                 elif not onlyremove and not onlyreturn:
1691                         self.addMark((current_pos, self.CUT_TYPE_MARK))
1692
1693                 if onlyreturn:
1694                         return None
1695
1696         def addMark(self, point):
1697                 bisect.insort(self.cut_list, point)
1698                 self.uploadCuesheet()
1699
1700         def removeMark(self, point):
1701                 self.cut_list.remove(point)
1702                 self.uploadCuesheet()
1703
1704         def __getCuesheet(self):
1705                 service = self.session.nav.getCurrentService()
1706                 if service is None:
1707                         return None
1708                 return service.cueSheet()
1709
1710         def uploadCuesheet(self):
1711                 cue = self.__getCuesheet()
1712
1713                 if cue is None:
1714                         print "upload failed, no cuesheet interface"
1715                         return
1716                 cue.setCutList(self.cut_list)
1717
1718         def downloadCuesheet(self):
1719                 cue = self.__getCuesheet()
1720
1721                 if cue is None:
1722                         print "upload failed, no cuesheet interface"
1723                         return
1724                 self.cut_list = cue.getCutList()
1725
1726 class InfoBarSummary(Screen):
1727         skin = """
1728         <screen position="0,0" size="132,64">
1729                 <widget source="CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
1730                         <convert type="ClockToText">WithSeconds</convert>
1731                 </widget>
1732                 <widget source="CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
1733                         <convert type="ServiceName">Name</convert>
1734                 </widget>
1735         </screen>"""
1736
1737         def __init__(self, session, parent):
1738                 Screen.__init__(self, session)
1739                 self["CurrentService"] = CurrentService(self.session.nav)
1740                 self["CurrentTime"] = Clock()
1741
1742 class InfoBarSummarySupport:
1743         def __init__(self):
1744                 pass
1745
1746         def createSummary(self):
1747                 return InfoBarSummary
1748
1749 class InfoBarTeletextPlugin:
1750         def __init__(self):
1751                 self.teletext_plugin = None
1752
1753                 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
1754                         self.teletext_plugin = p
1755
1756                 if self.teletext_plugin is not None:
1757                         self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
1758                                 {
1759                                         "startTeletext": (self.startTeletext, _("View teletext..."))
1760                                 })
1761                 else:
1762                         print "no teletext plugin found!"
1763
1764         def startTeletext(self):
1765                 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
1766
1767 class InfoBarSubtitleSupport(object):
1768         def __init__(self):
1769                 object.__init__(self)
1770                 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
1771                 self.__subtitles_enabled = False
1772
1773                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1774                         {
1775                                 iPlayableService.evStart: self.__serviceStarted,
1776                         })
1777
1778         def __serviceStarted(self):
1779                 # reenable if it was enabled
1780                 r = self.__subtitles_enabled
1781                 self.__subtitles_enabled = False
1782                 self.__selected_subtitle = None
1783                 self.setSubtitlesEnable(r)
1784
1785         def getCurrentServiceSubtitle(self):
1786                 service = self.session.nav.getCurrentService()
1787                 return service and service.subtitle()
1788
1789         def setSubtitlesEnable(self, enable=True):
1790                 subtitle = self.getCurrentServiceSubtitle()
1791                 if enable and self.__selected_subtitle is not None:
1792                         if subtitle and not self.__subtitles_enabled:
1793                                 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
1794                                 self.subtitle_window.show()
1795                                 self.__subtitles_enabled = True
1796                 else:
1797                         if subtitle:
1798                                 subtitle.disableSubtitles(self.subtitle_window.instance)
1799
1800                         self.subtitle_window.hide()
1801                         self.__subtitles_enabled = False
1802
1803         def setSelectedSubtitle(self, subtitle):
1804                 if self.__selected_subtitle != subtitle and self.subtitles_enabled:
1805                         # kick
1806                         self.__selected_subtitle = subtitle
1807                         self.__serviceStarted()
1808                 else:
1809                         self.__selected_subtitle = subtitle
1810
1811         subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
1812         selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)