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 enigma import eServiceReference, eEPGCache, 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 Components.Sources.Clock import Clock
+from Components.Input import Input
+from Screens.InputBox import InputBox
from ServiceReference import ServiceReference
from re import *
from os import remove
+FLAG_SERVICE_NEW_FOUND = 64 #define in lib/dvb/idvb.h as dxNewFound = 64
+
import xml.dom.minidom
class BouquetSelector(Screen):
- def __init__(self, session, bouquets, selectedFunc):
+ def __init__(self, session, bouquets, selectedFunc, enableWrapAround=False):
Screen.__init__(self, session)
self.selectedFunc=selectedFunc
entrys = [ ]
for x in bouquets:
entrys.append((x[0], x[1]))
- self["menu"] = MenuList(entrys)
+ self["menu"] = MenuList(entrys, enableWrapAround)
+
+ def getCurrent(self):
+ cur = self["menu"].getCurrent()
+ return cur and cur[1]
def okbuttonClick(self):
- self.selectedFunc(self["menu"].getCurrent()[1])
+ self.selectedFunc(self.getCurrent())
+
+ def up(self):
+ self["menu"].up()
+
+ def down(self):
+ self["menu"].down()
def cancelClick(self):
self.close(False)
def __init__(self, session, csel):
Screen.__init__(self, session)
self.csel = csel
+ self.bsel = None
self["actions"] = ActionMap(["OkCancelActions"],
{
})
menu = [ ]
- inBouquetRootList = csel.getRoot().getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
+ current_root = csel.getRoot()
+ current_sel_path = csel.getCurrentSelection().getPath()
+ current_sel_flags = csel.getCurrentSelection().flags
+ inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
inBouquet = csel.getMutableList() is not None
haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
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))
+ else:
+ if haveBouquets:
+ if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
+ menu.append((_("copy to favourites"), self.copyCurrentToBouquetList))
+ if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
+ menu.append((_("remove all new found flags"), self.removeAllNewFoundFlags))
if inBouquet:
- menu.append((_("remove service"), self.removeCurrentService))
- elif haveBouquets:
- menu.append((_("remove bouquet"), csel.removeBouquet))
+ menu.append((_("remove entry"), self.removeCurrentService))
+ if current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
+ menu.append((_("remove new found flag"), self.removeNewFoundFlag))
+ else:
+ menu.append((_("add bouquet"), self.showBouquetInputBox))
+ menu.append((_("remove entry"), self.removeBouquet))
if inBouquet: # current list is editable?
if not csel.bouquet_mark_edit:
if not csel.movemode:
+ menu.append((_("add marker"), self.showMarkerInputBox))
menu.append((_("enable move mode"), self.toggleMoveMode))
if not inBouquetRootList:
if haveBouquets:
def cancelClick(self):
self.close(False)
+
+ def showBouquetInputBox(self):
+ self.session.openWithCallback(self.bouquetInputCallback, InputBox, title=_("Please enter a name for the new bouquet"), text="bouquetname", maxSize=False, type=Input.TEXT)
+
+ def bouquetInputCallback(self, bouquet):
+ if bouquet is not None:
+ self.csel.addBouquet(bouquet, None)
+ self.close()
def addServiceToBouquetSelected(self):
bouquets = self.csel.getBouquetList()
else:
cnt = len(bouquets)
if cnt > 1: # show bouquet list
- self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
+ self.bsel = self.session.openWithCallback(self.bouquetSelClosed, 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 bouquetSelClosed(self, recursive):
+ self.bsel = None
if recursive:
self.close(False)
self.csel.removeBouquet()
self.close()
+ def showMarkerInputBox(self):
+ self.session.openWithCallback(self.markerInputCallback, InputBox, title=_("Please enter a name for the new marker"), text="markername", maxSize=False, type=Input.TEXT)
+
+ def markerInputCallback(self, marker):
+ if marker is not None:
+ self.csel.addMarker(marker)
+ self.close()
+
def addCurrentServiceToBouquet(self, dest):
self.csel.addCurrentServiceToBouquet(dest)
- self.close(True) # close bouquet selection
+ if self.bsel is not None:
+ self.bsel.close(True)
+ else:
+ self.close(True) # close bouquet selection
def removeCurrentService(self):
self.csel.removeCurrentService()
self.csel.endMarkedEdit(abort=True)
self.close()
+ def removeNewFoundFlag(self):
+ eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
+ self.close()
+
+ def removeAllNewFoundFlags(self):
+ curpath = self.csel.getCurrentSelection().getPath()
+ idx = curpath.find("satellitePosition == ")
+ if idx != -1:
+ tmp = curpath[idx+21:]
+ idx = tmp.find(')')
+ if idx != -1:
+ satpos = int(tmp[:idx])
+ eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
+ self.close()
+
class ChannelSelectionEPG:
def __init__(self):
self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
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()
+ return 0 # fall-trough
elif action == "ok":
- pass # avoid typo warning...
+ return 0 # fall-trough
else:
- ActionMap.action(self, contexts, action)
+ return ActionMap.action(self, contexts, action)
+
self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
{
"contextMenu": self.doContext,
serviceHandler = eServiceCenter.getInstance()
if not root.valid():
root=self.getRoot()
- list = serviceHandler.list(root)
+ list = root and serviceHandler.list(root)
if list is not None:
return list.startEdit()
return None
name += '_'
return name
- def copyCurrentToBouquetList(self):
- provider = ServiceReference(self.getCurrentSelection())
+ def addMarker(self, name):
+ current = self.servicelist.getCurrent()
+ mutableList = self.getMutableList()
+ cnt = 0
+ while mutableList:
+ str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
+ ref = eServiceReference(str)
+ if current and current.valid():
+ if not mutableList.addService(ref, current):
+ self.servicelist.addService(ref, True)
+ mutableList.flushChanges()
+ break
+ elif not mutableList.addService(ref):
+ self.servicelist.addService(ref, True)
+ mutableList.flushChanges()
+ break
+ cnt+=1
+
+ def addBouquet(self, bName, services):
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))
+ bName += " (TV)"
+ str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
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))
+ bName += " (Radio)"
+ str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
new_bouquet_ref = eServiceReference(str)
if not mutableBouquetList.addService(new_bouquet_ref):
self.bouquetNumOffsetCache = { }
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"
+ mutableBouquet.setListName(bName)
+ if services is not None:
+ for service in services:
+ if mutableBouquet.addService(service):
+ print "add", service.toString(), "to new bouquet failed"
+ else:
+ current = self.servicelist.getCurrent()
+ if current and current.toString() == self.bouquet_rootstr:
+ self.servicelist.addService(service, True)
+ mutableBouquet.flushChanges()
else:
print "get mutable list for new created bouquet failed"
else:
else:
print "bouquetlist is not editable"
+ def copyCurrentToBouquetList(self):
+ provider = ServiceReference(self.getCurrentSelection())
+ providerName = provider.getServiceName()
+ serviceHandler = eServiceCenter.getInstance()
+ services = serviceHandler.list(provider.ref)
+ self.addBouquet(providerName, services and services.getContent('R', True))
+
def removeBouquet(self):
refstr = self.getCurrentSelection().toString()
self.bouquetNumOffsetCache = { }
if pos != -1:
filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
self.removeCurrentService()
- remove(filename)
- eDVBDB.getInstance().reloadBouquets()
+ try:
+ remove(filename)
+ except OSError:
+ print "error during remove of", filename
# multiple marked entry stuff ( edit mode, later multiepg selection )
def startMarkedEdit(self):
new_title += ' ' + _("[bouquet edit]")
else:
new_title += ' ' + _("[favourite edit]")
- self.instance.setTitle(new_title)
+ self.setTitle(new_title)
self.bouquet_mark_edit = True
self.__marked = self.servicelist.getRootServices()
for x in self.__marked:
self.clearMarks()
self.bouquet_mark_edit = False
self.mutableList = None
- self.instance.setTitle(self.saved_title)
+ self.setTitle(self.saved_title)
self.saved_title = None
- self.servicePath = self.savedPath[:]
+ # self.servicePath is just a reference to servicePathTv or Radio...
+ # so we never ever do use the asignment operator in self.servicePath
+ del self.servicePath[:] # remove all elements
+ self.servicePath += self.savedPath # add saved elements
del self.savedPath
self.setRoot(self.servicePath[len(self.servicePath)-1])
if ref.valid() and mutableList is not None:
if not mutableList.removeService(ref):
self.bouquetNumOffsetCache = { }
- 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)
+ self.servicelist.removeCurrent()
def addCurrentServiceToBouquet(self, dest):
mutableList = self.getMutableList(dest)
if not mutableList.addService(self.servicelist.getCurrent()):
self.bouquetNumOffsetCache = { }
mutableList.flushChanges()
- self.close()
def toggleMoveMode(self):
if self.movemode:
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.setTitle(self.saved_title)
self.saved_title = None
if self.getRoot() == self.bouquet_root:
self.bouquetNumOffsetCache = { }
new_title = self.saved_title
pos = self.saved_title.find(')')
new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
- self.instance.setTitle(new_title);
+ self.setTitle(new_title);
def handleEditCancel(self):
if self.movemode: #movemode active?
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_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
self["key_red"] = Button(_("All"))
self.servicelist = self["list"]
self.numericalTextInput = NumericalTextInput()
+ self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
self.servicePathTV = [ ]
self.servicePathRadio = [ ]
- self.servicePath = None
+ self.servicePath = [ ]
+
+ self.mode = MODE_TV
self.pathChangedDisabled = False
"showSatellites": self.showSatellites,
"nextBouquet": self.nextBouquet,
"prevBouquet": self.prevBouquet,
+ "nextMarker": self.nextMarker,
+ "prevMarker": self.prevMarker,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
- "0": self.keyNumberGlobal
+ "0": self.keyNumber0
})
def appendDVBTypes(self, ref):
if pos != -1:
title = title[:pos]
title += " (TV)"
- self.instance.setTitle(title)
+ self.setTitle(title)
def setRadioMode(self):
self.mode = MODE_RADIO
if pos != -1:
title = title[:pos]
title += " (Radio)"
- self.instance.setTitle(title)
+ self.setTitle(title)
def setRoot(self, root, justSet=False):
path = root.getPath()
titleStr += '/'
nameStr = self.getServiceName(end_ref)
titleStr += nameStr
- self.instance.setTitle(titleStr)
+ self.setTitle(titleStr)
def moveUp(self):
self.servicelist.moveUp()
length = len(self.servicePath)
if length:
current = self.servicePath[length-1]
- self.setRoot(current, justSet)
- if not justSet:
- self.setCurrentSelection(prev)
+ self.setRoot(current, justSet)
+ if not justSet:
+ self.setCurrentSelection(prev)
return prev
def isBasePathEqual(self, ref):
service = servicelist.getNext()
if not service.valid(): #check if end of list
break
- orbpos = service.getData(4) >> 16
+ orbpos = service.getUnsignedData(4) >> 16
if service.getPath().find("FROM PROVIDER") != -1:
service_name = _("Providers")
+ elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
+ service_name = _("New")
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))
+ if orbpos == 0xFFFF: #Cable
+ n = ("%s (%s)") % (service_name, _("Cable"))
+ elif orbpos == 0xEEEE: #Terrestrial
+ n = ("%s (%s)") % (service_name, _("Terrestrial"))
else:
- service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
+ if orbpos > 1800: # west
+ orbpos = 3600 - orbpos
+ h = _("W")
+ else:
+ h = _("E")
+ n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
+ service.setName(n)
self.servicelist.addService(service)
self.servicelist.finishFill()
if prev is not None:
self.enterPath(self.bouquet_root)
def keyNumberGlobal(self, number):
- char = self.numericalTextInput.getKey(number)
- self.servicelist.moveToChar(char)
+ unichar = self.numericalTextInput.getKey(number)
+ charstr = unichar.encode("utf-8")
+ if len(charstr) == 1:
+ self.servicelist.moveToChar(charstr[0])
def getRoot(self):
return self.servicelist.getRoot()
return bouquets
return None
+ def keyNumber0(self, num):
+ if len(self.servicePath) > 1:
+ self.keyGoUp()
+ else:
+ self.keyNumberGlobal(num)
+
+ def keyGoUp(self):
+ if len(self.servicePath) > 1:
+ if self.isBasePathEqual(self.bouquet_root):
+ self.showFavourites()
+ else:
+ ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
+ if self.isBasePathEqual(ref):
+ self.showSatellites()
+ else:
+ ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
+ if self.isBasePathEqual(ref):
+ self.showProviders()
+ else:
+ self.showAllServices()
+
+ def nextMarker(self):
+ self.servicelist.moveToNextMarker()
+
+ def prevMarker(self):
+ self.servicelist.moveToPrevMarker()
+
HISTORYSIZE = 20
+#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.radio = ConfigSubsection()
+config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0)
+config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0)
+config.servicelist = ConfigSubsection()
+config.servicelist.lastmode = configElement("config.servicelist.lastmode", configText, "tv", 0)
+
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"],
+ self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
{
"cancel": self.cancel,
"ok": self.channelSelected,
+ "keyRadio": self.setModeRadio,
+ "keyTV": self.setModeTv,
})
+
self.onShown.append(self.__onShown)
self.lastChannelRootTimer = eTimer()
self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
self.lastChannelRootTimer.start(100,True)
- self.history = [ ]
+ self.history_tv = [ ]
+ self.history_radio = [ ]
+ self.history = self.history_tv
self.history_pos = 0
- def __onCreate(self):
- self.setTvMode()
+ self.lastservice = config.tv.lastservice
+ self.lastroot = config.tv.lastroot
+ self.revertMode = None
+
+ def setMode(self):
self.restoreRoot()
- lastservice=eServiceReference(config.tv.lastservice.value)
+ lastservice=eServiceReference(self.lastservice.value)
if lastservice.valid():
self.setCurrentSelection(lastservice)
+
+ def setModeTv(self):
+ if self.revertMode is None and config.servicelist.lastmode.value == "radio":
+ self.revertMode = MODE_RADIO
+ self.history = self.history_tv
+ self.lastservice = config.tv.lastservice
+ self.lastroot = config.tv.lastroot
+ config.servicelist.lastmode.value = "tv"
+ self.setTvMode()
+ self.setMode()
+
+ def setModeRadio(self):
+ if self.revertMode is None and config.servicelist.lastmode.value == "tv":
+ self.revertMode = MODE_TV
+ if currentConfigSelectionElement(config.usage.e1like_radio_mode) == "yes":
+ self.history = self.history_radio
+ self.lastservice = config.radio.lastservice
+ self.lastroot = config.radio.lastroot
+ config.servicelist.lastmode.value = "radio"
+ self.setRadioMode()
+ self.setMode()
+
+ def __onCreate(self):
+ if currentConfigSelectionElement(config.usage.e1like_radio_mode) == "yes":
+ if config.servicelist.lastmode.value == "tv":
+ self.setModeTv()
+ else:
+ self.setModeRadio()
+ else:
+ self.setModeTv()
+ lastservice=eServiceReference(self.lastservice.value)
+ if lastservice.valid():
self.zap()
def __onShown(self):
self.enterPath(ref)
elif self.bouquet_mark_edit:
self.doMark()
- else:
+ elif not (ref.flags & 64): # no marker
self.zap()
self.close(ref)
#called from infoBar and channelSelected
def zap(self):
+ self.revertMode=None
ref = self.session.nav.getCurrentlyPlayingServiceReference()
nref = self.getCurrentSelection()
if ref is None or ref != nref:
self.session.nav.playService(nref)
- self.saveRoot()
- self.saveChannel()
- tmp=self.servicePath[:]
- tmp.append(nref)
- try:
- del self.history[self.history_pos+1:]
- except:
- pass
- self.history.append(tmp)
- hlen = len(self.history)
- if hlen > HISTORYSIZE:
- del self.history[0]
- hlen -= 1
- self.history_pos = hlen-1
+ self.saveRoot()
+ self.saveChannel()
+ config.servicelist.lastmode.save()
+ self.addToHistory(nref)
+
+ def addToHistory(self, ref):
+ if self.servicePath is not None:
+ tmp=self.servicePath[:]
+ tmp.append(ref)
+ try:
+ del self.history[self.history_pos+1:]
+ except:
+ pass
+ self.history.append(tmp)
+ hlen = len(self.history)
+ if hlen > HISTORYSIZE:
+ del self.history[0]
+ hlen -= 1
+ self.history_pos = hlen-1
def historyBack(self):
hlen = len(self.history)
def setHistoryPath(self):
path = self.history[self.history_pos][:]
ref = path.pop()
- self.servicePath = path
+ del self.servicePath[:]
+ self.servicePath += path
self.saveRoot()
plen = len(path)
root = path[plen-1]
def saveRoot(self):
path = ''
- for i in self.servicePathTV:
+ for i in self.servicePath:
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()
+ if len(path) and path != self.lastroot.value:
+ self.lastroot.value = path
+ self.lastroot.save()
def restoreRoot(self):
self.clearPath()
re = compile('.+?;')
- tmp = re.findall(config.tv.lastroot.value)
+ tmp = re.findall(self.lastroot.value)
cnt = 0
for i in tmp:
- self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
+ self.servicePath.append(eServiceReference(i[:len(i)-1]))
cnt += 1
if cnt:
- path = self.servicePathTV.pop()
+ path = self.servicePath.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 len(self.servicePath) and self.servicePath[0] != eServiceReference(refstr):
+ pathstr = self.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:
+ lastservice=eServiceReference(self.lastservice.value)
+ if lastservice.valid():
self.setCurrentSelection(lastservice)
return True
return False
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()
+ if refstr != self.lastservice.value:
+ self.lastservice.value = refstr
+ self.lastservice.save()
+
+ def setCurrentServicePath(self, path):
+ hlen = len(self.history)
+ if hlen > 0:
+ self.history[self.history_pos] = path
+ else:
+ self.history.append(path)
+ self.setHistoryPath()
+
+ def getCurrentServicePath(self):
+ hlen = len(self.history)
+ if hlen > 0:
+ return self.history[self.history_pos]
+ return None
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)
+ hlen = len(self.history)
+ if hlen > 1:
+ if self.history_pos == hlen-1:
+ tmp = self.history[self.history_pos]
+ self.history[self.history_pos] = self.history[self.history_pos-1]
+ self.history[self.history_pos-1] = tmp
+ else:
+ tmp = self.history[self.history_pos+1]
+ self.history[self.history_pos+1] = self.history[self.history_pos]
+ self.history[self.history_pos] = tmp
+ self.setHistoryPath()
def cancel(self):
+ if self.revertMode is None:
+ self.restoreRoot()
+ lastservice=eServiceReference(self.lastservice.value)
+ if lastservice.valid() and self.getCurrentSelection() != lastservice:
+ self.setCurrentSelection(lastservice)
+ elif self.revertMode == MODE_TV:
+ self.setModeTv()
+ elif self.revertMode == MODE_RADIO:
+ self.setModeRadio()
+ self.revertMode = None
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
InfoBarEvent.__init__(self)
InfoBarServiceName.__init__(self)
InfoBarInstantRecord.__init__(self)
- self["Clock"] = Clock()
+ self["CurrentTime"] = Clock()
class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
+
+ ALLOW_SUSPEND = True
+
def __init__(self, session):
ChannelSelectionBase.__init__(self, session)
ChannelSelectionEdit.__init__(self)
if pathstr is not None and pathstr.find(refstr) == 0:
self.restoreRoot()
lastservice=eServiceReference(config.radio.lastservice.value)
- if lastservice is not None:
+ if lastservice.valid():
self.setCurrentSelection(lastservice)
return True
return False
self.enterPath(ref)
elif self.bouquet_mark_edit:
self.doMark()
- else:
+ elif not (ref.flags & 64): # no marker
playingref = self.session.nav.getCurrentlyPlayingServiceReference()
if playingref is None or playingref != ref:
self.session.nav.playService(ref)
})
def __onExecCallback(self):
- self.session.currentDialog.instance.setTitle(self.title)
+ self.setTitle(self.title)
self.setModeTv()
def channelSelected(self): # just return selected service
ref = self.getCurrentSelection()
if (ref.flags & 7) == 7:
self.enterPath(ref)
- else:
+ elif not (ref.flags & 64):
ref = self.getCurrentSelection()
self.close(ref)