path: root/lib/python/Screens/ChannelSelection.py

from Screen import Screen
from Components.Button import Button
from Components.ServiceList import ServiceList
from Components.ActionMap import NumberActionMap, ActionMap
from Components.MenuList import MenuList
from EpgSelection import EPGSelection
from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
from Screens.FixedMenu import FixedMenu
from Tools.NumericalTextInput import NumericalTextInput
from Components.NimManager import nimmanager
from Components.ServiceName import ServiceName
from Components.Clock import Clock
from Components.EventInfo import EventInfo
from ServiceReference import ServiceReference
from re import *
from os import remove

import xml.dom.minidom

class BouquetSelector(Screen):
	def __init__(self, session, bouquets, selectedFunc):
		Screen.__init__(self, session)

		self.selectedFunc=selectedFunc

		self["actions"] = ActionMap(["OkCancelActions"],
			{
				"ok": self.okbuttonClick,
				"cancel": self.cancelClick
			})
		entrys = [ ]
		for x in bouquets:
			entrys.append((x[0], x[1]))
		self["menu"] = MenuList(entrys)

	def okbuttonClick(self):
		self.selectedFunc(self["menu"].getCurrent()[1])

	def cancelClick(self):
		self.close(False)

class ChannelContextMenu(FixedMenu):
	def __init__(self, session, csel):
		self.csel = csel

		menu = [ ]

		inBouquetRootList = csel.getRoot().getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
		inBouquet = csel.getMutableList() is not None
		haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1

		if not csel.bouquet_mark_edit and not csel.movemode:
			if not inBouquetRootList:
				if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
					if haveBouquets:
						menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
					else:
						menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
				elif haveBouquets:
					if not inBouquet and csel.getCurrentSelection().getPath().find("PROVIDERS") == -1:
						menu.append((_("copy to favourites"), csel.copyCurrentToBouquetList))
				if inBouquet:
					menu.append((_("remove service"), self.removeCurrentService))
			elif haveBouquets:
				menu.append((_("remove bouquet"), csel.removeBouquet))

		if inBouquet: # current list is editable?
			if not csel.bouquet_mark_edit:
				if not csel.movemode:
					menu.append((_("enable move mode"), self.toggleMoveMode))
					if not inBouquetRootList:
						if haveBouquets:
							menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
						else:
							menu.append((_("enable favourite edit"), self.bouquetMarkStart))
				else:
					menu.append((_("disable move mode"), self.toggleMoveMode))
			elif not inBouquetRootList:
				if haveBouquets:
					menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
					menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
				else:
					menu.append((_("end favourites edit"), self.bouquetMarkEnd))
					menu.append((_("abort favourites edit"), self.bouquetMarkAbort))

		menu.append((_("back"), self.close))

		FixedMenu.__init__(self, session, _("Channel Selection"), menu)
		self.skinName = "Menu"

	def addServiceToBouquetSelected(self):
		bouquets = self.csel.getBouquetList()
		if bouquets is None:
			cnt = 0
		else:
			cnt = len(bouquets)
		if cnt > 1: # show bouquet list
			self.session.open(BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
		elif cnt == 1: # add to only one existing bouquet
			self.addCurrentServiceToBouquet(bouquets[0][1])
		else: #no bouquets in root.. so assume only one favourite list is used
			self.addCurrentServiceToBouquet(self.csel.bouquet_root)

	def copyCurrentToBouquetList(self):
		self.csel.copyCurrentToBouquetList()
		self.close()

	def removeBouquet(self):
		self.csel.removeBouquet()
		self.close()

	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.csel.startMarkedEdit()
		self.close()

	def bouquetMarkEnd(self):
		self.csel.endMarkedEdit(abort=False)
		self.close()

	def bouquetMarkAbort(self):
		self.csel.endMarkedEdit(abort=True)
		self.close()

class ChannelSelectionEPG:
	def __init__(self):
		self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
			{
				"showEPGList": self.showEPGList,
			})

	def showEPGList(self):
		ref=self.getCurrentSelection()
		ptr=eEPGCache.getInstance()
		if ptr.startTimeQuery(ref) != -1:
			self.session.open(EPGSelection, ref)
		else:
			print 'no epg for service', ref.toString()

