code.vuplus.com Git - vuplus_dvbapp/blob - 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.Clock import Clock
   7 from Components.EventInfo import EventInfo, EventInfoProgress
   8 from Components.Harddisk import harddiskmanager
   9 from Components.Input import Input
  10 from Components.Label import *
  11 from Components.Pixmap import Pixmap, PixmapConditional
  12 from Components.PluginComponent import plugins
  13 from Components.ProgressBar import *
  14 from Components.ServiceEventTracker import ServiceEventTracker
  15 from Components.ServiceName import ServiceName
  16 from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean
  17 from Components.config import configfile, configsequencearg
  18 from Components.TimerList import TimerEntryComponent
  19 from Components.TunerInfo import TunerInfo
  20
  21 from EpgSelection import EPGSelection
  22 from Plugins.Plugin import PluginDescriptor
  23
  24 from Screen import Screen
  25 from Screens.ChoiceBox import ChoiceBox
  26 from Screens.Dish import Dish
  27 from Screens.EventView import EventViewEPGSelect, EventViewSimple
  28 from Screens.InputBox import InputBox
  29 from Screens.MessageBox import MessageBox
  30 from Screens.MinuteInput import MinuteInput
  31 from Screens.TimerSelection import TimerSelection
  32 from Screens.PictureInPicture import PictureInPicture
  33 from ServiceReference import ServiceReference
  34
  35 from Tools import Notifications
  36 from Tools.Directories import *
  37
  38 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
  39 from enigma import *
  40
  41 import time
  42 import os
  43 import bisect
  44
  45 from Components.config import config, currentConfigSelectionElement
  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                         self.hideTimer.start(5000, True)
  89
  90         def __onHide(self):
  91                 self.__state = self.STATE_HIDDEN
  92
  93         def doShow(self):
  94                 self.show()
  95                 self.startHideTimer()
  96
  97         def doTimerHide(self):
  98                 self.hideTimer.stop()
  99                 if self.__state == self.STATE_SHOWN:
 100                         self.hide()
 101
 102         def toggleShow(self):
 103                 if self.__state == self.STATE_SHOWN:
 104                         self.hide()
 105                         self.hideTimer.stop()
 106                 elif self.__state == self.STATE_HIDDEN:
 107                         self.show()
 108
 109         def lockShow(self):
 110                 self.__locked = self.__locked + 1
 111                 if self.execing:
 112                         self.show()
 113                         self.hideTimer.stop()
 114
 115         def unlockShow(self):
 116                 self.__locked = self.__locked - 1
 117                 if self.execing:
 118                         self.startHideTimer()
 119
 120 #       def startShow(self):
 121 #               self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
 122 #               self.__state = self.STATE_SHOWN
 123 #
 124 #       def startHide(self):
 125 #               self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
 126 #               self.__state = self.STATE_HIDDEN
 127
 128 class NumberZap(Screen):
 129         def quit(self):
 130                 self.Timer.stop()
 131                 self.close(0)
 132
 133         def keyOK(self):
 134                 self.Timer.stop()
 135                 self.close(int(self["number"].getText()))
 136
 137         def keyNumberGlobal(self, number):
 138                 self.Timer.start(3000, True)            #reset timer
 139                 self.field = self.field + str(number)
 140                 self["number"].setText(self.field)
 141                 if len(self.field) >= 4:
 142                         self.keyOK()
 143
 144         def __init__(self, session, number):
 145                 Screen.__init__(self, session)
 146                 self.field = str(number)
 147
 148                 self["channel"] = Label(_("Channel:"))
 149
 150                 self["number"] = Label(self.field)
 151
 152                 self["actions"] = NumberActionMap( [ "SetupActions" ],
 153                         {
 154                                 "cancel": self.quit,
 155                                 "ok": self.keyOK,
 156                                 "1": self.keyNumberGlobal,
 157                                 "2": self.keyNumberGlobal,
 158                                 "3": self.keyNumberGlobal,
 159                                 "4": self.keyNumberGlobal,
 160                                 "5": self.keyNumberGlobal,
 161                                 "6": self.keyNumberGlobal,
 162                                 "7": self.keyNumberGlobal,
 163                                 "8": self.keyNumberGlobal,
 164                                 "9": self.keyNumberGlobal,
 165                                 "0": self.keyNumberGlobal
 166                         })
 167
 168                 self.Timer = eTimer()
 169                 self.Timer.timeout.get().append(self.keyOK)
 170                 self.Timer.start(3000, True)
 171
 172 class InfoBarNumberZap:
 173         """ Handles an initial number for NumberZapping """
 174         def __init__(self):
 175                 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
 176                         {
 177                                 "1": self.keyNumberGlobal,
 178                                 "2": self.keyNumberGlobal,
 179                                 "3": self.keyNumberGlobal,
 180                                 "4": self.keyNumberGlobal,
 181                                 "5": self.keyNumberGlobal,
 182                                 "6": self.keyNumberGlobal,
 183                                 "7": self.keyNumberGlobal,
 184                                 "8": self.keyNumberGlobal,
 185                                 "9": self.keyNumberGlobal,
 186                                 "0": self.keyNumberGlobal,
 187                         })
 188
 189         def keyNumberGlobal(self, number):
 190 #               print "You pressed number " + str(number)
 191                 if number == 0:
 192                         self.servicelist.recallPrevService()
 193                         self.doShow()
 194                 else:
 195                         self.session.openWithCallback(self.numberEntered, NumberZap, number)
 196
 197         def numberEntered(self, retval):
 198 #               print self.servicelist
 199                 if retval > 0:
 200                         self.zapToNumber(retval)
 201
 202         def searchNumberHelper(self, serviceHandler, num, bouquet):
 203                 servicelist = serviceHandler.list(bouquet)
 204                 if not servicelist is None:
 205                         while num:
 206                                 serviceIterator = servicelist.getNext()
 207                                 if not serviceIterator.valid(): #check end of list
 208                                         break
 209                                 if serviceIterator.flags: #assume normal dvb service have no flags set
 210                                         continue
 211                                 num -= 1;
 212                         if not num: #found service with searched number ?
 213                                 return serviceIterator, 0
 214                 return None, num
 215
 216         def zapToNumber(self, number):
 217                 bouquet = self.servicelist.bouquet_root
 218                 service = None
 219                 serviceHandler = eServiceCenter.getInstance()
 220                 if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
 221                         service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
 222                 else:
 223                         bouquetlist = serviceHandler.list(bouquet)
 224                         if not bouquetlist is None:
 225                                 while number:
 226                                         bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext())
 227                                         if not bouquet.valid(): #check end of list
 228                                                 break
 229                                         if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
 230                                                 continue
 231                                         service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
 232                 if not service is None:
 233                         if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
 234                                 self.servicelist.clearPath()
 235                                 if self.servicelist.bouquet_root != bouquet:
 236                                         self.servicelist.enterPath(self.servicelist.bouquet_root)
 237                                 self.servicelist.enterPath(bouquet)
 238                         self.servicelist.setCurrentSelection(service) #select the service in servicelist
 239                         self.servicelist.zap()
 240
 241 config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1);
 242
 243 class InfoBarChannelSelection:
 244         """ ChannelSelection - handles the channelSelection dialog and the initial
 245         channelChange actions which open the channelSelection dialog """
 246         def __init__(self):
 247                 #instantiate forever
 248                 self.servicelist = self.session.instantiateDialog(ChannelSelection)
 249
 250                 if config.misc.initialchannelselection.value == 1:
 251                         self.onShown.append(self.firstRun)
 252
 253                 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
 254                         {
 255                                 "switchChannelUp": self.switchChannelUp,
 256                                 "switchChannelDown": self.switchChannelDown,
 257                                 "zapUp": (self.zapUp, _("previous channel")),
 258                                 "zapDown": (self.zapDown, _("next channel")),
 259                                 "historyBack": (self.historyBack, _("previous channel in history")),
 260                                 "historyNext": (self.historyNext, _("next channel in history"))
 261                         })
 262
 263         def firstRun(self):
 264                 self.onShown.remove(self.firstRun)
 265                 config.misc.initialchannelselection.value = 0
 266                 config.misc.initialchannelselection.save()
 267                 self.switchChannelDown()
 268
 269         def historyBack(self):
 270                 self.servicelist.historyBack()
 271
 272         def historyNext(self):
 273                 self.servicelist.historyNext()
 274
 275         def switchChannelUp(self):
 276                 self.servicelist.moveUp()
 277                 self.session.execDialog(self.servicelist)
 278
 279         def switchChannelDown(self):
 280                 self.servicelist.moveDown()
 281                 self.session.execDialog(self.servicelist)
 282
 283         def zapUp(self):
 284                 if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":
 285                         if self.servicelist.inBouquet() and self.servicelist.atBegin():
 286                                 self.servicelist.prevBouquet()
 287                 self.servicelist.moveUp()
 288                 self.servicelist.zap()
 289                 self.doShow()
 290
 291         def zapDown(self):
 292                 if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.inBouquet() and self.servicelist.atEnd():
 293                         self.servicelist.nextBouquet()
 294                 else:
 295                         self.servicelist.moveDown()
 296                 self.servicelist.zap()
 297                 self.doShow()
 298
 299 class InfoBarMenu:
 300         """ Handles a menu action, to open the (main) menu """
 301         def __init__(self):
 302                 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
 303                         {
 304                                 "mainMenu": (self.mainMenu, "Enter main menu..."),
 305                         })
 306
 307         def mainMenu(self):
 308                 print "loading mainmenu XML..."
 309                 menu = mdom.childNodes[0]
 310                 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
 311                 self.session.open(MainMenu, menu, menu.childNodes)
 312
 313 class InfoBarSimpleEventView:
 314         """ Opens the Eventview for now/next """
 315         def __init__(self):
 316                 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
 317                         {
 318                                 "showEventInfo": (self.openEventView, _("show event details")),
 319                         })
 320
 321         def openEventView(self):
 322                 self.epglist = [ ]
 323                 service = self.session.nav.getCurrentService()
 324                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 325                 info = service.info()
 326                 ptr=info.getEvent(0)
 327                 if ptr:
 328                         self.epglist.append(ptr)
 329                 ptr=info.getEvent(1)
 330                 if ptr:
 331                         self.epglist.append(ptr)
 332                 if len(self.epglist) > 0:
 333                         self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
 334
 335         def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 336                 if len(self.epglist) > 1:
 337                         tmp = self.epglist[0]
 338                         self.epglist[0]=self.epglist[1]
 339                         self.epglist[1]=tmp
 340                         setEvent(self.epglist[0])
 341
 342 class InfoBarEPG:
 343         """ EPG - Opens an EPG list when the showEPGList action fires """
 344         def __init__(self):
 345                 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
 346                         {
 347                                 "showEventInfo": (self.openEventView, _("show EPG...")),
 348                         })
 349
 350         def zapToService(self, service):
 351                 if not service is None:
 352                         if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
 353                                 self.servicelist.clearPath()
 354                                 if self.servicelist.bouquet_root != self.epg_bouquet:
 355                                         self.servicelist.enterPath(self.servicelist.bouquet_root)
 356                                 self.servicelist.enterPath(self.epg_bouquet)
 357                         self.servicelist.setCurrentSelection(service) #select the service in servicelist
 358                         self.servicelist.zap()
 359
 360         def openBouquetEPG(self, bouquet, withCallback=True):
 361                 ptr=eEPGCache.getInstance()
 362                 services = [ ]
 363                 servicelist = eServiceCenter.getInstance().list(bouquet)
 364                 if not servicelist is None:
 365                         while True:
 366                                 service = servicelist.getNext()
 367                                 if not service.valid(): #check if end of list
 368                                         break
 369                                 if service.flags: #ignore non playable services
 370                                         continue
 371                                 services.append(ServiceReference(service))
 372                 if len(services):
 373                         self.epg_bouquet = bouquet
 374                         if withCallback:
 375                                 self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService)
 376                         else:
 377                                 self.session.open(EPGSelection, services, self.zapToService)
 378
 379         def closed(self, ret):
 380                 if ret:
 381                         self.close(ret)
 382
 383         def openMultiServiceEPG(self, withCallback=True):
 384                 bouquets = self.servicelist.getBouquetList()
 385                 if bouquets is None:
 386                         cnt = 0
 387                 else:
 388                         cnt = len(bouquets)
 389                 if cnt > 1: # show bouquet list
 390                         if withCallback:
 391                                 self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG)
 392                         else:
 393                                 self.session.open(BouquetSelector, bouquets, self.openBouquetEPG)
 394                 elif cnt == 1:
 395                         self.openBouquetEPG(bouquets[0][1], withCallback)
 396
 397         def openSingleServiceEPG(self):
 398                 ref=self.session.nav.getCurrentlyPlayingServiceReference()
 399                 ptr=eEPGCache.getInstance()
 400                 self.session.openWithCallback(self.closed, EPGSelection, ref)
 401
 402         def openEventView(self):
 403                 self.epglist = [ ]
 404                 service = self.session.nav.getCurrentService()
 405                 ref = self.session.nav.getCurrentlyPlayingServiceReference()
 406                 info = service.info()
 407                 ptr=info.getEvent(0)
 408                 if ptr:
 409                         self.epglist.append(ptr)
 410                 ptr=info.getEvent(1)
 411                 if ptr:
 412                         self.epglist.append(ptr)
 413                 if len(self.epglist) == 0:
 414                         epg = eEPGCache.getInstance()
 415                         ptr = epg.lookupEventTime(ref, -1)
 416                         if ptr:
 417                                 self.epglist.append(ptr)
 418                                 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
 419                                 if ptr:
 420                                         self.epglist.append(ptr)
 421                 if len(self.epglist) > 0:
 422                         self.session.open(EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG)
 423                 else:
 424                         print "no epg for the service avail.. so we show multiepg instead of eventinfo"
 425                         self.openMultiServiceEPG(False)
 426
 427         def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 428                 if len(self.epglist) > 1:
 429                         tmp = self.epglist[0]
 430                         self.epglist[0]=self.epglist[1]
 431                         self.epglist[1]=tmp
 432                         setEvent(self.epglist[0])
 433
 434 class InfoBarTuner:
 435         """provides a snr/agc/ber display"""
 436         def __init__(self):
 437                 self["snr"] = Label()
 438                 self["agc"] = Label()
 439                 self["ber"] = Label()
 440                 self["snr_percent"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, servicefkt = self.session.nav.getCurrentService)
 441                 self["agc_percent"] = TunerInfo(TunerInfo.AGC_PERCENTAGE, servicefkt = self.session.nav.getCurrentService)
 442                 self["ber_count"] = TunerInfo(TunerInfo.BER_VALUE, servicefkt = self.session.nav.getCurrentService)
 443                 self["snr_progress"] = TunerInfo(TunerInfo.SNR_BAR, servicefkt = self.session.nav.getCurrentService)
 444                 self["agc_progress"] = TunerInfo(TunerInfo.AGC_BAR, servicefkt = self.session.nav.getCurrentService)
 445                 self["ber_progress"] = TunerInfo(TunerInfo.BER_BAR, servicefkt = self.session.nav.getCurrentService)
 446                 self.timer = eTimer()
 447                 self.timer.timeout.get().append(self.updateTunerInfo)
 448                 self.timer.start(1000)
 449
 450         def updateTunerInfo(self):
 451                 if self.instance.isVisible():
 452                         self["snr_percent"].update()
 453                         self["agc_percent"].update()
 454                         self["ber_count"].update()
 455                         self["snr_progress"].update()
 456                         self["agc_progress"].update()
 457                         self["ber_progress"].update()
 458
 459 class InfoBarEvent:
 460         """provides a current/next event info display"""
 461         def __init__(self):
 462                 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
 463                 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
 464
 465                 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
 466                 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
 467
 468                 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Remaining)
 469                 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
 470
 471                 self["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now)
 472
 473 class InfoBarServiceName:
 474         def __init__(self):
 475                 self["ServiceName"] = ServiceName(self.session.nav)
 476
 477 class InfoBarSeek:
 478         """handles actions like seeking, pause"""
 479
 480         # ispause, isff, issm
 481         SEEK_STATE_PLAY = (0, 0, 0, ">")
 482         SEEK_STATE_PAUSE = (1, 0, 0, "||")
 483         SEEK_STATE_FF_2X = (0, 2, 0, ">> 2x")
 484         SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x")
 485         SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x")
 486         SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x")
 487         SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x")
 488         SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x")
 489
 490         SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x")
 491         SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x")
 492         SEEK_STATE_BACK_64X = (0, -64, 0, "<< 64x")
 493         SEEK_STATE_BACK_128X = (0, -128, 0, "<< 128x")
 494
 495         SEEK_STATE_SM_HALF = (0, 0, 2, "/2")
 496         SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4")
 497         SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8")
 498
 499         def __init__(self):
 500                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
 501                         {
 502                                 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
 503                                 iPlayableService.evStart: self.__serviceStarted,
 504
 505                                 iPlayableService.evEOF: self.__evEOF,
 506                                 iPlayableService.evSOF: self.__evSOF,
 507                         })
 508
 509                 class InfoBarSeekActionMap(HelpableActionMap):
 510                         def __init__(self, screen, *args, **kwargs):
 511                                 HelpableActionMap.__init__(self, screen, *args, **kwargs)
 512                                 self.screen = screen
 513
 514                         def action(self, contexts, action):
 515                                 if action[:5] == "seek:":
 516                                         time = int(action[5:])
 517                                         self.screen.seekRelative(time * 90000)
 518                                         return 1
 519                                 else:
 520                                         return HelpableActionMap.action(self, contexts, action)
 521
 522                 self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions",
 523                         {
 524                                 "pauseService": (self.pauseService, "pause"),
 525                                 "unPauseService": (self.unPauseService, "continue"),
 526
 527                                 "seekFwd": (self.seekFwd, "skip forward"),
 528                                 "seekFwdDown": self.seekFwdDown,
 529                                 "seekFwdUp": self.seekFwdUp,
 530                                 "seekBack": (self.seekBack, "skip backward"),
 531                                 "seekBackDown": self.seekBackDown,
 532                                 "seekBackUp": self.seekBackUp,
 533                         }, prio=-1)
 534                         # give them a little more priority to win over color buttons
 535
 536                 self.seekstate = self.SEEK_STATE_PLAY
 537                 self.onClose.append(self.delTimer)
 538
 539                 self.fwdtimer = False
 540                 self.fwdKeyTimer = eTimer()
 541                 self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
 542
 543                 self.rwdtimer = False
 544                 self.rwdKeyTimer = eTimer()
 545                 self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
 546
 547                 self.onPlayStateChanged = [ ]
 548
 549                 self.lockedBecauseOfSkipping = False
 550
 551         def up(self):
 552                 pass
 553
 554         def down(self):
 555                 pass
 556
 557         def delTimer(self):
 558                 del self.fwdKeyTimer
 559                 del self.rwdKeyTimer
 560
 561         def getSeek(self):
 562                 service = self.session.nav.getCurrentService()
 563                 if service is None:
 564                         return False
 565
 566                 seek = service.seek()
 567
 568                 if seek is None or not seek.isCurrentlySeekable():
 569                         return None
 570
 571                 return seek
 572
 573         def isSeekable(self):
 574                 if self.getSeek() is None:
 575                         return False
 576                 return True
 577
 578         def __seekableStatusChanged(self):
 579                 print "seekable status changed!"
 580                 if not self.isSeekable():
 581                         self["SeekActions"].setEnabled(False)
 582                         print "not seekable, return to play"
 583                         self.setSeekState(self.SEEK_STATE_PLAY)
 584                 else:
 585                         self["SeekActions"].setEnabled(True)
 586                         print "seekable"
 587
 588         def __serviceStarted(self):
 589                 self.seekstate = self.SEEK_STATE_PLAY
 590
 591         def setSeekState(self, state):
 592                 service = self.session.nav.getCurrentService()
 593
 594                 if service is None:
 595                         return False
 596
 597                 if not self.isSeekable():
 598                         if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
 599                                 state = self.SEEK_STATE_PLAY
 600
 601                 pauseable = service.pause()
 602
 603                 if pauseable is None:
 604                         print "not pauseable."
 605                         state = self.SEEK_STATE_PLAY
 606
 607                 oldstate = self.seekstate
 608                 self.seekstate = state
 609
 610                 for i in range(3):
 611                         if oldstate[i] != self.seekstate[i]:
 612                                 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
 613
 614                 for c in self.onPlayStateChanged:
 615                         c(self.seekstate)
 616
 617                 self.checkSkipShowHideLock()
 618
 619                 return True
 620
 621         def pauseService(self):
 622                 if self.seekstate == self.SEEK_STATE_PAUSE:
 623                         print "pause, but in fact unpause"
 624                         self.unPauseService()
 625                 else:
 626                         if self.seekstate == self.SEEK_STATE_PLAY:
 627                                 print "yes, playing."
 628                         else:
 629                                 print "no", self.seekstate
 630                         print "pause"
 631                         self.setSeekState(self.SEEK_STATE_PAUSE);
 632
 633         def unPauseService(self):
 634                 print "unpause"
 635                 self.setSeekState(self.SEEK_STATE_PLAY);
 636
 637         def doSeek(self, seektime):
 638                 print "doseek", seektime
 639                 service = self.session.nav.getCurrentService()
 640                 if service is None:
 641                         return
 642
 643                 seekable = self.getSeek()
 644                 if seekable is None:
 645                         return
 646
 647                 seekable.seekTo(90 * seektime)
 648
 649         def seekFwdDown(self):
 650                 print "start fwd timer"
 651                 self.fwdtimer = True
 652                 self.fwdKeyTimer.start(1000)
 653
 654         def seekBackDown(self):
 655                 print "start rewind timer"
 656                 self.rwdtimer = True
 657                 self.rwdKeyTimer.start(1000)
 658
 659         def seekFwdUp(self):
 660                 print "seekFwdUp"
 661                 if self.fwdtimer:
 662                         self.fwdKeyTimer.stop()
 663                         self.fwdtimer = False
 664                         self.seekFwd()
 665
 666         def seekFwd(self):
 667                 lookup = {
 668                                 self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
 669                                 self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
 670                                 self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
 671                                 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
 672                                 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
 673                                 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
 674                                 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
 675                                 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
 676                                 self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY,
 677                                 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
 678                                 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
 679                                 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
 680                                 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
 681                                 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
 682                                 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
 683                         }
 684                 self.setSeekState(lookup[self.seekstate])
 685
 686         def seekBackUp(self):
 687                 print "seekBackUp"
 688                 if self.rwdtimer:
 689                         self.rwdKeyTimer.stop()
 690                         self.rwdtimer = False
 691                         self.seekBack()
 692
 693         def seekBack(self):
 694                 lookup = {
 695                                 self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
 696                                 self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
 697                                 self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
 698                                 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
 699                                 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
 700                                 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
 701                                 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
 702                                 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
 703                                 self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
 704                                 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
 705                                 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
 706                                 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
 707                                 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
 708                                 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
 709                                 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
 710                         }
 711                 self.setSeekState(lookup[self.seekstate])
 712
 713                 if self.seekstate == self.SEEK_STATE_PAUSE:
 714                         seekable = self.getSeek()
 715                         if seekable is not None:
 716                                 seekable.seekRelative(-1, 3)
 717
 718         def fwdTimerFire(self):
 719                 print "Display seek fwd"
 720                 self.fwdKeyTimer.stop()
 721                 self.fwdtimer = False
 722                 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
 723
 724         def fwdSeekTo(self, minutes):
 725                 print "Seek", minutes, "minutes forward"
 726                 if minutes != 0:
 727                         seekable = self.getSeek()
 728                         if seekable is not None:
 729                                 seekable.seekRelative(1, minutes * 60 * 90000)
 730
 731         def rwdTimerFire(self):
 732                 print "rwdTimerFire"
 733                 self.rwdKeyTimer.stop()
 734                 self.rwdtimer = False
 735                 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
 736
 737         def rwdSeekTo(self, minutes):
 738                 print "rwdSeekTo"
 739                 self.fwdSeekTo(0 - minutes)
 740
 741         def checkSkipShowHideLock(self):
 742                 wantlock = self.seekstate != self.SEEK_STATE_PLAY
 743
 744                 if self.lockedBecauseOfSkipping and not wantlock:
 745                         self.unlockShow()
 746                         self.lockedBecauseOfSkipping = False
 747
 748                 if wantlock and not self.lockedBecauseOfSkipping:
 749                         self.lockShow()
 750                         self.lockedBecauseOfSkipping = True
 751
 752         def __evEOF(self):
 753                 if self.seekstate != self.SEEK_STATE_PLAY:
 754                         self.setSeekState(self.SEEK_STATE_PAUSE)
 755                         # HACK
 756                         #self.getSeek().seekRelative(1, -90000)
 757                         self.setSeekState(self.SEEK_STATE_PLAY)
 758                 else:
 759                         self.setSeekState(self.SEEK_STATE_PAUSE)
 760
 761         def __evSOF(self):
 762                 self.setSeekState(self.SEEK_STATE_PLAY)
 763                 self.doSeek(0)
 764
 765         def seekRelative(self, diff):
 766                 seekable = self.getSeek()
 767                 if seekable is not None:
 768                         seekable.seekRelative(1, diff)
 769
 770 from Screens.PVRState import PVRState, TimeshiftState
 771
 772 class InfoBarPVRState:
 773         def __init__(self, screen=PVRState):
 774                 self.onPlayStateChanged.append(self.__playStateChanged)
 775                 self.pvrStateDialog = self.session.instantiateDialog(screen)
 776                 self.onShow.append(self.__mayShow)
 777                 self.onHide.append(self.pvrStateDialog.hide)
 778
 779         def __mayShow(self):
 780                 if self.seekstate != self.SEEK_STATE_PLAY and self.execing:
 781                         self.pvrStateDialog.show()
 782
 783         def __playStateChanged(self, state):
 784                 playstateString = state[3]
 785                 self.pvrStateDialog["state"].setText(playstateString)
 786                 self.__mayShow()
 787
 788 class InfoBarTimeshiftState(InfoBarPVRState):
 789         def __init__(self):
 790                 InfoBarPVRState.__init__(self, screen=TimeshiftState)
 791
 792
 793 class InfoBarShowMovies:
 794
 795         # i don't really like this class.
 796         # it calls a not further specified "movie list" on up/down/movieList,
 797         # so this is not more than an action map
 798         def __init__(self):
 799                 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
 800                         {
 801                                 "movieList": (self.showMovies, "movie list"),
 802                                 "up": (self.showMovies, "movie list"),
 803                                 "down": (self.showMovies, "movie list")
 804                         })
 805
 806 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
 807
 808 # Hrmf.
 809 #
 810 # Timeshift works the following way:
 811 #                                         demux0   demux1                    "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
 812 # - normal playback                       TUNER    unused      PLAY               enable                disable              disable
 813 # - user presses "yellow" button.         TUNER    record      PAUSE              enable                disable              enable
 814 # - user presess pause again              FILE     record      PLAY               enable                disable              enable
 815 # - user fast forwards                    FILE     record      FF                 enable                disable              enable
 816 # - end of timeshift buffer reached       TUNER    record      PLAY               enable                enable               disable
 817 # - user backwards                        FILE     record      BACK  # !!         enable                disable              enable
 818 #
 819
 820 # in other words:
 821 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
 822 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
 823 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
 824 # - the user can now PVR around
 825 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
 826 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
 827 # after!
 828 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
 829 # - if the user rewinds, or press pause, timeshift will be activated again
 830
 831 # note that a timeshift can be enabled ("recording") and
 832 # activated (currently time-shifting).
 833
 834 class InfoBarTimeshift:
 835         def __init__(self):
 836                 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
 837                         {
 838                                 "timeshiftStart": (self.startTimeshift, "start timeshift"),  # the "yellow key"
 839                                 "timeshiftStop": (self.stopTimeshift, "stop timeshift")      # currently undefined :), probably 'TV'
 840                         }, prio=1)
 841                 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
 842                         {
 843                                 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key"
 844                                 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause  # something like "backward key"
 845                         }, prio=-1) # priority over record
 846
 847                 self.timeshift_enabled = 0
 848                 self.timeshift_state = 0
 849                 self.ts_pause_timer = eTimer()
 850                 self.ts_pause_timer.timeout.get().append(self.pauseService)
 851
 852                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
 853                         {
 854                                 iPlayableService.evStart: self.__serviceStarted,
 855                                 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
 856                         })
 857
 858         def getTimeshift(self):
 859                 service = self.session.nav.getCurrentService()
 860                 return service.timeshift()
 861
 862         def startTimeshift(self):
 863                 print "enable timeshift"
 864                 ts = self.getTimeshift()
 865                 if ts is None:
 866                         self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
 867                         print "no ts interface"
 868                         return
 869
 870                 if self.timeshift_enabled:
 871                         print "hu, timeshift already enabled?"
 872                 else:
 873                         if not ts.startTimeshift():
 874                                 import time
 875                                 self.timeshift_enabled = 1
 876                                 self.pvrStateDialog["timeshift"].setRelative(time.time())
 877
 878                                 # PAUSE.
 879                                 self.setSeekState(self.SEEK_STATE_PAUSE)
 880
 881                                 # enable the "TimeshiftEnableActions", which will override
 882                                 # the startTimeshift actions
 883                                 self.__seekableStatusChanged()
 884                         else:
 885                                 print "timeshift failed"
 886
 887         def stopTimeshift(self):
 888                 if not self.timeshift_enabled:
 889                         return
 890                 print "disable timeshift"
 891                 ts = self.getTimeshift()
 892                 if ts is None:
 893                         return
 894                 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
 895
 896         def stopTimeshiftConfirmed(self, confirmed):
 897                 if not confirmed:
 898                         return
 899
 900                 ts = self.getTimeshift()
 901                 if ts is None:
 902                         return
 903
 904                 ts.stopTimeshift()
 905                 self.timeshift_enabled = 0
 906
 907                 # disable actions
 908                 self.__seekableStatusChanged()
 909
 910         # activates timeshift, and seeks to (almost) the end
 911         def activateTimeshiftEnd(self):
 912                 ts = self.getTimeshift()
 913
 914                 if ts is None:
 915                         return
 916
 917                 if ts.isTimeshiftActive():
 918                         print "!! activate timeshift called - but shouldn't this be a normal pause?"
 919                         self.pauseService()
 920                 else:
 921                         self.setSeekState(self.SEEK_STATE_PLAY)
 922                         ts.activateTimeshift()
 923                         self.seekRelative(0)
 924
 925         # same as activateTimeshiftEnd, but pauses afterwards.
 926         def activateTimeshiftEndAndPause(self):
 927                 state = self.seekstate
 928                 self.activateTimeshiftEnd()
 929
 930                 # well, this is "andPause", but it could be pressed from pause,
 931                 # when pausing on the (fake-)"live" picture, so an un-pause
 932                 # is perfectly ok.
 933
 934                 print "now, pauseService"
 935                 if state == self.SEEK_STATE_PLAY:
 936                         print "is PLAYING, start pause timer"
 937                         self.ts_pause_timer.start(200, 1)
 938                 else:
 939                         print "unpause"
 940                         self.unPauseService()
 941
 942         def __seekableStatusChanged(self):
 943                 enabled = False
 944
 945                 print "self.isSeekable", self.isSeekable()
 946                 print "self.timeshift_enabled", self.timeshift_enabled
 947
 948                 # when this service is not seekable, but timeshift
 949                 # is enabled, this means we can activate
 950                 # the timeshift
 951                 if not self.isSeekable() and self.timeshift_enabled:
 952                         enabled = True
 953
 954                 print "timeshift activate:", enabled
 955                 self["TimeshiftActivateActions"].setEnabled(enabled)
 956
 957         def __serviceStarted(self):
 958                 self.timeshift_enabled = False
 959                 self.__seekableStatusChanged()
 960
 961 class InfoBarExtensions:
 962         def __init__(self):
 963                 self.pipshown = False
 964
 965                 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
 966                         {
 967                                 "extensions": (self.extensions, "Extensions..."),
 968                         })
 969
 970         def extensions(self):
 971                 list = []
 972                 if self.pipshown == False:
 973                         list.append((_("Activate Picture in Picture"), "pipon"))
 974                 elif self.pipshown == True:
 975                         list.append((_("Disable Picture in Picture"), "pipoff"))
 976                 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list)
 977
 978         def extensionCallback(self, answer):
 979                 if answer[1] == "pipon":
 980                         self.pip = self.session.instantiateDialog(PictureInPicture)
 981                         self.pip.show()
 982                         self.pipshown = True
 983                         print "would show PiP now"
 984                 elif answer[1] == "pipoff":
 985                         self.pip.hide()
 986                         del self.pip
 987                         self.pipshown = False
 988
 989 from RecordTimer import parseEvent
 990
 991 class InfoBarInstantRecord:
 992         """Instant Record - handles the instantRecord action in order to
 993         start/stop instant records"""
 994         def __init__(self):
 995                 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
 996                         {
 997                                 "instantRecord": (self.instantRecord, "Instant Record..."),
 998                         })
 999                 self.recording = []
