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

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index f8ac8fda..f1267afa 100644
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -5,26 +5,27 @@ from Components.Label import *
 from Components.ProgressBar import *
 from Components.config import configfile, configsequencearg
 from Components.config import config, configElement, ConfigSubsection, configSequence
-from ChannelSelection import ChannelSelection
+from ChannelSelection import ChannelSelection, BouquetSelector
 
 from Components.Pixmap import Pixmap, PixmapConditional
 from Components.BlinkingPixmap import BlinkingPixmapConditional
 from Components.ServiceName import ServiceName
-from Components.EventInfo import EventInfo
+from Components.EventInfo import EventInfo, EventInfoProgress
 
 from ServiceReference import ServiceReference
 from EpgSelection import EPGSelection
 
 from Screens.MessageBox import MessageBox
-from Screens.Volume import Volume
-from Screens.Mute import Mute
 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 *
 
 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
 from enigma import *
@@ -32,71 +33,15 @@ from enigma import *
 import time
 import os
 
+from Components.config import config, currentConfigSelectionElement
+
 # hack alert!
 from Menu import MainMenu, mdom
 
-class InfoBarVolumeControl:
-	"""Volume control, handles volUp, volDown, volMute actions and display 
-	a corresponding dialog"""
-	def __init__(self):
-		config.audio = ConfigSubsection()
-		config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
-
-		self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
-			{
-				"volumeUp": self.volUp,
-				"volumeDown": self.volDown,
-				"volumeMute": self.volMute,
-			})
-
-		self.volumeDialog = self.session.instantiateDialog(Volume)
-		self.muteDialog = self.session.instantiateDialog(Mute)
-
-		self.hideVolTimer = eTimer()
-		self.hideVolTimer.timeout.get().append(self.volHide)
-
-		vol = config.audio.volume.value[0]
-		self.volumeDialog.setValue(vol)
-		eDVBVolumecontrol.getInstance().setVolume(vol, vol)
-	
-	def volSave(self):
-		config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
-		config.audio.volume.save()
-		
-	def	volUp(self):
-		if (eDVBVolumecontrol.getInstance().isMuted()):
-			self.volMute()
-		eDVBVolumecontrol.getInstance().volumeUp()
-		self.volumeDialog.instance.show()
-		self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
-		self.volSave()
-		self.hideVolTimer.start(3000, True)
-
-	def	volDown(self):
-		if (eDVBVolumecontrol.getInstance().isMuted()):
-			self.volMute()
-		eDVBVolumecontrol.getInstance().volumeDown()
-		self.volumeDialog.instance.show()
-		self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
-		self.volSave()
-		self.hideVolTimer.start(3000, True)
-		
-	def volHide(self):
-		self.volumeDialog.instance.hide()
-
-	def	volMute(self):
-		eDVBVolumecontrol.getInstance().volumeToggleMute()
-		self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
-		
-		if (eDVBVolumecontrol.getInstance().isMuted()):
-			self.muteDialog.instance.show()
-		else:
-			self.muteDialog.instance.hide()
-
 class InfoBarDish:
 	def __init__(self):
 		self.dishDialog = self.session.instantiateDialog(Dish)