class ChannelSelectionEdit:
	def __init__(self):
		self.entry_marked = False
		self.movemode = False
		self.bouquet_mark_edit = False
		self.mutableList = None
		self.__marked = [ ]
		self.saved_title = None
		self.saved_root = None

		class ChannelSelectionEditActionMap(ActionMap):
			def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
				ActionMap.__init__(self, contexts, actions, prio)
				self.csel = csel
			def action(self, contexts, action):
				if action == "cancel":
					self.csel.handleEditCancel()
				elif action == "ok":
					pass # avoid typo warning...
				else:
					ActionMap.action(self, contexts, action)
		self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
			{
				"contextMenu": self.doContext,
			})

	def getMutableList(self, root=eServiceReference()):
		if not self.mutableList is None:
			return self.mutableList
		serviceHandler = eServiceCenter.getInstance()
		if not root.valid():
			root=self.getRoot()
		list = serviceHandler.list(root)
		if list is not None:
			return list.startEdit()
		return None

	def buildBouquetID(self, str):
		tmp = str.lower()
		name = ''
		for c in tmp:
			if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
				name += c
			else:
				name += '_'
		return name

	def copyCurrentToBouquetList(self):
		provider = ServiceReference(self.getCurrentSelection())
		serviceHandler = eServiceCenter.getInstance()
		mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
		if mutableBouquetList:
			providerName = provider.getServiceName()
			if self.mode == MODE_TV:
				str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
			else:
				str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
			new_bouquet_ref = eServiceReference(str)
			if not mutableBouquetList.addService(new_bouquet_ref):
				mutableBouquetList.flushChanges()
				eDVBDB.getInstance().reloadBouquets()
				mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
				if mutableBouquet:
					mutableBouquet.setListName(providerName)
					list = [ ]
					services = serviceHandler.list(provider.ref)
					if not services is None:
						if not services.getContent(list, True):
							for service in list:
								if mutableBouquet.addService(service):
									print "add", service.toString(), "to new bouquet failed"
							mutableBouquet.flushChanges()
						else:
							print "getContent failed"
					else:
						print "list provider", providerName, "failed"
				else:
					print "get mutable list for new created bouquet failed"
			else:
				print "add", str, "to bouquets failed"
		else:
			print "bouquetlist is not editable"

	def removeBouquet(self):
		refstr = self.getCurrentSelection().toString()
		pos = refstr.find('FROM BOUQUET "')
		if pos != -1:
			refstr = refstr[pos+14:]
			print refstr
			pos = refstr.find('"')
			if pos != -1:
				filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
		self.removeCurrentService()
		remove(filename)
		eDVBDB.getInstance().reloadBouquets()

#  multiple marked entry stuff ( edit mode, later multiepg selection )
	def startMarkedEdit(self):
		self.mutableList = self.getMutableList()
		# add all services from the current list to internal marked set in listboxservicecontent
		self.bouquetRoot = self.getRoot()
		self.clearMarks() # this clears the internal marked set in the listboxservicecontent
		self.saved_title = self.instance.getTitle()
		new_title = self.saved_title
		if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
			new_title += ' ' + _("[bouquet edit]")
		else:
			new_title += ' ' + _("[favourite edit]")
		self.instance.setTitle(new_title)
		self.bouquet_mark_edit = True
		self.__marked = self.servicelist.getRootServices()
		for x in self.__marked:
			self.servicelist.addMarked(eServiceReference(x))
		self.saved_root = self.getRoot()
		self.showAllServices()

	def endMarkedEdit(self, abort):
		if not abort and self.mutableList is not None:
			new_marked = set(self.servicelist.getMarked())
			old_marked = set(self.__marked)
			removed = old_marked - new_marked
			added = new_marked - old_marked
			changed = False
			for x in removed:
				changed = True
				self.mutableList.removeService(eServiceReference(x))
			for x in added:
				changed = True
				self.mutableList.addService(eServiceReference(x))
			if changed:
				self.mutableList.flushChanges()
		self.__marked = []
		self.clearMarks()
		self.bouquet_mark_edit = False
		self.bouquetRoot = None
		self.mutableList = None
		self.instance.setTitle(self.saved_title)
		self.saved_title = None
		self.setRoot(self.saved_root)

	def clearMarks(self):
		self.servicelist.clearMarks()

	def doMark(self):
		ref = self.servicelist.getCurrent()
		if self.servicelist.isMarked(ref):
			self.servicelist.removeMarked(ref)
		else:
			self.servicelist.addMarked(ref)

	def removeCurrentService(self):
		ref = self.servicelist.getCurrent()
		mutableList = self.getMutableList()
		if ref.valid() and mutableList is not None:
			if not mutableList.removeService(ref):
				currentIndex = self.servicelist.getCurrentIndex()
				self.servicelist.moveDown()
				if self.servicelist.getCurrentIndex() == currentIndex:
					currentIndex -= 1
				mutableList.flushChanges() #FIXME dont flush on each single removed service
				self.setRoot(self.getRoot())
				self.servicelist.moveToIndex(currentIndex)

	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.toggleMoveMarked() # unmark current entry
			self.movemode = False
			self.pathChangedDisabled = False # re-enable path change
			self.mutableList.flushChanges() # FIXME add check if changes was made
			self.mutableList = None
			self.instance.setTitle(self.saved_title)
			self.saved_title = None
		else:
			self.mutableList = self.getMutableList()
			self.movemode = True
			self.pathChangedDisabled = True # no path change allowed in movemode
			self.saved_title = self.instance.getTitle()
			new_title = self.saved_title
			new_title += ' ' + _("[move mode]");
			self.instance.setTitle(new_title);

	def handleEditCancel(self):
		if self.movemode: #movemode active?
			self.channelSelected() # unmark
			self.toggleMoveMode() # disable move mode
		elif self.bouquet_mark_edit:
			self.endMarkedEdit(True) # abort edit mode

	def toggleMoveMarked(self):
		if self.entry_marked:
			self.servicelist.setCurrentMarked(False)
			self.entry_marked = False
		else:
			self.servicelist.setCurrentMarked(True)
			self.entry_marked = True

	def doContext(self):
		self.session.open(ChannelContextMenu, self)

