X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/124d18766f09faf0209eeb052c8c8a865e672eb3..0ee61341634a64b426a5934065e43fdade81971d:/lib/python/Screens/InfoBarGenerics.py

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index fc19c806..f1267afa 100644
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -18,10 +18,12 @@ from EpgSelection import EPGSelection
 from Screens.MessageBox import MessageBox
 from Screens.Dish import Dish
 from Screens.Standby import Standby
-from Screens.EventView import EventView
+from Screens.EventView import EventViewEPGSelect
 from Screens.MinuteInput import MinuteInput
 from Components.Harddisk import harddiskmanager
 
+from Components.ServiceEventTracker import ServiceEventTracker
+
 from Tools import Notifications
 from Tools.Directories import *
 
@@ -39,7 +41,7 @@ from Menu import MainMenu, mdom
 class InfoBarDish:
 	def __init__(self):
 		self.dishDialog = self.session.instantiateDialog(Dish)
-		self.onShown.append(self.dishDialog.instance.show)
+		self.onShown.append(self.dishDialog.show)
 
 class InfoBarShowHide:
 	""" InfoBar show/hide control, accepts toggleShow and hide actions, might start
@@ -56,49 +58,59 @@ class InfoBarShowHide:
 				"hide": self.hide,
 			})
 
-		self.state = self.STATE_SHOWN
+		self.__state = self.STATE_SHOWN
+		self.__locked = 0
 		
 		self.onExecBegin.append(self.show)
-		self.onClose.append(self.delHideTimer)
 		
 		self.hideTimer = eTimer()
 		self.hideTimer.timeout.get().append(self.doTimerHide)
 		self.hideTimer.start(5000, True)
+		
+		self.onShow.append(self.__onShow)
+		self.onHide.append(self.__onHide)
 
-	def delHideTimer(self):
-		del self.hideTimer
+	def __onShow(self):
+		self.__state = self.STATE_SHOWN
+		self.startHideTimer()
+	
+	def startHideTimer(self):
+		if self.__state == self.STATE_SHOWN and not self.__locked:
+			self.hideTimer.start(5000, True)
 
-	def hide(self):	
-		self.instance.hide()
-		
-	def show(self):
-		self.state = self.STATE_SHOWN
-		self.hideTimer.start(5000, True)
+	def __onHide(self):
+		self.__state = self.STATE_HIDDEN
 
 	def doTimerHide(self):
 		self.hideTimer.stop()
-		if self.state == self.STATE_SHOWN:
-			self.instance.hide()
-			self.state = self.STATE_HIDDEN
+		if self.__state == self.STATE_SHOWN:
+			self.hide()
 
 	def toggleShow(self):
-		if self.state == self.STATE_SHOWN:
-			self.instance.hide()
-			#pls check animation support, sorry
-#			self.startHide()
+		if self.__state == self.STATE_SHOWN:
+			self.hide()
 			self.hideTimer.stop()
-			self.state = self.STATE_HIDDEN
-		elif self.state == self.STATE_HIDDEN:
-			self.instance.show()
+		elif self.__state == self.STATE_HIDDEN:
 			self.show()
-			
-	def startShow(self):
-		self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
-		self.state = self.STATE_SHOWN
+
+	def lockShow(self):
+		self.__locked = self.__locked + 1
+		if self.execing:
+			self.show()
+			self.hideTimer.stop()
 	
-	def startHide(self):
-		self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
-		self.state = self.STATE_HIDDEN
+	def unlockShow(self):
+		self.__locked = self.__locked - 1
+		if self.execing:
+			self.startHideTimer()
+
+#	def startShow(self):
+#		self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
+#		self.__state = self.STATE_SHOWN
+#	
+#	def startHide(self):
+#		self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
+#		self.__state = self.STATE_HIDDEN
 
 class NumberZap(Screen):
 	def quit(self):
@@ -182,7 +194,7 @@ class InfoBarPowerKey:
 class InfoBarNumberZap:
 	""" Handles an initial number for NumberZapping """
 	def __init__(self):
-		self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
+		self["NumberActions"] = NumberActionMap( [ "NumberActions"],
 			{
 				"1": self.keyNumberGlobal,
 				"2": self.keyNumberGlobal,
@@ -199,8 +211,7 @@ class InfoBarNumberZap:
 	def keyNumberGlobal(self, number):
 #		print "You pressed number " + str(number)
 		if number == 0:
-			self.session.nav.zapLast()
-			self.instance.show()
+			self.servicelist.recallPrevService()
 			self.show()
 		else:
 			self.session.openWithCallback(self.numberEntered, NumberZap, number)
@@ -237,14 +248,17 @@ class InfoBarNumberZap:
 					bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext())
 					if not bouquet.valid(): #check end of list
 						break
-					if ((bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
+					if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
 						continue
 					service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
 		if not service is None:
-			self.session.nav.playService(service) #play service
 			if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
-				self.servicelist.setRoot(bouquet)
+				self.servicelist.clearPath()
+				if self.servicelist.bouquet_root != bouquet:
+					self.servicelist.enterPath(self.servicelist.bouquet_root)
+				self.servicelist.enterPath(bouquet)
 			self.servicelist.setCurrentSelection(service) #select the service in servicelist
+			self.servicelist.zap()
 
 class InfoBarChannelSelection:
 	""" ChannelSelection - handles the channelSelection dialog and the initial 
