X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/1c0c5016517f081fea23f3db19a4a1d08e5a5feb..d1728d8452421e919faeeadd002a87001a790f5c:/lib/python/Screens/ChannelSelection.py

diff --git a/lib/python/Screens/ChannelSelection.py b/lib/python/Screens/ChannelSelection.py
index d83d3d7a..27c4e209 100644
--- a/lib/python/Screens/ChannelSelection.py
+++ b/lib/python/Screens/ChannelSelection.py
@@ -1,55 +1,95 @@
 from Screen import Screen
 from Components.Button import Button
 from Components.ServiceList import ServiceList
-from Components.ActionMap import ActionMap
+from Components.ActionMap import NumberActionMap
 from EpgSelection import EPGSelection
-from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, eTimer
+from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer
 from Components.config import config, configElement, ConfigSubsection, configText
-
 from Screens.FixedMenu import FixedMenu
+from Tools.NumericalTextInput import NumericalTextInput
 
 import xml.dom.minidom
 
+class BouquetSelector(FixedMenu):
+	def __init__(self, session, bouquets, parent):
+		self.parent=parent
+		entrys = [ ]
+		for x in bouquets:
+			entrys.append((x[0], self.bouquetSelected, x[1]))
+		FixedMenu.__init__(self, session, "Bouquetlist", entrys)
+		self.skinName = "Menu"
+
+	def bouquetSelected(self):
+		self.parent.addCurrentServiceToBouquet(self["menu"].getCurrent()[2])
+		self.close()
+
 class ChannelContextMenu(FixedMenu):
 	def __init__(self, session, csel):
 		self.csel = csel
-		
+
 		menu = [ ]
-		
-		if csel.mutableList is not None:
+
+		inBouquetRootList = csel.servicelist.getRoot().toString().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
+		inBouquet = csel.getMutableList() is not None
+
+		if not csel.bouquet_mark_edit and not csel.movemode and not inBouquetRootList:
+			menu.append(("add service to bouquet", self.addServiceToBouquetSelected))
+			if inBouquet:
+				menu.append(("remove service", self.removeCurrentService))
+
+		if inBouquet: # current list is editable?
 			if not csel.bouquet_mark_edit:
-				if csel.movemode:
-					menu.append(("disable move mode", self.toggleMoveMode))
-				else:
+				if not csel.movemode:
 					menu.append(("enable move mode", self.toggleMoveMode))
-
-			if not csel.movemode:
-				if csel.bouquet_mark_edit:
-					menu.append(("end bouquet edit", self.bouquetMarkEnd))
-					menu.append(("abort bouquet edit", self.bouquetMarkAbort))
+					if not inBouquetRootList: 
+						menu.append(("enable bouquet edit", self.bouquetMarkStart))
 				else:
-					menu.append(("edit bouquet...", self.bouquetMarkStart))
+					menu.append(("disable move mode", self.toggleMoveMode))
+			elif not inBouquetRootList: 
+				menu.append(("end bouquet edit", self.bouquetMarkEnd))
+				menu.append(("abort bouquet edit", self.bouquetMarkAbort))
 
-			if not csel.bouquet_mark_edit and not csel.movemode:
-				menu.append(("remove service", self.removeCurrentService))
-			menu.append(("back", self.close))
-		else:
-			menu.append(("back", self.close))
+		menu.append(("back", self.close))
 
 		FixedMenu.__init__(self, session, "Channel Selection", menu)
 		self.skinName = "Menu"
 
-	def removeCurrentService(self):
+	def addServiceToBouquetSelected(self):
+		bouquets = [ ]
+		serviceHandler = eServiceCenter.getInstance()
+		list = serviceHandler.list(self.csel.bouquet_root)
+		if not list is None:
+			while True:
+				s = list.getNext()
+				if not s.valid():
+					break
+				if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
+					info = serviceHandler.info(s)
+					if not info is None:
+						bouquets.append((info.getName(s), s))
+		cnt = len(bouquets)
+		if cnt > 1: # show bouquet list
+			self.session.open(BouquetSelector, bouquets, self)
+		elif cnt == 1: # add to only one existing bouquet
+			self.addCurrentServiceToBouquet(bouquet[0][1])
+		else: #no bouquets in root.. so assume only one favourite list is used
+			self.addCurrentServiceToBouquet(self.csel.bouquet_root)
+
+	def addCurrentServiceToBouquet(self, dest):
+		self.csel.addCurrentServiceToBouquet(dest)
 		self.close()