MODE_TV = 0
MODE_RADIO = 1

class ChannelSelectionBase(Screen):
	def __init__(self, session):
		Screen.__init__(self, session)

		# this makes it much simple to implement a selectable radio or tv mode :)
		self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
		self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'

		self["key_red"] = Button(_("All"))
		self["key_green"] = Button(_("Satellites"))
		self["key_yellow"] = Button(_("Provider"))
		self["key_blue"] = Button(_("Favourites"))

		self["list"] = ServiceList()
		self.servicelist = self["list"]

		self.numericalTextInput = NumericalTextInput()

		self.servicePathTV = [ ]
		self.servicePathRadio = [ ]

		self.pathChangedDisabled = False

		self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
			{
				"showFavourites": self.showFavourites,
				"showAllServices": self.showAllServices,
				"showProviders": self.showProviders,
				"showSatellites": self.showSatellites,
				"nextBouquet": self.nextBouquet,
				"prevBouquet": self.prevBouquet,
				"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
			})

	def appendDVBTypes(self, ref):
		path = ref.getPath()
		pos = path.find(' FROM BOUQUET')
		if pos != -1:
			return eServiceReference(self.service_types + path[pos:])
		return ref

	def getBouquetNumOffset(self, bouquet):
		bouquet = self.appendDVBTypes(bouquet)
		if self.bouquet_root.getPath().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 = self.appendDVBTypes(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 recallBouquetMode(self):
		if self.mode == MODE_TV:
			self.service_types = self.service_types_tv
			if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
				self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
			else:
				self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
		else:
			self.service_types = self.service_types_radio
			if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
				self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
			else:
				self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
		self.bouquet_root = eServiceReference(self.bouquet_rootstr)

	def setTvMode(self):
		title = self.instance.getTitle()
		pos = title.find(" (")
		if pos != -1:
			title = title[:pos]
		title += " (TV)"
		self.instance.setTitle(title)
		self.mode = MODE_TV
		self.recallBouquetMode()

	def setRadioMode(self):
		title = self.instance.getTitle()
		pos = title.find(" (")
		if pos != -1:
			title = title[:pos]
		title += " (Radio)"
		self.instance.setTitle(title)
		self.mode = MODE_RADIO
		self.recallBouquetMode()

	def setRoot(self, root, justSet=False):
		path = root.getPath()
		inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
		pos = path.find(' FROM BOUQUET')
		isBouquet = pos != -1
		if not inBouquetRootList and isBouquet:
			self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
			self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
			refstr = self.service_types + path[pos:]
			root = eServiceReference(refstr)
		else:
			self.servicelist.setMode(ServiceList.MODE_NORMAL)
		self.servicelist.setRoot(root, justSet)

	def moveUp(self):
		self.servicelist.moveUp()

	def moveDown(self):
		self.servicelist.moveDown()

	def clearPath(self):
		if self.mode == MODE_RADIO:
			self.servicePathRadio = [ ]
		else:
			self.servicePathTV = [ ]

	def enterPath(self, ref, justSet=False):
		if self.mode == MODE_RADIO:
			self.servicePathRadio.append(ref)
		else:
			self.servicePathTV.append(ref)
		self.setRoot(ref, justSet)

	def pathUp(self, justSet=False):
		if self.mode == MODE_TV:
			prev = self.servicePathTV.pop()
			length = len(self.servicePathTV)
			if length:
				current = self.servicePathTV[length-1]
		else:
			prev = self.servicePathRadio.pop()
			length = len(self.servicePathRadio)
			if length:
				current = self.servicePathRadio[length-1]
		self.setRoot(current, justSet)
		if not justSet:
			self.setCurrentSelection(prev)
		return prev

	def isBasePathEqual(self, ref):
		if self.mode == MODE_RADIO and len(self.servicePathRadio) > 1 and self.servicePathRadio[0] == ref:
			return True
		elif self.mode == MODE_TV and len(self.servicePathTV) > 1 and self.servicePathTV[0] == ref:
			return True
		return False

	def isPrevPathEqual(self, ref):
		path = self.servicePathRadio
		if self.mode == MODE_TV:
			path = self.servicePathTV
		length = len(path)
		if length > 1 and path[length-2] == ref:
			return True
		return False

	def preEnterPath(self, refstr):
		return False

	def showAllServices(self):
		if not self.pathChangedDisabled:
			refstr = '%s ORDER BY name'%(self.service_types)
			if not self.preEnterPath(refstr):
				ref = eServiceReference(refstr)
				currentRoot = self.getRoot()
				if currentRoot is None or currentRoot != ref:
					self.clearPath()
					self.enterPath(ref)

	def showSatellites(self):
		if not self.pathChangedDisabled:
			refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
			if not self.preEnterPath(refstr):
				ref = eServiceReference(refstr)
				justSet=False
				prev = None

				if self.isBasePathEqual(ref):
					if self.isPrevPathEqual(ref):
						justSet=True
					prev = self.pathUp(justSet)
				else:
					currentRoot = self.getRoot()
					if currentRoot is None or currentRoot != ref:
						justSet=True
						self.clearPath()
						self.enterPath(ref, True)
				if justSet:
					serviceHandler = eServiceCenter.getInstance()
					servicelist = serviceHandler.list(ref)
					if not servicelist is None:
						while True:
							service = servicelist.getNext()
							if not service.valid(): #check if end of list
								break
							orbpos = service.getData(4) >> 16
							if service.getPath().find("FROM PROVIDER") != -1:
								service_name = _("Providers")
							else:
								service_name = _("Services")
							try:
								service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
								service.setName(service_name) # why we need this cast?
							except:
								if orbpos > 1800: # west
									service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
								else:
									service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
							self.servicelist.addService(service)
							self.servicelist.finishFill()
							if prev is not None:
								self.setCurrentSelection(prev)

	def showProviders(self):
		if not self.pathChangedDisabled:
			refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
			if not self.preEnterPath(refstr):
				ref = eServiceReference(refstr)
				if self.isBasePathEqual(ref):
					self.pathUp()
				else:
					currentRoot = self.getRoot()
					if currentRoot is None or currentRoot != ref:
						self.clearPath()
						self.enterPath(ref)

	def changeBouquet(self, direction):
		if not self.pathChangedDisabled:
			if self.isBasePathEqual(self.bouquet_root):
				self.pathUp()
				if direction < 0:
					self.moveUp()
				else:
					self.moveDown()
				ref = self.getCurrentSelection()
				self.enterPath(ref)

	def nextBouquet(self):
		self.changeBouquet(+1)

	def prevBouquet(self):
		self.changeBouquet(-1)

	def showFavourites(self):
		if not self.pathChangedDisabled:
			if not self.preEnterPath(self.bouquet_rootstr):
				if self.isBasePathEqual(self.bouquet_root):
					self.pathUp()
				else:
					currentRoot = self.getRoot()
					if currentRoot is None or currentRoot != self.bouquet_root:
						self.clearPath()
						self.enterPath(self.bouquet_root)

	def keyNumberGlobal(self, number):
		char = self.numericalTextInput.getKey(number)
		self.servicelist.moveToChar(char)

	def getRoot(self):
		return self.servicelist.getRoot()

	def getCurrentSelection(self):
		return self.servicelist.getCurrent()

	def setCurrentSelection(self, service):
		servicepath = service.getPath()
		pos = servicepath.find(" FROM BOUQUET")
		if pos != -1:
			if self.mode == MODE_TV:
				servicepath = '(type == 1)' + servicepath[pos:]
			else:
				servicepath = '(type == 2)' + servicepath[pos:]
			service.setPath(servicepath)
		self.servicelist.setCurrent(service)

	def getBouquetList(self):
		serviceCount=0
		bouquets = [ ]
		serviceHandler = eServiceCenter.getInstance()
		list = serviceHandler.list(self.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))
				else:
					serviceCount += 1
			if len(bouquets) == 0 and serviceCount > 0:
				info = serviceHandler.info(self.bouquet_root)
				if not info is None:
					bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
			return bouquets
		return None