@@ -260,27 +274,25 @@ class InfoBarChannelSelection:
 				"zapUp": (self.zapUp, _("next channel")),
 				"zapDown": (self.zapDown, _("previous channel")),
 			})
-			
-	def switchChannelUp(self):	
+
+	def switchChannelUp(self):
 		self.servicelist.moveUp()
 		self.session.execDialog(self.servicelist)
 
-	def switchChannelDown(self):	
+	def switchChannelDown(self):
 		self.servicelist.moveDown()
 		self.session.execDialog(self.servicelist)
 
 	def	zapUp(self):
 		self.servicelist.moveUp()
 		self.servicelist.zap()
-		self.instance.show()
 		self.show()
 
 	def	zapDown(self):
 		self.servicelist.moveDown()
 		self.servicelist.zap()
-		self.instance.show()
 		self.show()
-		
+
 class InfoBarMenu:
 	""" Handles a menu action, to open the (main) menu """
 	def __init__(self):
@@ -300,61 +312,19 @@ class InfoBarEPG:
 	def __init__(self):
 		self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
 			{
-				"showEPGList": (self.showEPG, _("show EPG...")),
+				"showEventInfo": (self.openEventView, _("show EPG...")),
 			})
 
-	def showEPG(self):
-		if currentConfigSelectionElement(config.usage.epgtoggle) == "yes":
-			self.openSingleServiceEPG()
-		else:
-			self.showEPGList()
-
-	def showEPGList(self):
-		bouquets = self.servicelist.getBouquetList()
-		if bouquets is None:
-			cnt = 0
-		else:
-			cnt = len(bouquets)
-		if cnt > 1: # show bouquet list
-			self.session.open(BouquetSelector, bouquets, self.openBouquetEPG)
-		elif cnt == 1: # add to only one existing bouquet
-			self.openBouquetEPG(bouquets[0][1])
-		else: #no bouquets so we open single epg
-			self.openSingleEPGSelector(self.session.nav.getCurrentlyPlayingServiceReference())
-
-	def bouquetEPGCallback(self, info):
-		if info:
-			self.openSingleServiceEPG()
-	
-	def singleEPGCallback(self, info):
-		if info:
-			self.showEPGList()
-			
-	def openEventView(self):
-		try:
-			self.epglist = [ ]
-			service = self.session.nav.getCurrentService()
-			info = service.info()
-			ptr=info.getEvent(0)
-			if ptr:
-				self.epglist.append(ptr)
-			ptr=info.getEvent(1)
-			if ptr:
-				self.epglist.append(ptr)
-			if len(self.epglist) > 0:
-				self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
-		except:
-			pass
-			
-	def openSingleServiceEPG(self):
-		ref=self.session.nav.getCurrentlyPlayingServiceReference()
-		ptr=eEPGCache.getInstance()
-		if ptr.startTimeQuery(ref) != -1:
-			self.session.openWithCallback(self.singleEPGCallback, EPGSelection, ref)
-		else: # try to show now/next
-			print 'no epg for service', ref.toString()
+	def zapToService(self, service):
+		if not service is None:
+			if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
+				self.servicelist.clearPath()
+				if self.servicelist.bouquet_root != self.epg_bouquet:
+					self.servicelist.enterPath(self.servicelist.bouquet_root)
+				self.servicelist.enterPath(self.epg_bouquet)
+			self.servicelist.setCurrentSelection(service) #select the service in servicelist
+			self.servicelist.zap()
 
