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