class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
	def __init__(self, session):
		ChannelSelectionBase.__init__(self,session)
		ChannelSelectionEdit.__init__(self)
		ChannelSelectionEPG.__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);
		config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
		config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);

		self["actions"] = ActionMap(["OkCancelActions"],
			{
				"cancel": self.cancel,
				"ok": self.channelSelected,
			})
		self.onShown.append(self.onShow)

		self.lastChannelRootTimer = eTimer()
		self.lastChannelRootTimer.timeout.get().append(self.onCreate)
		self.lastChannelRootTimer.start(100,True)

	def onCreate(self):
		self.setTvMode()
		self.servicePathTV = [ ]
		self.restoreRoot()
		lastservice=eServiceReference(config.tv.lastservice.value)
		if lastservice.valid():
			self.setCurrentSelection(lastservice)
			self.session.nav.playService(lastservice)

	def onShow(self):
		self.recallBouquetMode()
		ref = self.session.nav.getCurrentlyPlayingServiceReference()
		if ref is not None and ref.valid() and ref.getPath() == "":
			self.servicelist.setPlayableIgnoreService(ref)
		else:
			self.servicelist.setPlayableIgnoreService(eServiceReference())

	def channelSelected(self):
		ref = self.getCurrentSelection()
		if self.movemode:
			self.toggleMoveMarked()
		elif (ref.flags & 7) == 7:
			self.enterPath(ref)
		elif self.bouquet_mark_edit:
			self.doMark()
		else:
			self.zap()
			self.close(ref)

	#called from infoBar and channelSelected
	def zap(self):
		ref = self.session.nav.getCurrentlyPlayingServiceReference()
		if ref is None or ref != self.getCurrentSelection():
			self.session.nav.playService(self.getCurrentSelection())
		self.saveRoot()
		self.saveChannel()

	def saveRoot(self):
		path = ''
		for i in self.servicePathTV:
			path += i.toString()
			path += ';'
		if config.tv.prevroot.value != config.tv.lastroot.value:
			config.tv.prevroot.value = config.tv.lastroot.value
			config.tv.prevroot.save()
		if len(path) and path != config.tv.lastroot.value:
			config.tv.lastroot.value = path
			config.tv.lastroot.save()

	def restoreRoot(self):
		self.servicePathTV = [ ]
		re = compile('.+?;')
		tmp = re.findall(config.tv.lastroot.value)
		cnt = 0
		for i in tmp:
			self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
			cnt += 1
		if cnt:
			path = self.servicePathTV.pop()
			self.enterPath(path)
		else:
			self.showFavourites()
			self.saveRoot()

	def preEnterPath(self, refstr):
		if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
			pathstr = config.tv.lastroot.value
			if pathstr is not None and pathstr.find(refstr) == 0:
				self.restoreRoot()
				lastservice=eServiceReference(config.tv.lastservice.value)
				if lastservice is not None:
					self.setCurrentSelection(lastservice)
				return True
		return False

	def saveChannel(self):
		ref = self.session.nav.getCurrentlyPlayingServiceReference()
		if ref is not None:
			refstr = ref.toString()
		else:
			refstr = ""
		if refstr != config.tv.lastservice.value:
			config.tv.prevservice.value = config.tv.lastservice.value
			config.tv.prevservice.save()
			config.tv.lastservice.value = refstr
			config.tv.lastservice.save()

	def recallPrevService(self):
		if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
			if config.tv.lastroot.value != config.tv.prevroot.value:
				tmp = config.tv.lastroot.value
				config.tv.lastroot.value = config.tv.prevroot.value
				config.tv.lastroot.save()
				config.tv.prevroot.value = tmp
				config.tv.prevroot.save()
				self.restoreRoot()
			if config.tv.lastservice.value != config.tv.prevservice.value:
				tmp = config.tv.lastservice.value
				config.tv.lastservice.value = config.tv.prevservice.value
				config.tv.lastservice.save()
				config.tv.prevservice.value = tmp
				config.tv.prevservice.save()
				lastservice=eServiceReference(config.tv.lastservice.value)
				self.session.nav.playService(lastservice)
				self.setCurrentSelection(lastservice)

	def cancel(self):
		self.close(None)
		self.restoreRoot()
		lastservice=eServiceReference(config.tv.lastservice.value)
		if lastservice.valid() and self.getCurrentSelection() != lastservice:
			self.setCurrentSelection(lastservice)