-	
 	def openBouquetEPG(self, bouquet):
 		ptr=eEPGCache.getInstance()
 		services = [ ]
@@ -368,28 +338,53 @@ class InfoBarEPG:
 					continue
 				services.append(ServiceReference(service))
 		if len(services):
-			self.session.openWithCallback(self.bouquetEPGCallback, EPGSelection, services)
+			self.epg_bouquet = bouquet
+			self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService)
+
+	def closed(self, ret):
+		if ret:
+			self.close(ret)
 
-	def openSingleEPGSelector(self, ref):
+	def openMultiServiceEPG(self):
+		bouquets = self.servicelist.getBouquetList()
+		if bouquets is None:
+			cnt = 0
+		else:
+			cnt = len(bouquets)
+		if cnt > 1: # show bouquet list
+			self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG)
+		elif cnt == 1: 
+			self.openBouquetEPG(bouquets[0][1])
+
+	def openSingleServiceEPG(self):
+		ref=self.session.nav.getCurrentlyPlayingServiceReference()
 		ptr=eEPGCache.getInstance()
-		if ptr.startTimeQuery(ref) != -1:
-			self.session.open(EPGSelection, ref)
-		else: # try to show now/next
-			print 'no epg for service', ref.toString()
-			try:
-				self.epglist = [ ]
-				service = self.session.nav.getCurrentService()
-				info = service.info()
-				ptr=info.getEvent(0)
-				if ptr:
-					self.epglist.append(ptr)
-				ptr=info.getEvent(1)
+		self.session.openWithCallback(self.closed, EPGSelection, ref)
+
+	def openEventView(self):
+		self.epglist = [ ]
+		service = self.session.nav.getCurrentService()
+		ref = self.session.nav.getCurrentlyPlayingServiceReference()
+		info = service.info()
+		ptr=info.getEvent(0)
+		if ptr:
+			self.epglist.append(ptr)
+		ptr=info.getEvent(1)
+		if ptr:
+			self.epglist.append(ptr)
+		if len(self.epglist) == 0:
+			epg = eEPGCache.getInstance()
+			ptr = epg.lookupEventTime(ref, -1)
+			if ptr:
+				self.epglist.append(ptr)
+				ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
 				if ptr:
 					self.epglist.append(ptr)
-				if len(self.epglist) > 0:
-					self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
-			except:
-				pass
+		if len(self.epglist) > 0:
+			self.session.open(EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG)
+		else:
+			print "no epg for the service avail.. so we show multiepg instead of eventinfo"
+			self.openMultiServiceEPG()
 
 	def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 		if len(self.epglist) > 1:
@@ -463,26 +458,34 @@ class InfoBarServiceName:
 class InfoBarSeek:
 	"""handles actions like seeking, pause"""
 	