+
+	def removeCurrentService(self):
 		self.csel.removeCurrentService()
+		self.close()
 
 	def toggleMoveMode(self):
 		self.csel.toggleMoveMode()
 		self.close()
 
 	def bouquetMarkStart(self):
-		self.close()
 		self.csel.startMarkedEdit()
+		self.close()
 
 	def bouquetMarkEnd(self):
 		self.csel.endMarkedEdit(abort=False)
@@ -58,99 +98,40 @@ class ChannelContextMenu(FixedMenu):
 	def bouquetMarkAbort(self):
 		self.csel.endMarkedEdit(abort=True)
 		self.close()
- 
-class ChannelSelection(Screen):
-	def lastService(self):
-		self.lastServiceTimer.stop()
-		#zap to last running tv service
-		config.tv = ConfigSubsection();
-		config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
-		self.session.nav.playService(eServiceReference(config.tv.lastservice.value))
-	
-	def __init__(self, session):
-		Screen.__init__(self, session)
-		
+
+class ChannelSelectionEdit:
+	def __init__(self):
 		self.entry_marked = False
 		self.movemode = False
 		self.bouquet_mark_edit = False
-		
-		## FIXME
+		self.mutableList = None
 		self.__marked = [ ]
-		
-		self["key_red"] = Button("All")
-		self["key_green"] = Button("Provider")
-		self["key_yellow"] = Button("Satellite")
-		self["key_blue"] = Button("Favourites")
-		
-		self["list"] = ServiceList()
-		self.setRoot(eServiceReference("""1:0:1:0:0:0:0:0:0:0:(type == 1)"""))
-		
-		#self["okbutton"] = Button("ok", [self.channelSelected])
 
-		self.lastServiceTimer = eTimer()
-		self.lastServiceTimer.timeout.get().append(self.lastService)
-		self.lastServiceTimer.start(100)
-
-		class ChannelActionMap(ActionMap):
-			def action(self, contexts, action):
-				if action[:7] == "bouquet":
-					l = self.csel
-					list = l["list"]
-					list.setMode(list.MODE_NORMAL)
-					l.setRoot(eServiceReference("1:7:1:0:0:0:0:0:0:0:" + action[8:]))
-				else:
-					if action == "cancel":
-						l = self.csel
-						if l.movemode: #movemode active?
-							l.channelSelected() # unmark
-							l.toggleMoveMode() # disable move mode
-						elif l.bouquet_mark_edit:
-							l.endMarkedEdit(True) # abort edit mode
-					ActionMap.action(self, contexts, action)
-
-		self["actions"] = ChannelActionMap(["ChannelSelectActions", "OkCancelActions", "ContextMenuActions"], 
-			{
-				"cancel": self.close,
-				"ok": self.channelSelected,
-				"mark": self.doMark,
-				"contextMenu": self.doContext,
-				"showFavourites": self.showFavourites,
-		    "showEPGList": self.showEPGList
-			})
-		self["actions"].csel = self
-
-	def showEPGList(self):
-		ref=self["list"].getCurrent()
-		ptr=eEPGCache.getInstance()
-		if ptr.startTimeQuery(ref) != -1:
-			self.session.open(EPGSelection, ref)
-		else:
-			print 'no epg for service', ref.toString()
+	def getMutableList(self, root=eServiceReference()):
+		if not self.mutableList is None:
+			return self.mutableList
+		serviceHandler = eServiceCenter.getInstance()
+		if not root.valid():
+			root=self.servicelist.getRoot()
+		list = serviceHandler.list(root)
+		if list is not None:
+			return list.startEdit()
+		return None
 
 #  multiple marked entry stuff ( edit mode, later multiepg selection )
 	def startMarkedEdit(self):
-		l = self["list"]
+		self.mutableList = self.getMutableList()
 		# add all services from the current list to internal marked set in listboxservicecontent