from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord

class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
	def __init__(self, session):
		Screen.__init__(self, session)
		InfoBarEvent.__init__(self)
		InfoBarServiceName.__init__(self)
		InfoBarInstantRecord.__init__(self)
		self["Clock"] = Clock()

class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
	def __init__(self, session):
		ChannelSelectionBase.__init__(self, session)
		ChannelSelectionEdit.__init__(self)
		ChannelSelectionEPG.__init__(self)

		config.radio = ConfigSubsection();
		config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
		config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
		self.onLayoutFinish.append(self.onCreate)

		self.info = session.instantiateDialog(RadioInfoBar)

		self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
			{
				"keyTV": self.closeRadio,
				"keyRadio": self.closeRadio,
				"cancel": self.closeRadio,
				"ok": self.channelSelected,
			})

	def saveRoot(self):
		path = ''
		for i in self.servicePathRadio:
			path += i.toString()
			path += ';'
		if len(path) and path != config.radio.lastroot.value:
			config.radio.lastroot.value = path
			config.radio.lastroot.save()

	def restoreRoot(self):
		self.servicePathRadio = [ ]
		re = compile('.+?;')
		tmp = re.findall(config.radio.lastroot.value)
		cnt = 0
		for i in tmp:
			self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
			cnt += 1
		if cnt:
			path = self.servicePathRadio.pop()
			self.enterPath(path)
		else:
			self.showFavourites()
			self.saveRoot()

	def preEnterPath(self, refstr):
		if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
			pathstr = config.radio.lastroot.value
			if pathstr is not None and pathstr.find(refstr) == 0:
				self.restoreRoot()
				lastservice=eServiceReference(config.radio.lastservice.value)
				if lastservice is not None:
					self.setCurrentSelection(lastservice)
				return True
		return False

	def onCreate(self):
		self.setRadioMode()
		self.restoreRoot()
		lastservice=eServiceReference(config.radio.lastservice.value)
		if lastservice.valid():
			self.servicelist.setCurrent(lastservice)
			self.session.nav.playService(lastservice)
			self.servicelist.setPlayableIgnoreService(lastservice)
		self.info.instance.show()

	def channelSelected(self): # just return selected service
		ref = self.getCurrentSelection()
		if self.movemode:
			self.toggleMoveMarked()
		elif (ref.flags & 7) == 7:
			self.enterPath(ref)
		elif self.bouquet_mark_edit:
			self.doMark()
		else:
			playingref = self.session.nav.getCurrentlyPlayingServiceReference()
			if playingref is None or playingref != ref:
				self.session.nav.playService(ref)
				self.servicelist.setPlayableIgnoreService(ref)
				config.radio.lastservice.value = ref.toString()
				config.radio.lastservice.save()
			self.saveRoot()

	def closeRadio(self):
		self.info.instance.hide()
		#set previous tv service
		lastservice=eServiceReference(config.tv.lastservice.value)
		self.session.nav.playService(lastservice)
		self.close(None)

class SimpleChannelSelection(ChannelSelectionBase):
	def __init__(self, session, title):
		ChannelSelectionBase.__init__(self, session)
		self.title = title
		self.onShown.append(self.onExecCallback)

		self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
			{
				"cancel": self.cancel,
				"ok": self.channelSelected,
				"keyRadio": self.setModeRadio,
				"keyTV": self.setModeTv,
			})

	def onExecCallback(self):
		self.session.currentDialog.instance.setTitle(self.title)
		self.setModeTv()

	def channelSelected(self): # just return selected service
		ref = self.getCurrentSelection()
		if (ref.flags & 7) == 7:
			self.enterPath(ref)
		else:
			ref = self.getCurrentSelection()
			self.close(ref)

	def setModeTv(self):
		self.setTvMode()
		self.showFavourites()

	def setModeRadio(self):
		self.setRadioMode()
		self.showFavourites()