1000                 self["BlinkingPoint"] = BlinkingPixmapConditional()
1001                 self["BlinkingPoint"].hide()
1002                 self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
1003
1004         def stopCurrentRecording(self, entry = -1):
1005                 if entry is not None and entry != -1:
1006                         self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1007                         self.recording.remove(self.recording[entry])
1008
1009         def startInstantRecording(self, limitEvent = False):
1010                 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1011
1012                 # try to get event info
1013                 event = None
1014                 try:
1015                         service = self.session.nav.getCurrentService()
1016                         epg = eEPGCache.getInstance()
1017                         event = epg.lookupEventTime(serviceref, -1, 0)
1018                         if event is None:
1019                                 info = service.info()
1020                                 ev = info.getEvent(0)
1021                                 event = ev
1022                 except:
1023                         pass
1024
1025                 begin = time.time()
1026                 end = time.time() + 3600 * 10
1027                 name = "instant record"
1028                 description = ""
1029                 eventid = None
1030
1031                 if event is not None:
1032                         curEvent = parseEvent(event)
1033                         name = curEvent[2]
1034                         description = curEvent[3]
1035                         eventid = curEvent[4]
1036                         if limitEvent:
1037                                 end = curEvent[1]
1038                 else:
1039                         if limitEvent:
1040                                 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1041
1042                 data = (begin, end, name, description, eventid)
1043
1044                 recording = self.session.nav.recordWithTimer(serviceref, *data)
1045                 recording.dontSave = True
1046                 self.recording.append(recording)
1047
1048                 #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
1049
1050         def isInstantRecordRunning(self):
1051                 print "self.recording:", self.recording
1052                 if len(self.recording) > 0:
1053                         for x in self.recording:
1054                                 if x.isRunning():
1055                                         return True
1056                 return False
1057
1058         def recordQuestionCallback(self, answer):
1059                 if answer is None or answer[1] == "no":
1060                         return
1061                 list = []
1062                 for x in self.recording:
1063                         if x.dontSave:
1064                                 list.append(TimerEntryComponent(x, False))
1065
1066                 if answer[1] == "changeduration":
1067                         if len(self.recording) == 1:
1068                                 self.changeDuration(0)
1069                         else:
1070                                 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1071                 elif answer[1] == "stop":
1072                         if len(self.recording) == 1:
1073                                 self.stopCurrentRecording(0)
1074                         else:
1075                                 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1076                 if answer[1] == "indefinitely" or answer[1] == "manualduration" or answer[1] == "event":
1077                         limitEvent = False
1078                         if answer[1] == "event":
1079                                 limitEvent = True
1080                         if answer[1] == "manualduration":
1081                                 self.selectedEntry = len(self.recording)
1082                                 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1083                         self.startInstantRecording(limitEvent = limitEvent)
1084
1085         def changeDuration(self, entry):
1086                 if entry is not None:
1087                         self.selectedEntry = entry
1088                         self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1089
1090         def inputCallback(self, value):
1091                 if value is not None:
1092                         print "stopping recording after", int(value), "minutes."
1093                         self.recording[self.selectedEntry].end = time.time() + 60 * int(value)
1094                         self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1095
1096         def instantRecord(self):
1097                 try:
1098                         stat = os.stat(resolveFilename(SCOPE_HDD))
1099                 except:
1100                         self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1101                         return
1102
1103                 if self.isInstantRecordRunning():
1104                         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")])
1105                 else:
1106                         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")])
1107
1108 from Screens.AudioSelection import AudioSelection
1109
1110 class InfoBarAudioSelection:
1111         def __init__(self):
1112                 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1113                         {
1114                                 "audioSelection": (self.audioSelection, "Audio Options..."),
1115                         })
1116
1117         def audioSelection(self):
1118                 service = self.session.nav.getCurrentService()
1119                 audio = service.audioTracks()
1120                 n = audio.getNumberOfTracks()
1121                 if n > 0:
1122                         self.session.open(AudioSelection, audio)
1123
1124 from Screens.SubserviceSelection import SubserviceSelection
1125
1126 class InfoBarSubserviceSelection:
1127         def __init__(self):
1128                 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1129                         {
1130                                 "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
1131                         })
1132
1133         def subserviceSelection(self):
1134                 service = self.session.nav.getCurrentService()
1135                 subservices = service.subServices()
1136                 n = subservices.getNumberOfSubservices()
1137                 if n > 0:
1138                         self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
1139
1140         def subserviceSelected(self, service):
1141                 if not service is None:
1142                         self.session.nav.playService(service)
1143
1144 class InfoBarAdditionalInfo:
1145         def __init__(self):
1146                 self["DolbyActive"] = Pixmap()
1147                 self["CryptActive"] = Pixmap()
1148                 self["FormatActive"] = Pixmap()
1149
1150                 self["ButtonRed"] = PixmapConditional(withTimer = False)
1151                 self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
1152                 self.onLayoutFinish.append(self["ButtonRed"].update)
1153                 self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False)
1154                 self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
1155                 self.onLayoutFinish.append(self["ButtonRedText"].update)
1156
1157                 self["ButtonGreen"] = Pixmap()
1158                 self["ButtonGreenText"] = Label(_("Subservices"))
1159
1160                 self["ButtonYellow"] = PixmapConditional(withTimer = False)
1161                 self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
1162                 self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False)
1163                 self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
1164                 self.onLayoutFinish.append(self["ButtonYellow"].update)
1165                 self.onLayoutFinish.append(self["ButtonYellowText"].update)
1166
1167                 self["ButtonBlue"] = PixmapConditional(withTimer = False)
1168                 self["ButtonBlue"].setConnect(lambda: True)
1169                 self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
1170                 self["ButtonBlueText"].setConnect(lambda: True)
1171                 self.onLayoutFinish.append(self["ButtonBlue"].update)
1172                 self.onLayoutFinish.append(self["ButtonBlueText"].update)
1173
1174                 self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
1175
1176         def hideSubServiceIndication(self):
1177                 self["ButtonGreen"].hide()
1178                 self["ButtonGreenText"].hide()
1179
1180         def showSubServiceIndication(self):
1181                 self["ButtonGreen"].show()
1182                 self["ButtonGreenText"].show()
1183
1184         def checkFormat(self, service):
1185                 info = service.info()
1186                 if info is not None:
1187                         aspect = info.getInfo(iServiceInformation.sAspect)
1188                         if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]:
1189                                 self["FormatActive"].show()
1190                         else:
1191                                 self["FormatActive"].hide()
1192
1193         def checkSubservices(self, service):
1194                 if service.subServices().getNumberOfSubservices() > 0:
1195                         self.showSubServiceIndication()
1196                 else:
1197                         self.hideSubServiceIndication()
1198
1199         def checkDolby(self, service):
1200                 # FIXME
1201                 dolby = False
1202                 audio = service.audioTracks()
1203                 if audio is not None:
1204                         n = audio.getNumberOfTracks()
1205                         for x in range(n):
1206                                 i = audio.getTrackInfo(x)
1207                                 description = i.getDescription();
1208                                 if description.find("AC3") != -1 or description.find("DTS") != -1:
1209                                         dolby = True
1210                                         break
1211                 if dolby:
1212                         self["DolbyActive"].show()
1213                 else:
1214                         self["DolbyActive"].hide()
1215
1216         def checkCrypted(self, service):
1217                 info = service.info()
1218                 if info is not None:
1219                         if info.getInfo(iServiceInformation.sIsCrypted) > 0:
1220                                 self["CryptActive"].show()
1221                         else:
1222                                 self["CryptActive"].hide()
1223
1224         def gotServiceEvent(self, ev):
1225                 service = self.session.nav.getCurrentService()
1226                 if ev == iPlayableService.evUpdatedEventInfo:
1227                         self.checkSubservices(service)
1228                         self.checkFormat(service)
1229                 elif ev == iPlayableService.evUpdatedInfo:
1230                         self.checkCrypted(service)
1231                         self.checkDolby(service)
1232                 elif ev == iPlayableService.evEnd:
1233                         self.hideSubServiceIndication()
1234                         self["CryptActive"].hide()
1235                         self["DolbyActive"].hide()
1236                         self["FormatActive"].hide()
1237
1238 class InfoBarNotifications:
1239         def __init__(self):
1240                 self.onExecBegin.append(self.checkNotifications)
1241                 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1242
1243         def checkNotificationsIfExecing(self):
1244                 if self.execing:
1245                         self.checkNotifications()
1246
1247         def checkNotifications(self):
1248                 if len(Notifications.notifications):
1249                         n = Notifications.notifications[0]
1250                         Notifications.notifications = Notifications.notifications[1:]
1251                         print "open",n
1252                         cb = n[0]
1253                         if cb is not None:
1254                                 self.session.openWithCallback(cb, *n[1:])
1255                         else:
1256                                 self.session.open(*n[1:])
1257
1258 class InfoBarServiceNotifications:
1259         def __init__(self):
1260                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1261                         {
1262                                 iPlayableService.evEnd: self.serviceHasEnded
1263                         })
1264
1265         def serviceHasEnded(self):
1266                 print "service end!"
1267
1268                 try:
1269                         self.setSeekState(self.SEEK_STATE_PLAY)
1270                 except:
1271                         pass
1272
1273 class InfoBarCueSheetSupport:
1274         CUT_TYPE_IN = 0
1275         CUT_TYPE_OUT = 1
1276         CUT_TYPE_MARK = 2
1277
1278         def __init__(self):
1279                 self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions",
1280                         {
1281                                 "jumpPreviousMark": (self.jumpPreviousMark, "jump to next marked position"),
1282                                 "jumpNextMark": (self.jumpNextMark, "jump to previous marked position"),
1283                                 "toggleMark": (self.toggleMark, "toggle a cut mark at the current position")
1284                         }, prio=1)
1285
1286                 self.cut_list = [ ]
1287                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1288                         {
1289                                 iPlayableService.evStart: self.__serviceStarted,
1290                         })
1291
1292         def __serviceStarted(self):
1293                 print "new service started! trying to download cuts!"
1294                 self.downloadCuesheet()
1295
1296         def __getSeekable(self):
1297                 service = self.session.nav.getCurrentService()
1298                 if service is None:
1299                         return None
1300                 return service.seek()
1301
1302         def cueGetCurrentPosition(self):
1303                 seek = self.__getSeekable()
1304                 if seek is None:
1305                         return None
1306                 r = seek.getPlayPosition()
1307                 if r[0]:
1308                         return None
1309                 return long(r[1])
1310
1311         def jumpPreviousNextMark(self, cmp, alternative=None):
1312                 current_pos = self.cueGetCurrentPosition()
1313                 if current_pos is None:
1314                         return
1315                 mark = self.getNearestCutPoint(current_pos, cmp=cmp)
1316                 if mark is not None:
1317                         pts = mark[0]
1318                 elif alternative is not None:
1319                         pts = alternative
1320                 else:
1321                         return
1322
1323                 seekable = self.__getSeekable()
1324                 if seekable is not None:
1325                         seekable.seekTo(pts)
1326
1327         def jumpPreviousMark(self):
1328                 # we add 2 seconds, so if the play position is <2s after
1329                 # the mark, the mark before will be used
1330                 self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0)
1331
1332         def jumpNextMark(self):
1333                 self.jumpPreviousNextMark(lambda x: x)
1334
1335         def getNearestCutPoint(self, pts, cmp=abs):
1336                 # can be optimized
1337                 nearest = None
1338                 for cp in self.cut_list:
1339                         diff = cmp(cp[0] - pts)
1340                         if diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
1341                                 nearest = cp
1342                 return nearest
1343
1344         def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
1345                 current_pos = self.cueGetCurrentPosition()
1346                 if current_pos is None:
1347                         print "not seekable"
1348                         return
1349
1350                 nearest_cutpoint = self.getNearestCutPoint(current_pos)
1351
1352                 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
1353                         if onlyreturn:
1354                                 return nearest_cutpoint
1355                         if not onlyadd:
1356                                 self.removeMark(nearest_cutpoint)
1357                 elif not onlyremove and not onlyreturn:
1358                         self.addMark((current_pos, self.CUT_TYPE_MARK))
1359
1360                 if onlyreturn:
1361                         return None
1362
1363         def addMark(self, point):
1364                 bisect.insort(self.cut_list, point)
1365                 self.uploadCuesheet()
1366
1367         def removeMark(self, point):
1368                 self.cut_list.remove(point)
1369                 self.uploadCuesheet()
1370
1371         def __getCuesheet(self):
1372                 service = self.session.nav.getCurrentService()
1373                 if service is None:
1374                         return None
1375                 return service.cueSheet()
1376
1377         def uploadCuesheet(self):
1378                 cue = self.__getCuesheet()
1379
1380                 if cue is None:
1381                         print "upload failed, no cuesheet interface"
1382                         return
1383                 cue.setCutList(self.cut_list)
1384
1385         def downloadCuesheet(self):
1386                 cue = self.__getCuesheet()
1387
1388                 if cue is None:
1389                         print "upload failed, no cuesheet interface"
1390                         return
1391                 self.cut_list = cue.getCutList()
1392
1393 class InfoBarSummary(Screen):
1394         skin = """
1395         <screen position="0,0" size="132,64">
1396                 <widget name="Clock" position="50,46" size="82,18" font="Regular;16" />
1397                 <widget name="CurrentService" position="0,4" size="132,42" font="Regular;18" />
1398         </screen>"""
1399
1400         def __init__(self, session, parent):
1401                 Screen.__init__(self, session)
1402                 self["CurrentService"] = ServiceName(self.session.nav)
1403                 self["Clock"] = Clock()
1404
1405 class InfoBarSummarySupport:
1406         def __init__(self):
1407                 pass
1408
1409         def createSummary(self):
1410                 return InfoBarSummary
1411
1412 class InfoBarTeletextPlugin:
1413         def __init__(self):
1414                 self.teletext_plugin = None
1415
1416                 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
1417                         self.teletext_plugin = p
1418
1419                 if self.teletext_plugin is not None:
1420                         self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
1421                                 {
1422                                         "startTeletext": (self.startTeletext, "View teletext...")
1423                                 })
1424                 else:
1425                         print "no teletext plugin found!"
1426
1427         def startTeletext(self):
1428                 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())