-	# ispause, isff, issm, skip
-	SEEK_STATE_PLAY = (0, 0, 0, 0)
-	SEEK_STATE_PAUSE = (1, 0, 0, 0)
-	SEEK_STATE_FF_2X = (0, 2, 0, 0)
-	SEEK_STATE_FF_4X = (0, 4, 0, 0)
-	SEEK_STATE_FF_8X = (0, 8, 0, 0)
-	SEEK_STATE_FF_32X = (0, 4, 0, 32)
-	SEEK_STATE_FF_64X = (0, 4, 0, 64)
-	SEEK_STATE_FF_128X = (0, 4, 0, 128)
+	# ispause, isff, issm
+	SEEK_STATE_PLAY = (0, 0, 0, ">")
+	SEEK_STATE_PAUSE = (1, 0, 0, "||")
+	SEEK_STATE_FF_2X = (0, 2, 0, ">> 2x")
+	SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x")
+	SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x")
+	SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x")
+	SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x")
+	SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x")
 	
-	SEEK_STATE_BACK_4X = (0, 0, 0, -4)
-	SEEK_STATE_BACK_32X = (0, 0, 0, -32)
-	SEEK_STATE_BACK_64X = (0, 0, 0, -64)
-	SEEK_STATE_BACK_128X = (0, 0, 0, -128)
+	SEEK_STATE_BACK_4X = (0, -4, 0, "<< 4x")
+	SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x")
+	SEEK_STATE_BACK_64X = (0, -64, 0, "<< 64x")
+	SEEK_STATE_BACK_128X = (0, -128, 0, "<< 128x")
 	
-	SEEK_STATE_SM_HALF = (0, 0, 2, 0)
-	SEEK_STATE_SM_QUARTER = (0, 0, 4, 0)
-	SEEK_STATE_SM_EIGHTH = (0, 0, 8, 0)
+	SEEK_STATE_SM_HALF = (0, 0, 2, "/2")
+	SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4")
+	SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8")
 	
 	def __init__(self):
+		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+			{
+				iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
+				iPlayableService.evStart: self.__serviceStarted,
+				
+				iPlayableService.evEOF: self.__evEOF,
+				iPlayableService.evSOF: self.__evSOF,
+			})
 		self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", 
 			{
 				"pauseService": (self.pauseService, "pause"),
@@ -492,13 +495,11 @@ class InfoBarSeek:
 				"seekFwdUp": (self.seekFwdUp, "skip forward"),
 				"seekBack": (self.seekBack, "skip backward"),
 				"seekBackUp": (self.seekBackUp, "skip backward"),
-			})
+			}, prio=-1)
+			# give them a little more priority to win over color buttons
 
 		self.seekstate = self.SEEK_STATE_PLAY
-		self.seekTimer = eTimer()
-		self.seekTimer.timeout.get().append(self.seekTimerFired)
-		self.skipinterval = 500 # 500ms skip interval
-		self.onClose.append(self.delSeekTimer)
+		self.onClose.append(self.delTimer)
 		
 		self.fwdtimer = False
 		self.fwdKeyTimer = eTimer()
@@ -507,6 +508,10 @@ class InfoBarSeek:
 		self.rwdtimer = False
 		self.rwdKeyTimer = eTimer()
 		self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
+		
+		self.onPlayStateChanged = [ ]
+		
+		self.lockedBecauseOfSkipping = False
 	
 	def up(self):
 		pass
@@ -514,66 +519,80 @@ class InfoBarSeek:
 	def down(self):
 		pass
 	
-	def delSeekTimer(self):
-		del self.seekTimer
+	def delTimer(self):
+		del self.fwdKeyTimer
+		del self.rwdKeyTimer
 	