-		self.onShown.append(self.dishDialog.instance.hide)
+		self.onShown.append(self.dishDialog.show)
 
 class InfoBarShowHide:
 	""" InfoBar show/hide control, accepts toggleShow and hide actions, might start
@@ -113,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):
@@ -239,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,
@@ -256,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)
@@ -291,17 +245,20 @@ class InfoBarNumberZap:
 			bouquetlist = serviceHandler.list(bouquet)
 			if not bouquetlist is None:
 				while number:
-					bouquet = bouquetlist.getNext()
+					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 
@@ -317,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):
@@ -357,32 +312,81 @@ class InfoBarEPG:
 	def __init__(self):
 		self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
 			{
-				"showEPGList": (self.showEPGList, _("show EPG...")),
+				"showEventInfo": (self.openEventView, _("show EPG...")),
 			})
 
-	def showEPGList(self):
+	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 = [ ]
+		servicelist = eServiceCenter.getInstance().list(bouquet)
+		if not servicelist is None:
+			while True:
+				service = servicelist.getNext()
+				if not service.valid(): #check if end of list
+					break
+				if service.flags: #ignore non playable services
+					continue
+				services.append(ServiceReference(service))
+		if len(services):
+			self.epg_bouquet = bouquet
+			self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService)
+
+	def closed(self, ret):
+		if ret:
+			self.close(ret)
+
+	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, val): #used for now/next displaying
+	def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 		if len(self.epglist) > 1:
 			tmp = self.epglist[0]
 			self.epglist[0]=self.epglist[1]
@@ -445,34 +449,44 @@ class InfoBarEvent:
 		self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
 		self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
 
+		self["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now)
+
 class InfoBarServiceName:
 	def __init__(self):
 		self["ServiceName"] = ServiceName(self.session.nav)
 
-class InfoBarPVR:
-
-	# 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)
+class InfoBarSeek:
+	"""handles actions like seeking, pause"""
 	
-	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)
+	# 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_SM_HALF = (0, 0, 2, 0)
-	SEEK_STATE_SM_QUARTER = (0, 0, 4, 0)
-	SEEK_STATE_SM_EIGHTH = (0, 0, 8, 0)
+	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, "/2")
+	SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4")
+	SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8")
 	
-	"""handles PVR specific actions like seeking, pause"""
 	def __init__(self):
-		self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions", 
+		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"),
 				"unPauseService": (self.unPauseService, "continue"),
@@ -481,16 +495,11 @@ class InfoBarPVR:
 				"seekFwdUp": (self.seekFwdUp, "skip forward"),
 				"seekBack": (self.seekBack, "skip backward"),
 				"seekBackUp": (self.seekBackUp, "skip backward"),
-							 
-				"up": (self.showMovies, "movie list"),
-				"down": (self.showMovies, "movie list")
-			})
+			}, 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()
@@ -499,6 +508,10 @@ class InfoBarPVR:
 		self.rwdtimer = False
 		self.rwdKeyTimer = eTimer()
 		self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
+		
+		self.onPlayStateChanged = [ ]
+		
+		self.lockedBecauseOfSkipping = False
 	
 	def up(self):
 		pass
@@ -506,66 +519,80 @@ class InfoBarPVR:
 	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
@@ -586,6 +613,7 @@ class InfoBarPVR:
 		self.rwdKeyTimer.start(500)
 
 	def seekFwdUp(self):
+		print "seekFwdUp"
 		if self.fwdtimer:
 			self.fwdKeyTimer.stop()
 			self.fwdtimer = False
@@ -609,6 +637,7 @@ class InfoBarPVR:
 			self.setSeekState(lookup[self.seekstate]);
 	
 	def seekBackUp(self):
+		print "seekBackUp"
 		if self.rwdtimer:
 			self.rwdKeyTimer.stop()
 			self.rwdtimer = False
@@ -640,21 +669,211 @@ class InfoBarPVR:
 		
 	def fwdSeekTo(self, minutes):
 		print "Seek", minutes, "minutes forward"
-		service = self.session.nav.getCurrentService()
-		if service is None:
-			return
-		seekable = service.seek()
-		if seekable is None:
-			return
-		seekable.seekRelative(1, minutes * 60 * 90000)
+		if minutes != 0:
+			service = self.session.nav.getCurrentService()
+			if service is None:
+				return
+			seekable = service.seek()
+			if seekable is None:
+				return
+			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 more than an action map
+	def __init__(self):
+		self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", 
+			{
+				"movieList": (self.showMovies, "movie list"),
+				"up": (self.showMovies, "movie list"),
+				"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"),  # 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
+			})
+	
+	def getTimeshift(self):
+		service = self.session.nav.getCurrentService()
+		return service.timeshift()
+
+	def startTimeshift(self):
+		# TODO: check for harddisk! (or do this in the interface? would make
+		# more sense... for example radio could be timeshifted in memory,
+		# and the decision can't be made here)
+		print "enable timeshift"
+		ts = self.getTimeshift()
+		if ts is None:
+			self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
+			print "no ts interface"
+			return
+		
+		if self.timeshift_enabled:
+			print "hu, timeshift already enabled?"
+		else:
+			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.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
 
@@ -691,7 +910,17 @@ class InfoBarInstantRecord:
 		
 		if event is not None:
 			data = parseEvent(event)
-			data = (data[0], data[1] + 3600 * 10, data[2], data[3], data[4])
+			begin = data[0]
+			if begin < time.time():
+				begin = time.time()
+			
+			end = data[1]
+			if end < begin:
+				end = begin
+			
+			end += 3600 * 10
+			
+			data = (begin, end, data[2], data[3], data[4])
 		else:
 			data = (time.time(), time.time() + 3600 * 10, "instant record", "", None)
 		
@@ -718,9 +947,9 @@ class InfoBarInstantRecord:
 
 	def instantRecord(self):
 		try:
-			stat = os.stat("/hdd/movies")
+			stat = os.stat(resolveFilename(SCOPE_HDD))
 		except:
-			self.session.open(MessageBox, "No HDD found!", MessageBox.TYPE_ERROR)
+			self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
 			return
 	
 		if self.isInstantRecordRunning():
@@ -812,6 +1041,7 @@ class InfoBarAdditionalInfo:
 			self.hideSubServiceIndication()
 
 	def checkDolby(self, service):
+		# FIXME
 		dolby = False
 		audio = service.audioTracks()
 		if audio is not None:
@@ -837,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()
@@ -868,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