-		if self.mutableList is not None:
-			self.bouquetRoot = l.getRoot()
-			self.clearMarks() # this clears the internal marked set in the listboxservicecontent
-			self.bouquet_mark_edit = True
-			self.__marked = l.getRootServices()
-			for x in self.__marked:
-				l.addMarked(eServiceReference(x))
-
-	def removeCurrentService(self):
-		l = self["list"]
-		ref=l.getCurrent()
-		if ref.valid() and self.mutableList is not None:
-			self.mutableList.removeService(ref)
-			self.mutableList.flushChanges() #FIXME dont flush on each single removed service
-			self.setRoot(l.getRoot())
+		self.bouquetRoot = self.servicelist.getRoot()
+		self.clearMarks() # this clears the internal marked set in the listboxservicecontent
+		self.bouquet_mark_edit = True
+		self.__marked = self.servicelist.getRootServices()
+		for x in self.__marked:
+			self.servicelist.addMarked(eServiceReference(x))
 
 	def endMarkedEdit(self, abort):
-		l = self["list"]
 		if not abort and self.mutableList is not None:
-			new_marked = set(l.getMarked())
+			new_marked = set(self.servicelist.getMarked())
 			old_marked = set(self.__marked)
 			removed = old_marked - new_marked
 			added = new_marked - old_marked
@@ -163,81 +144,238 @@ class ChannelSelection(Screen):
 				self.mutableList.addService(eServiceReference(x))
 			if changed:
 				self.mutableList.flushChanges()
-				#self.setRoot(self.bouquetRoot)
-				self.showFavourites()
+				self.setRoot(self.bouquetRoot)
+				#self.showFavourites()
 		self.__marked = []
 		self.clearMarks()
 		self.bouquet_mark_edit = False
 		self.bouquetRoot = None
-
-	def setRoot(self, root):
-		if not self.movemode:
-			if not self.bouquet_mark_edit:
-				serviceHandler = eServiceCenter.getInstance()
-				list = serviceHandler.list(root)
-				if list is not None:
-					self.mutableList = list.startEdit()
-				else:
-					self.mutableList = None
-			self["list"].setRoot(root)
+		self.mutableList = None
 
 	def clearMarks(self):
-		self["list"].clearMarks()
+		self.servicelist.clearMarks()
 
 	def doMark(self):
-		if not self.bouquet_mark_edit:
-			return
-		ref = self["list"].getCurrent()
-		if self["list"].isMarked(ref):
-			self["list"].removeMarked(ref)
+		ref = self.servicelist.getCurrent()
+		if self.servicelist.isMarked(ref):
+			self.servicelist.removeMarked(ref)
 		else:
-			self["list"].addMarked(ref)
+			self.servicelist.addMarked(ref)
 
-	def channelSelected(self):
-		ref = self["list"].getCurrent()
+	def removeCurrentService(self):
+		ref = self.servicelist.getCurrent()
+		mutableList = self.getMutableList()
+		if ref.valid() and mutableList is not None:
+			if not mutableList.removeService(ref):
+				mutableList.flushChanges() #FIXME dont flush on each single removed service
+				self.setRoot(self.servicelist.getRoot())
+
+	def addCurrentServiceToBouquet(self, dest):
+		mutableList = self.getMutableList(dest)
+		if not mutableList is None:
+			if not mutableList.addService(self.servicelist.getCurrent()):
+				mutableList.flushChanges()
+		self.close()
+
+	def toggleMoveMode(self):
 		if self.movemode:
 			if self.entry_marked:
-				self["list"].setCurrentMarked(False)
-				self.entry_marked = False
-			else:
-				self["list"].setCurrentMarked(True)
-				self.entry_marked = True
-		elif (ref.flags & 7) == 7:
-			self.setRoot(ref)
+				self.toggleMoveMarked() # unmark current entry
+			self.movemode = False
+			self.mutableList.flushChanges() # FIXME add check if changes was made
+			self.mutableList = None
+		else:
+			self.mutableList = self.getMutableList()
+			self.movemode = True
+
+	def handleEditCancel(self):
+		if self.movemode: #movemode active?
+			self.channelSelected() # unmark
+			self.toggleMoveMode() # disable move mode
 		elif self.bouquet_mark_edit:
-			self.doMark()
+			self.endMarkedEdit(True) # abort edit mode
+
+	def toggleMoveMarked(self):
+		if self.entry_marked:
+			self.servicelist.setCurrentMarked(False)
+			self.entry_marked = False
 		else:
-			self.session.nav.playService(ref)
-			self.saveChannel()
-			self.close()
+			self.servicelist.setCurrentMarked(True)
+			self.entry_marked = True
 