-	def seekTimerFired(self):
-		self.seekbase += self.skipmode * self.skipinterval
-		
-		# check if we bounced against the beginning of the file
-		if self.seekbase < 0:
-			self.seekbase = 0;
+	def isSeekable(self):
+		service = self.session.nav.getCurrentService()
+		if service is None:
+			return False
+		if service.seek() is None:
+			return False
+		else:
+			return True
+
+	def __seekableStatusChanged(self):
+		print "seekable status changed!"
+		if not self.isSeekable():
+			self["SeekActions"].setEnabled(False)
+			print "not seekable, return to play"
 			self.setSeekState(self.SEEK_STATE_PLAY)
-			
-		self.doSeek(self.seekbase)
+		else:
+			self["SeekActions"].setEnabled(True)
+			print "seekable"
 
-	def setSeekState(self, state):
-		oldstate = self.seekstate
-		
-		self.seekstate = state
+	def __serviceStarted(self):
+		self.seekstate = self.SEEK_STATE_PLAY
 
+	def setSeekState(self, state):
 		service = self.session.nav.getCurrentService()
+		
 		if service is None:
-			return
+			return False
 		
-		pauseable = service.pause()
+		if service.seek() is None:
+			if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+				state = self.SEEK_STATE_PLAY
 		
-		for i in range(4):
-			if oldstate[i] != self.seekstate[i]:
-				(self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion, self.setSkipMode)[i](self.seekstate[i])
+		pauseable = service.pause()
+
+		if pauseable is None:
+			print "not pauseable."
+			state = self.SEEK_STATE_PLAY
 		
-	def setSkipMode(self, skipmode):
-		self.skipmode = skipmode
-		if skipmode == 0:
-			self.seekTimer.stop()
-		else:
-			self.seekTimer.start(500)
+		oldstate = self.seekstate
+		self.seekstate = state
 		
-		service = self.session.nav.getCurrentService()
-		if service is None:
-			return
+		for i in range(3):
+			if oldstate[i] != self.seekstate[i]:
+				(self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
+
+		for c in self.onPlayStateChanged:
+			c(self.seekstate)
 		
-		seekable = service.seek()
-		if seekable is None:
-			return
+		self.checkSkipShowHideLock()
 
-		if skipmode:
-			seekable.setTrickmode(1)
-		else:
-			seekable.setTrickmode(0)
+		return True
 		
-		self.seekbase = seekable.getPlayPosition()[1] / 90
-	
 	def pauseService(self):
-		if (self.seekstate == self.SEEK_STATE_PAUSE):
+		if self.seekstate == self.SEEK_STATE_PAUSE:
+			print "pause, but in fact unpause"
 			self.unPauseService()
 		else:
+			if self.seekstate == self.SEEK_STATE_PLAY:
+				print "yes, playing."
+			else:
+				print "no", self.seekstate
+			print "pause"
 			self.setSeekState(self.SEEK_STATE_PAUSE);
 		
 	def unPauseService(self):
+		print "unpause"
 		self.setSeekState(self.SEEK_STATE_PLAY);
 	
 	def doSeek(self, seektime):
+		print "doseek", seektime
 		service = self.session.nav.getCurrentService()
 		if service is None:
 			return
@@ -594,6 +613,7 @@ class InfoBarSeek:
 		self.rwdKeyTimer.start(500)
 
 	def seekFwdUp(self):
+		print "seekFwdUp"
 		if self.fwdtimer:
 			self.fwdKeyTimer.stop()
 			self.fwdtimer = False
@@ -617,6 +637,7 @@ class InfoBarSeek:
 			self.setSeekState(lookup[self.seekstate]);
 	
 	def seekBackUp(self):
+		print "seekBackUp"
 		if self.rwdtimer:
 			self.rwdKeyTimer.stop()
 			self.rwdtimer = False
@@ -658,18 +679,55 @@ class InfoBarSeek:
 			seekable.seekRelative(1, minutes * 60 * 90000)
 	
 	def rwdTimerFire(self):
+		print "rwdTimerFire"
 		self.rwdKeyTimer.stop()
 		self.rwdtimer = False
 		self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
 	
 	def rwdSeekTo(self, minutes):
+		print "rwdSeekTo"
 		self.fwdSeekTo(0 - minutes)
+	
+	def checkSkipShowHideLock(self):
+		wantlock = self.seekstate != self.SEEK_STATE_PLAY
+		
+		if self.lockedBecauseOfSkipping and not wantlock:
+			self.unlockShow()
+			self.lockedBecauseOfSkipping = False
+		
+		if wantlock and not self.lockedBecauseOfSkipping:
+			self.lockShow()
+			self.lockedBecauseOfSkipping = True
+
+	def __evEOF(self):
+		self.setSeekState(self.SEEK_STATE_PAUSE)
+	
+	def __evSOF(self):
+		self.setSeekState(self.SEEK_STATE_PLAY)
+
+from Screens.PVRState import PVRState
+
+class InfoBarPVRState:
+	def __init__(self):
+		self.onPlayStateChanged.append(self.__playStateChanged)
+		self.pvrStateDialog = self.session.instantiateDialog(PVRState)
+		self.onShow.append(self.__mayShow)
+		self.onHide.append(self.pvrStateDialog.hide)
+	
+	def __mayShow(self):
+		if self.seekstate != self.SEEK_STATE_PLAY:
+			self.pvrStateDialog.show()
+
+	def __playStateChanged(self, state):
+		playstateString = state[3]
+		self.pvrStateDialog["state"].setText(playstateString)
+		self.__mayShow()
 
 class InfoBarShowMovies:
 
 	# i don't really like this class. 
 	# it calls a not further specified "movie list" on up/down/movieList,
-	# so this is not moe than an action map
+	# so this is not more than an action map
 	def __init__(self):
 		self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", 
 			{
@@ -678,14 +736,56 @@ class InfoBarShowMovies:
 				"down": (self.showMovies, "movie list")
 			})
 
+# InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
+
+# Hrmf.
+#
+# Timeshift works the following way:
+#                                         demux0   demux1                    "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
+# - normal playback                       TUNER    unused      PLAY               enable                disable              disable
+# - user presses "yellow" button.         TUNER    record      PAUSE              enable                disable              enable
+# - user presess pause again              FILE     record      PLAY               enable                disable              enable
+# - user fast forwards                    FILE     record      FF                 enable                disable              enable
+# - end of timeshift buffer reached       TUNER    record      PLAY               enable                enable               disable
+# - user backwards                        FILE     record      BACK  # !!         enable                disable              enable
+#
+
+# in other words:
+# - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
+# freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
+# now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
+# - the user can now PVR around
+# - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
+# the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
+# after!
+# the seek actions will be disabled, but the timeshiftActivateActions will be enabled
+# - if the user rewinds, or press pause, timeshift will be activated again
+
+# note that a timeshift can be enabled ("recording") and
+# activated (currently time-shifting).
+
 class InfoBarTimeshift:
 	def __init__(self):
 		self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", 
 			{
-				"timeshiftStart": (self.startTimeshift, "start timeshift "),
-				"timeshiftStop": (self.stopTimeshift, "stop timeshift")
+				"timeshiftStart": (self.startTimeshift, "start timeshift"),  # the "yellow key"
+				"timeshiftStop": (self.stopTimeshift, "stop timeshift")      # currently undefined :), probably 'TV'
+			}, prio=1)
+		self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
+			{
+				"timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key"
+				"timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause  # something like "backward key"
+			})
+
+		self.timeshift_enabled = 0
+		self.timeshift_state = 0
+		self.ts_pause_timer = eTimer()
+		self.ts_pause_timer.timeout.get().append(self.pauseService)
+
+		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+			{
+				iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
 			})
-		self.tshack = 0
 	
 	def getTimeshift(self):
 		service = self.session.nav.getCurrentService()
@@ -701,22 +801,79 @@ class InfoBarTimeshift:
 			self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
 			print "no ts interface"
 			return
