from Components.ServiceName import ServiceName
from Components.Clock import Clock
from Components.EventInfo import EventInfo
+from Components.Input import Input
+from Screens.InputBox import InputBox
from ServiceReference import ServiceReference
from re import *
from os import remove
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))
+ menu.append((_("copy to favourites"), self.copyCurrentToBouquetList))
if inBouquet:
menu.append((_("remove service"), self.removeCurrentService))
elif haveBouquets:
- menu.append((_("remove bouquet"), csel.removeBouquet))
+ menu.append((_("remove bouquet"), self.removeBouquet))
if inBouquet: # current list is editable?
if not csel.bouquet_mark_edit:
if not csel.movemode:
menu.append((_("enable move mode"), self.toggleMoveMode))
+ menu.append((_("add bouquet..."), self.showBouquetInputBox))
if not inBouquetRootList:
if haveBouquets:
menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
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)
def addServiceToBouquetSelected(self):
bouquets = self.csel.getBouquetList()
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,
else:
name += '_'
return name
+
+ def addBouquet(self, providerName):
+ serviceHandler = eServiceCenter.getInstance()
+ mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
+ if mutableBouquetList:
+ if self.mode == MODE_TV:
+ providerName += " (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:
+ providerName += " (Radio)"
+ 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):
+ self.bouquetNumOffsetCache = { }
+ mutableBouquetList.flushChanges()
+ eDVBDB.getInstance().reloadBouquets()
+ mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
+ if mutableBouquet:
+ mutableBouquet.setListName(providerName)
+ mutableBouquet.flushChanges()
+ self.setRoot(self.getRoot())
+ else:
+ print "get mutable list for new created bouquet failed"
+ else:
+ print "add", str, "to bouquets failed"
+ else:
+ print "bouquetlist is not editable"
def copyCurrentToBouquetList(self):
provider = ServiceReference(self.getCurrentSelection())
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()
pos = self.saved_title.find(')')
new_title += ' ' + _("[bouquet edit]")
else:
new_title += ' ' + _("[favourite edit]")
- self.instance.setTitle(new_title)
- print new_title
+ self.setTitle(new_title)
self.bouquet_mark_edit = True
self.__marked = self.servicelist.getRootServices()
for x in self.__marked:
self.__marked = []
self.clearMarks()
self.bouquet_mark_edit = False
- self.bouquetRoot = None
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)
def addCurrentServiceToBouquet(self, dest):
mutableList = self.getMutableList(dest)
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?
self.servicePathTV = [ ]
self.servicePathRadio = [ ]
- self.servicePath = None
+ self.servicePath = [ ]
+
+ self.mode = MODE_TV
self.pathChangedDisabled = False
"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.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))
+ orbpos = 3600 - orbpos
+ h = _("W")
else:
- service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
+ 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:
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()
+
+HISTORYSIZE = 20
+
class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
def __init__(self, session):
ChannelSelectionBase.__init__(self,session)
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.lastChannelRootTimer.timeout.get().append(self.__onCreate)
self.lastChannelRootTimer.start(100,True)
+ self.history = [ ]
+ self.history_pos = 0
+
def __onCreate(self):
self.setTvMode()
self.restoreRoot()
lastservice=eServiceReference(config.tv.lastservice.value)
if lastservice.valid():
self.setCurrentSelection(lastservice)
- self.session.nav.playService(lastservice)
+ self.zap()
def __onShown(self):
self.recallBouquetMode()
#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())
+ nref = self.getCurrentSelection()
+ if ref is None or ref != nref:
+ self.session.nav.playService(nref)
self.saveRoot()
self.saveChannel()
+ if self.servicePath is not None:
+ 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
+
+ def historyBack(self):
+ hlen = len(self.history)
+ if hlen > 1 and self.history_pos > 0:
+ self.history_pos -= 1
+ self.setHistoryPath()
+
+ def historyNext(self):
+ hlen = len(self.history)
+ if hlen > 1 and self.history_pos < (hlen-1):
+ self.history_pos += 1
+ self.setHistoryPath()
+
+ def setHistoryPath(self):
+ path = self.history[self.history_pos][:]
+ ref = path.pop()
+ del self.servicePath[:]
+ self.servicePath += path
+ self.saveRoot()
+ plen = len(path)
+ root = path[plen-1]
+ if self.getRoot() != root:
+ self.setRoot(root)
+ self.session.nav.playService(ref)
+ self.setCurrentSelection(ref)
+ 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()
if pathstr is not None and pathstr.find(refstr) == 0:
self.restoreRoot()
lastservice=eServiceReference(config.tv.lastservice.value)
- if lastservice is not None:
+ if lastservice.valid():
self.setCurrentSelection(lastservice)
return True
return False
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)
+ 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):
self.close(None)
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
})
def __onExecCallback(self):
- self.session.currentDialog.instance.setTitle(self.title)
+ self.setTitle(self.title)
self.setModeTv()
def channelSelected(self): # just return selected service
git.cweiske.de / enigma2.git / blobdiff