-	#called from infoBar
-	def zap(self):
-		self.session.nav.playService(self["list"].getCurrent())
-		self.saveChannel()
+	def doContext(self):
+		self.session.open(ChannelContextMenu, self)
+
+class ChannelSelectionBase(Screen):
+	def __init__(self, session):
+		Screen.__init__(self, session)
+
+		#self.bouquet_root = eServiceReference('1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet')
+		self.bouquet_root = eServiceReference('1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet')
+
+		self["key_red"] = Button("All")
+		#self["key_green"] = Button("Provider")
+		#self["key_yellow"] = Button("Satellite")
+		self["key_green"] = Button("")
+		self["key_yellow"] = Button("")
+		self["key_blue"] = Button("Favourites")
+
+		self["list"] = ServiceList()
+		self.servicelist = self["list"]
+
+		#self["okbutton"] = Button("ok", [self.channelSelected])
+		
+		self.numericalTextInput = NumericalTextInput()
+		
+		self.lastService = None
+
+		self.lastServiceTimer = eTimer()
+		self.lastServiceTimer.timeout.get().append(self.lastService)
+		self.lastServiceTimer.start(100)
+
+	def getBouquetNumOffset(self, bouquet):
+		if self.bouquet_root.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
+			return 0
+		offsetCount = 0
+		serviceHandler = eServiceCenter.getInstance()
+		bouquetlist = serviceHandler.list(self.bouquet_root)
+		if not bouquetlist is None:
+			while True:
+				bouquetIterator = bouquetlist.getNext()
+				if not bouquetIterator.valid() or bouquetIterator == bouquet: #end of list or bouquet found
+					break
+				if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
+					continue
+				servicelist = serviceHandler.list(bouquetIterator)
+				if not servicelist is None:
+					while True:
+						serviceIterator = servicelist.getNext()
+						if not serviceIterator.valid(): #check if end of list
+							break
+						if serviceIterator.flags: #playable services have no flags
+							continue
+						offsetCount += 1
+		return offsetCount
+
+	def setRootBase(self, root):
+		inBouquetRootList = root.toString().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
+		if not inBouquetRootList and ((root.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
+			self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
+			self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
+		else:
+			self.servicelist.setMode(ServiceList.MODE_NORMAL)
+		self.servicelist.setRoot(root)
 
 	def moveUp(self):
-		self["list"].moveUp()
+		self.servicelist.moveUp()
 
 	def moveDown(self):
-		self["list"].moveDown()
+		self.servicelist.moveDown()
 
-	def doContext(self):
-		self.session.open(ChannelContextMenu, self)
+	def showFavourites(self):
+		self.setRoot(self.bouquet_root)
 
-	def toggleMoveMode(self):
+	def keyNumberGlobal(self, number):
+		print "You pressed number " + str(number)
+		print "You would go to character " + str(self.numericalTextInput.getKey(number))
+		# TODO let the servicelist jump to the next entry strating with the chosen character
+
+	def enterBouquet(self, action):
+		if action[:7] == "bouquet":
+			if action.find("FROM BOUQUET") != -1:
+				self.setRoot(eServiceReference("1:7:1:0:0:0:0:0:0:0:" + action[8:]))
+			else:
+				self.setRoot(eServiceReference("1:0:1:0:0:0:0:0:0:0:" + action[8:]))
+			return True
+		return False
+
+	def getRoot(self):
+		return self.servicelist.getRoot()
+
+	def getCurrentSelection(self):
+		return self.servicelist.getCurrent()
+
+	def setCurrentSelection(self, service):
+		self.servicelist.setCurrent(service)
+
+	def cancel(self):
+		self.close(None)
+
+class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit):
+	def __init__(self, session):
+		ChannelSelectionBase.__init__(self,session)
+		ChannelSelectionEdit.__init__(self)
+
+		#config for lastservice
+		config.tv = ConfigSubsection();
+		config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
+		config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
+
+		if config.tv.lastroot.value == "":
+			self.servicelist.setRoot(eServiceReference("""1:0:1:0:0:0:0:0:0:0:(type == 1)"""))
+
+		self.session.nav.playService(eServiceReference(config.tv.lastservice.value))
+
+		class ChannelActionMap(NumberActionMap):
+			def action(self, contexts, action):
+				if not self.csel.enterBouquet(action):
+					if action == "cancel":
+						self.csel.handleEditCancel()
+					NumberActionMap.action(self, contexts, action)
+		self["actions"] = ChannelActionMap(["ChannelSelectActions", "OkCancelActions", "ContextMenuActions"],
+			{
+				"cancel": self.cancel,
+				"ok": self.channelSelected,
+				"mark": self.doMark,
+				"contextMenu": self.doContext,
+				"showFavourites": self.showFavourites,
+				"showEPGList": self.showEPGList,
+				"1": self.keyNumberGlobal,
+				"2": self.keyNumberGlobal,
+				"3": self.keyNumberGlobal,
+				"4": self.keyNumberGlobal,
+				"5": self.keyNumberGlobal,
+				"6": self.keyNumberGlobal,
+				"7": self.keyNumberGlobal,
+				"8": self.keyNumberGlobal,
+				"9": self.keyNumberGlobal,
+				"0": self.keyNumberGlobal
+			})
+		self["actions"].csel = self
+
+	def showEPGList(self):
+		ref=self.servicelist.getCurrent()
+		ptr=eEPGCache.getInstance()
+		if ptr.startTimeQuery(ref) != -1:
+			self.session.open(EPGSelection, ref)
+		else:
+			print 'no epg for service', ref.toString()
+
+	def channelSelected(self):
+		ref = self.servicelist.getCurrent()
 		if self.movemode:
-			if self.entry_marked:
-				self.channelSelected() # unmark current entry
-			self.movemode = False
-			self.mutableList.flushChanges() # FIXME add check if changes was made
+			self.toggleMoveMarked()
+		elif (ref.flags & 7) == 7:
+			self.setRoot(ref)
+		elif self.bouquet_mark_edit:
+			self.doMark()
 		else:
-			self.movemode = True
+			self.zap()
+			self.close(ref)
 
-	def showFavourites(self):
-		self.setRoot(eServiceReference('1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'))
-		list = self["list"]
-		list.setMode(list.MODE_FAVOURITES)
+	def setRoot(self, root):
+		if not self.movemode:
+			self.setRootBase(root)
+
+	#called from infoBar and channelSelected
+	def zap(self):
+		self.session.nav.playService(self.servicelist.getCurrent())
+		self.saveChannel()
+
+	def saveRoot(self, root):
+		if root is not None:
+			config.tv.lastroot.value = root.toString()
+			config.tv.lastroot.save()
 
 	def saveChannel(self):
 		ref = self.session.nav.getCurrentlyPlayingServiceReference()
@@ -247,3 +385,49 @@ class ChannelSelection(Screen):
 			refstr = ""
 		config.tv.lastservice.value = refstr
 		config.tv.lastservice.save()
+
+	def lastService(self):
+		self.lastServiceTimer.stop()
+		#zap to last running tv service
+		self.setRoot(eServiceReference(config.tv.lastroot.value))
+		self.session.nav.playService(eServiceReference(config.tv.lastservice.value))
+
+class SimpleChannelSelection(ChannelSelectionBase):
+	def __init__(self, session, title):
+		ChannelSelectionBase.__init__(self, session)
+		self.title = title
+		self.onShown.append(self.onExecCallback)
+
+		class ChannelActionMap(ActionMap):
+			def action(self, contexts, action):
+				if not self.csel.enterBouquet(action):
+					ActionMap.action(self, contexts, action)
+		self["actions"] = ChannelActionMap(["ChannelSelectActions", "OkCancelActions", "ContextMenuActions"],
+			{
+				"cancel": self.cancel,
+				"ok": self.channelSelected,
+				"showFavourites": self.showFavourites,
+				"1": self.keyNumberGlobal,
+				"2": self.keyNumberGlobal,
+				"3": self.keyNumberGlobal,
+				"4": self.keyNumberGlobal,
+				"5": self.keyNumberGlobal,
+				"6": self.keyNumberGlobal,
+				"7": self.keyNumberGlobal,
+				"8": self.keyNumberGlobal,
+				"9": self.keyNumberGlobal,
+				"0": self.keyNumberGlobal
+			})
+		self["actions"].csel = self
+
+	def onExecCallback(self):
+		print "onExecCallback"
+		self.session.currentDialog.instance.setTitle(self.title)
+
+	def channelSelected(self): # just return selected service
+		ref = self.servicelist.getCurrent()
+		self.close(ref)
+
+	def setRoot(self, root):
+		self.setRootBase(root)
+