-		print "ok, timeshift enabled"
-		if self.tshack == 0:
-			ts.startTimeshift()
-			self.tshack = 1
+		
+		if self.timeshift_enabled:
+			print "hu, timeshift already enabled?"
 		else:
-			pauseable = self.session.nav.getCurrentService().pause()
-			pauseable.pause() # switch to record
+			if not ts.startTimeshift():
+				self.timeshift_enabled = 1
+				
+				# PAUSE.
+				self.setSeekState(self.SEEK_STATE_PAUSE)
+				
+				# enable the "TimeshiftEnableActions", which will override
+				# the startTimeshift actions
+				self.__seekableStatusChanged()
+			else:
+				print "timeshift failed"
 
+	# nyi
 	def stopTimeshift(self):
 		print "disable timeshift"
 		ts = self.getTimeshift()
 		if ts is None:
 			return
 		ts.stopTimeshift()
-		self.tshack = 0
+		self.timeshift_enabled = 0
+
+		# disable actions
+		self.__seekableStatusChanged()
+	
+	# activates timeshift, and seeks to (almost) the end
+	def activateTimeshiftEnd(self):
+		ts = self.getTimeshift()
 		
+		if ts is None:
+			return
+		
+		if ts.isTimeshiftActive():
+			print "!! activate timeshift called - but shouldn't this be a normal pause?"
+			self.pauseService()
+		else:
+			self.setSeekState(self.SEEK_STATE_PLAY)
+			ts.activateTimeshift()
+	
+	# same as activateTimeshiftEnd, but pauses afterwards.
+	def activateTimeshiftEndAndPause(self):
+		state = self.seekstate
+		self.activateTimeshiftEnd()
+		
+		# well, this is "andPause", but it could be pressed from pause,
+		# when pausing on the (fake-)"live" picture, so an un-pause
+		# is perfectly ok.
+		
+		print "now, pauseService"
+		if state == self.SEEK_STATE_PLAY:
+			print "is PLAYING, start pause timer"
+			self.ts_pause_timer.start(200, 1)
+		else:
+			print "unpause"
+			self.unPauseService()
+	
+	def __seekableStatusChanged(self):
+		enabled = False
+		
+		print "self.isSeekable", self.isSeekable()
+		print "self.timeshift_enabled", self.timeshift_enabled
+		
+		# when this service is not seekable, but timeshift
+		# is enabled, this means we can activate
+		# the timeshift
+		if not self.isSeekable() and self.timeshift_enabled:
+			enabled = True
+
+		print "timeshift activate:", enabled
+		self["TimeshiftActivateActions"].setEnabled(enabled)
 
 from RecordTimer import parseEvent
 
@@ -910,13 +1067,13 @@ class InfoBarAdditionalInfo:
 
 	def gotServiceEvent(self, ev):
 		service = self.session.nav.getCurrentService()
-		if ev == pNavigation.evUpdatedEventInfo:
+		if ev == iPlayableService.evUpdatedEventInfo:
 			self.checkSubservices(service)
 			self.checkFormat(service)
-		elif ev == pNavigation.evUpdatedInfo:
+		elif ev == iPlayableService.evUpdatedInfo:
 			self.checkCrypted(service)
 			self.checkDolby(service)
-		elif ev == pNavigation.evStopService:
+		elif ev == iPlayableService.evEnd:
 			self.hideSubServiceIndication()
 			self["CryptActive"].hideWidget()
 			self["DolbyActive"].hideWidget()
@@ -941,3 +1098,18 @@ class InfoBarNotifications:
 				self.session.openWithCallback(cb, *n[1:])
 			else:
 				self.session.open(*n[1:])
+
+class InfoBarServiceNotifications:
+	def __init__(self):
+		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+			{
+				iPlayableService.evEnd: self.serviceHasEnded
+			})
+
+	def serviceHasEnded(self):
+		print "service end!"
+
+		try:
+			self.setSeekState(self.SEEK_STATE_PLAY)
+		except:
+			pass