1 from Screen import Screen
2 from Components.Button import Button
3 from Components.ServiceList import ServiceList
4 from Components.ActionMap import NumberActionMap, ActionMap
5 from Components.MenuList import MenuList
6 from EpgSelection import EPGSelection
7 from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
8 from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
9 from Screens.FixedMenu import FixedMenu
10 from Tools.NumericalTextInput import NumericalTextInput
11 from Components.NimManager import nimmanager
12 from Components.ServiceName import ServiceName
13 from Components.Clock import Clock
14 from Components.EventInfo import EventInfo
15 from ServiceReference import ServiceReference
19 import xml.dom.minidom
21 class BouquetSelector(Screen):
22 def __init__(self, session, bouquets, selectedFunc):
23 Screen.__init__(self, session)
25 self.selectedFunc=selectedFunc
27 self["actions"] = ActionMap(["OkCancelActions"],
29 "ok": self.okbuttonClick,
30 "cancel": self.cancelClick
34 entrys.append((x[0], x[1]))
35 self["menu"] = MenuList(entrys)
37 def okbuttonClick(self):
38 self.selectedFunc(self["menu"].getCurrent()[1])
40 def cancelClick(self):
43 class ChannelContextMenu(Screen):
44 def __init__(self, session, csel):
45 Screen.__init__(self, session)
48 self["actions"] = ActionMap(["OkCancelActions"],
50 "ok": self.okbuttonClick,
51 "cancel": self.cancelClick
55 inBouquetRootList = csel.getRoot().getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
56 inBouquet = csel.getMutableList() is not None
57 haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
59 if not csel.bouquet_mark_edit and not csel.movemode:
60 if not inBouquetRootList:
61 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
63 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
65 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
67 if not inBouquet and csel.getCurrentSelection().getPath().find("PROVIDERS") == -1:
68 menu.append((_("copy to favourites"), csel.copyCurrentToBouquetList))
70 menu.append((_("remove service"), self.removeCurrentService))
72 menu.append((_("remove bouquet"), csel.removeBouquet))
74 if inBouquet: # current list is editable?
75 if not csel.bouquet_mark_edit:
77 menu.append((_("enable move mode"), self.toggleMoveMode))
78 if not inBouquetRootList:
80 menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
82 menu.append((_("enable favourite edit"), self.bouquetMarkStart))
84 menu.append((_("disable move mode"), self.toggleMoveMode))
85 elif not inBouquetRootList:
87 menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
88 menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
90 menu.append((_("end favourites edit"), self.bouquetMarkEnd))
91 menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
93 menu.append((_("back"), self.cancelClick))
94 self["menu"] = MenuList(menu)
96 def okbuttonClick(self):
97 self["menu"].getCurrent()[1]()
99 def cancelClick(self):
102 def addServiceToBouquetSelected(self):
103 bouquets = self.csel.getBouquetList()
108 if cnt > 1: # show bouquet list
109 self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
110 elif cnt == 1: # add to only one existing bouquet
111 self.addCurrentServiceToBouquet(bouquets[0][1])
112 else: #no bouquets in root.. so assume only one favourite list is used
113 self.addCurrentServiceToBouquet(self.csel.bouquet_root)
115 def bouquetSelClosed(self, recursive):
119 def copyCurrentToBouquetList(self):
120 self.csel.copyCurrentToBouquetList()
123 def removeBouquet(self):
124 self.csel.removeBouquet()
127 def addCurrentServiceToBouquet(self, dest):
128 self.csel.addCurrentServiceToBouquet(dest)
129 self.close(True) # close bouquet selection
131 def removeCurrentService(self):
132 self.csel.removeCurrentService()
135 def toggleMoveMode(self):
136 self.csel.toggleMoveMode()
139 def bouquetMarkStart(self):
140 self.csel.startMarkedEdit()
143 def bouquetMarkEnd(self):
144 self.csel.endMarkedEdit(abort=False)
147 def bouquetMarkAbort(self):
148 self.csel.endMarkedEdit(abort=True)
151 class ChannelSelectionEPG:
153 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
155 "showEPGList": self.showEPGList,
158 def showEPGList(self):
159 ref=self.getCurrentSelection()
160 ptr=eEPGCache.getInstance()
161 if ptr.startTimeQuery(ref) != -1:
162 self.session.open(EPGSelection, ref)
164 print 'no epg for service', ref.toString()
166 class ChannelSelectionEdit:
168 self.entry_marked = False
169 self.movemode = False
170 self.bouquet_mark_edit = False
171 self.mutableList = None
173 self.saved_title = None
174 self.saved_root = None
176 class ChannelSelectionEditActionMap(ActionMap):
177 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
178 ActionMap.__init__(self, contexts, actions, prio)
180 def action(self, contexts, action):
181 if action == "cancel":
182 self.csel.handleEditCancel()
184 pass # avoid typo warning...
186 ActionMap.action(self, contexts, action)
187 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
189 "contextMenu": self.doContext,
192 def getMutableList(self, root=eServiceReference()):
193 if not self.mutableList is None:
194 return self.mutableList
195 serviceHandler = eServiceCenter.getInstance()
198 list = serviceHandler.list(root)
200 return list.startEdit()
203 def buildBouquetID(self, str):
207 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
213 def copyCurrentToBouquetList(self):
214 provider = ServiceReference(self.getCurrentSelection())
215 serviceHandler = eServiceCenter.getInstance()
216 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
217 if mutableBouquetList:
218 providerName = provider.getServiceName()
219 if self.mode == MODE_TV:
220 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
222 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
223 new_bouquet_ref = eServiceReference(str)
224 if not mutableBouquetList.addService(new_bouquet_ref):
225 self.bouquetNumOffsetCache = { }
226 mutableBouquetList.flushChanges()
227 eDVBDB.getInstance().reloadBouquets()
228 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
230 mutableBouquet.setListName(providerName)
232 services = serviceHandler.list(provider.ref)
233 if not services is None:
234 if not services.getContent(list, True):
236 if mutableBouquet.addService(service):
237 print "add", service.toString(), "to new bouquet failed"
238 mutableBouquet.flushChanges()
240 print "getContent failed"
242 print "list provider", providerName, "failed"
244 print "get mutable list for new created bouquet failed"
246 print "add", str, "to bouquets failed"
248 print "bouquetlist is not editable"
250 def removeBouquet(self):
251 refstr = self.getCurrentSelection().toString()
252 self.bouquetNumOffsetCache = { }
253 pos = refstr.find('FROM BOUQUET "')
255 refstr = refstr[pos+14:]
256 pos = refstr.find('"')
258 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
259 self.removeCurrentService()
261 eDVBDB.getInstance().reloadBouquets()
263 # multiple marked entry stuff ( edit mode, later multiepg selection )
264 def startMarkedEdit(self):
265 self.mutableList = self.getMutableList()
266 # add all services from the current list to internal marked set in listboxservicecontent
267 self.bouquetRoot = self.getRoot()
268 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
269 self.saved_title = self.instance.getTitle()
270 new_title = self.saved_title
271 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
272 new_title += ' ' + _("[bouquet edit]")
274 new_title += ' ' + _("[favourite edit]")
275 self.instance.setTitle(new_title)
276 self.bouquet_mark_edit = True
277 self.__marked = self.servicelist.getRootServices()
278 for x in self.__marked:
279 self.servicelist.addMarked(eServiceReference(x))
280 self.savedPath = self.servicePath[:]
281 self.showAllServices()
283 def endMarkedEdit(self, abort):
284 if not abort and self.mutableList is not None:
285 self.bouquetNumOffsetCache = { }
286 new_marked = set(self.servicelist.getMarked())
287 old_marked = set(self.__marked)
288 removed = old_marked - new_marked
289 added = new_marked - old_marked
293 self.mutableList.removeService(eServiceReference(x))
296 self.mutableList.addService(eServiceReference(x))
298 self.mutableList.flushChanges()
301 self.bouquet_mark_edit = False
302 self.bouquetRoot = None
303 self.mutableList = None
304 self.instance.setTitle(self.saved_title)
305 self.saved_title = None
306 self.servicePath = self.savedPath[:]
308 self.setRoot(self.servicePath[len(self.servicePath-1)])
310 def clearMarks(self):
311 self.servicelist.clearMarks()
314 ref = self.servicelist.getCurrent()
315 if self.servicelist.isMarked(ref):
316 self.servicelist.removeMarked(ref)
318 self.servicelist.addMarked(ref)
320 def removeCurrentService(self):
321 ref = self.servicelist.getCurrent()
322 mutableList = self.getMutableList()
323 if ref.valid() and mutableList is not None:
324 if not mutableList.removeService(ref):
325 self.bouquetNumOffsetCache = { }
326 currentIndex = self.servicelist.getCurrentIndex()
327 self.servicelist.moveDown()
328 if self.servicelist.getCurrentIndex() == currentIndex:
330 mutableList.flushChanges() #FIXME dont flush on each single removed service
331 self.setRoot(self.getRoot())
332 self.servicelist.moveToIndex(currentIndex)
334 def addCurrentServiceToBouquet(self, dest):
335 mutableList = self.getMutableList(dest)
336 if not mutableList is None:
337 if not mutableList.addService(self.servicelist.getCurrent()):
338 self.bouquetNumOffsetCache = { }
339 mutableList.flushChanges()
342 def toggleMoveMode(self):
344 if self.entry_marked:
345 self.toggleMoveMarked() # unmark current entry
346 self.movemode = False
347 self.pathChangedDisabled = False # re-enable path change
348 self.mutableList.flushChanges() # FIXME add check if changes was made
349 self.mutableList = None
350 self.instance.setTitle(self.saved_title)
351 self.saved_title = None
352 if self.getRoot() == self.bouquet_root:
353 self.bouquetNumOffsetCache = { }
355 self.mutableList = self.getMutableList()
357 self.pathChangedDisabled = True # no path change allowed in movemode
358 self.saved_title = self.instance.getTitle()
359 new_title = self.saved_title
360 new_title += ' ' + _("[move mode]");
361 self.instance.setTitle(new_title);
363 def handleEditCancel(self):
364 if self.movemode: #movemode active?
365 self.channelSelected() # unmark
366 self.toggleMoveMode() # disable move mode
367 elif self.bouquet_mark_edit:
368 self.endMarkedEdit(True) # abort edit mode
370 def toggleMoveMarked(self):
371 if self.entry_marked:
372 self.servicelist.setCurrentMarked(False)
373 self.entry_marked = False
375 self.servicelist.setCurrentMarked(True)
376 self.entry_marked = True
379 self.session.open(ChannelContextMenu, self)
384 class ChannelSelectionBase(Screen):
385 def __init__(self, session):
386 Screen.__init__(self, session)
388 # this makes it much simple to implement a selectable radio or tv mode :)
389 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
390 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
392 self["key_red"] = Button(_("All"))
393 self["key_green"] = Button(_("Satellites"))
394 self["key_yellow"] = Button(_("Provider"))
395 self["key_blue"] = Button(_("Favourites"))
397 self["list"] = ServiceList()
398 self.servicelist = self["list"]
400 self.numericalTextInput = NumericalTextInput()
402 self.servicePathTV = [ ]
403 self.servicePathRadio = [ ]
404 self.servicePath = None
406 self.pathChangedDisabled = False
408 self.bouquetNumOffsetCache = { }
410 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
412 "showFavourites": self.showFavourites,
413 "showAllServices": self.showAllServices,
414 "showProviders": self.showProviders,
415 "showSatellites": self.showSatellites,
416 "nextBouquet": self.nextBouquet,
417 "prevBouquet": self.prevBouquet,
418 "1": self.keyNumberGlobal,
419 "2": self.keyNumberGlobal,
420 "3": self.keyNumberGlobal,
421 "4": self.keyNumberGlobal,
422 "5": self.keyNumberGlobal,
423 "6": self.keyNumberGlobal,
424 "7": self.keyNumberGlobal,
425 "8": self.keyNumberGlobal,
426 "9": self.keyNumberGlobal,
427 "0": self.keyNumberGlobal
430 def appendDVBTypes(self, ref):
432 pos = path.find(' FROM BOUQUET')
434 return eServiceReference(self.service_types + path[pos:])
437 def getBouquetNumOffset(self, bouquet):
438 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
440 bouquet = self.appendDVBTypes(bouquet)
442 return self.bouquetNumOffsetCache[bouquet.toString()]
445 serviceHandler = eServiceCenter.getInstance()
446 bouquetlist = serviceHandler.list(self.bouquet_root)
447 if not bouquetlist is None:
449 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
450 if not bouquetIterator.valid(): #end of list
452 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
453 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
455 servicelist = serviceHandler.list(bouquetIterator)
456 if not servicelist is None:
458 serviceIterator = servicelist.getNext()
459 if not serviceIterator.valid(): #check if end of list
461 if serviceIterator.flags: #playable services have no flags
464 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
466 def recallBouquetMode(self):
467 if self.mode == MODE_TV:
468 self.service_types = self.service_types_tv
469 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
470 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
472 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
474 self.service_types = self.service_types_radio
475 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
476 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
478 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
479 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
482 title = self.instance.getTitle()
483 pos = title.find(" (")
487 self.instance.setTitle(title)
489 self.servicePath = self.servicePathTV
490 self.recallBouquetMode()
492 def setRadioMode(self):
493 title = self.instance.getTitle()
494 pos = title.find(" (")
498 self.instance.setTitle(title)
499 self.mode = MODE_RADIO
500 self.servicePath = self.servicePathRadio
501 self.recallBouquetMode()
503 def setRoot(self, root, justSet=False):
504 path = root.getPath()
505 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
506 pos = path.find(' FROM BOUQUET')
507 isBouquet = pos != -1
508 if not inBouquetRootList and isBouquet:
509 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
510 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
511 refstr = self.service_types + path[pos:]
512 root = eServiceReference(refstr)
514 self.servicelist.setMode(ServiceList.MODE_NORMAL)
515 self.servicelist.setRoot(root, justSet)
518 self.servicelist.moveUp()
521 self.servicelist.moveDown()
524 del self.servicePath[:]
526 def enterPath(self, ref, justSet=False):
527 self.servicePath.append(ref)
528 self.setRoot(ref, justSet)
530 def pathUp(self, justSet=False):
531 prev = self.servicePath.pop()
532 length = len(self.servicePath)
534 current = self.servicePath[length-1]
535 self.setRoot(current, justSet)
537 self.setCurrentSelection(prev)
540 def isBasePathEqual(self, ref):
541 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
545 def isPrevPathEqual(self, ref):
546 length = len(self.servicePath)
547 if length > 1 and self.servicePath[length-2] == ref:
551 def preEnterPath(self, refstr):
554 def showAllServices(self):
555 if not self.pathChangedDisabled:
556 refstr = '%s ORDER BY name'%(self.service_types)
557 if not self.preEnterPath(refstr):
558 ref = eServiceReference(refstr)
559 currentRoot = self.getRoot()
560 if currentRoot is None or currentRoot != ref:
564 def showSatellites(self):
565 if not self.pathChangedDisabled:
566 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
567 if not self.preEnterPath(refstr):
568 ref = eServiceReference(refstr)
572 if self.isBasePathEqual(ref):
573 if self.isPrevPathEqual(ref):
575 prev = self.pathUp(justSet)
577 currentRoot = self.getRoot()
578 if currentRoot is None or currentRoot != ref:
581 self.enterPath(ref, True)
583 serviceHandler = eServiceCenter.getInstance()
584 servicelist = serviceHandler.list(ref)
585 if not servicelist is None:
587 service = servicelist.getNext()
588 if not service.valid(): #check if end of list
590 orbpos = service.getData(4) >> 16
591 if service.getPath().find("FROM PROVIDER") != -1:
592 service_name = _("Providers")
594 service_name = _("Services")
596 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
597 service.setName(service_name) # why we need this cast?
599 if orbpos > 1800: # west
600 service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
602 service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
603 self.servicelist.addService(service)
604 self.servicelist.finishFill()
606 self.setCurrentSelection(prev)
608 def showProviders(self):
609 if not self.pathChangedDisabled:
610 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
611 if not self.preEnterPath(refstr):
612 ref = eServiceReference(refstr)
613 if self.isBasePathEqual(ref):
616 currentRoot = self.getRoot()
617 if currentRoot is None or currentRoot != ref:
621 def changeBouquet(self, direction):
622 if not self.pathChangedDisabled:
623 if self.isBasePathEqual(self.bouquet_root):
629 ref = self.getCurrentSelection()
633 return self.isBasePathEqual(self.bouquet_root)
636 return self.servicelist.atBegin()
639 return self.servicelist.atEnd()
641 def nextBouquet(self):
642 self.changeBouquet(+1)
644 def prevBouquet(self):
645 self.changeBouquet(-1)
647 def showFavourites(self):
648 if not self.pathChangedDisabled:
649 if not self.preEnterPath(self.bouquet_rootstr):
650 if self.isBasePathEqual(self.bouquet_root):
653 currentRoot = self.getRoot()
654 if currentRoot is None or currentRoot != self.bouquet_root:
656 self.enterPath(self.bouquet_root)
658 def keyNumberGlobal(self, number):
659 char = self.numericalTextInput.getKey(number)
660 self.servicelist.moveToChar(char)
663 return self.servicelist.getRoot()
665 def getCurrentSelection(self):
666 return self.servicelist.getCurrent()
668 def setCurrentSelection(self, service):
669 servicepath = service.getPath()
670 pos = servicepath.find(" FROM BOUQUET")
672 if self.mode == MODE_TV:
673 servicepath = '(type == 1)' + servicepath[pos:]
675 servicepath = '(type == 2)' + servicepath[pos:]
676 service.setPath(servicepath)
677 self.servicelist.setCurrent(service)
679 def getBouquetList(self):
682 serviceHandler = eServiceCenter.getInstance()
683 list = serviceHandler.list(self.bouquet_root)
689 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
690 info = serviceHandler.info(s)
692 bouquets.append((info.getName(s), s))
695 if len(bouquets) == 0 and serviceCount > 0:
696 info = serviceHandler.info(self.bouquet_root)
698 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
702 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
703 def __init__(self, session):
704 ChannelSelectionBase.__init__(self,session)
705 ChannelSelectionEdit.__init__(self)
706 ChannelSelectionEPG.__init__(self)
708 #config for lastservice
709 config.tv = ConfigSubsection();
710 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
711 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
712 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
713 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
715 self["actions"] = ActionMap(["OkCancelActions"],
717 "cancel": self.cancel,
718 "ok": self.channelSelected,
720 self.onShown.append(self.__onShown)
722 self.lastChannelRootTimer = eTimer()
723 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
724 self.lastChannelRootTimer.start(100,True)
726 def __onCreate(self):
729 lastservice=eServiceReference(config.tv.lastservice.value)
730 if lastservice.valid():
731 self.setCurrentSelection(lastservice)
732 self.session.nav.playService(lastservice)
735 self.recallBouquetMode()
736 ref = self.session.nav.getCurrentlyPlayingServiceReference()
737 if ref is not None and ref.valid() and ref.getPath() == "":
738 self.servicelist.setPlayableIgnoreService(ref)
740 self.servicelist.setPlayableIgnoreService(eServiceReference())
742 def channelSelected(self):
743 ref = self.getCurrentSelection()
745 self.toggleMoveMarked()
746 elif (ref.flags & 7) == 7:
748 elif self.bouquet_mark_edit:
754 #called from infoBar and channelSelected
756 ref = self.session.nav.getCurrentlyPlayingServiceReference()
757 if ref is None or ref != self.getCurrentSelection():
758 self.session.nav.playService(self.getCurrentSelection())
764 for i in self.servicePathTV:
767 if config.tv.prevroot.value != config.tv.lastroot.value:
768 config.tv.prevroot.value = config.tv.lastroot.value
769 config.tv.prevroot.save()
770 if len(path) and path != config.tv.lastroot.value:
771 config.tv.lastroot.value = path
772 config.tv.lastroot.save()
774 def restoreRoot(self):
777 tmp = re.findall(config.tv.lastroot.value)
780 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
783 path = self.servicePathTV.pop()
786 self.showFavourites()
789 def preEnterPath(self, refstr):
790 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
791 pathstr = config.tv.lastroot.value
792 if pathstr is not None and pathstr.find(refstr) == 0:
794 lastservice=eServiceReference(config.tv.lastservice.value)
795 if lastservice is not None:
796 self.setCurrentSelection(lastservice)
800 def saveChannel(self):
801 ref = self.session.nav.getCurrentlyPlayingServiceReference()
803 refstr = ref.toString()
806 if refstr != config.tv.lastservice.value:
807 config.tv.prevservice.value = config.tv.lastservice.value
808 config.tv.prevservice.save()
809 config.tv.lastservice.value = refstr
810 config.tv.lastservice.save()
812 def recallPrevService(self):
813 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
814 if config.tv.lastroot.value != config.tv.prevroot.value:
815 tmp = config.tv.lastroot.value
816 config.tv.lastroot.value = config.tv.prevroot.value
817 config.tv.lastroot.save()
818 config.tv.prevroot.value = tmp
819 config.tv.prevroot.save()
821 if config.tv.lastservice.value != config.tv.prevservice.value:
822 tmp = config.tv.lastservice.value
823 config.tv.lastservice.value = config.tv.prevservice.value
824 config.tv.lastservice.save()
825 config.tv.prevservice.value = tmp
826 config.tv.prevservice.save()
827 lastservice=eServiceReference(config.tv.lastservice.value)
828 self.session.nav.playService(lastservice)
829 self.setCurrentSelection(lastservice)
834 lastservice=eServiceReference(config.tv.lastservice.value)
835 if lastservice.valid() and self.getCurrentSelection() != lastservice:
836 self.setCurrentSelection(lastservice)
838 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
840 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
841 def __init__(self, session):
842 Screen.__init__(self, session)
843 InfoBarEvent.__init__(self)
844 InfoBarServiceName.__init__(self)
845 InfoBarInstantRecord.__init__(self)
846 self["Clock"] = Clock()
848 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
849 def __init__(self, session):
850 ChannelSelectionBase.__init__(self, session)
851 ChannelSelectionEdit.__init__(self)
852 ChannelSelectionEPG.__init__(self)
854 config.radio = ConfigSubsection();
855 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
856 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
857 self.onLayoutFinish.append(self.onCreate)
859 self.info = session.instantiateDialog(RadioInfoBar)
861 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
863 "keyTV": self.closeRadio,
864 "keyRadio": self.closeRadio,
865 "cancel": self.closeRadio,
866 "ok": self.channelSelected,
871 for i in self.servicePathRadio:
874 if len(path) and path != config.radio.lastroot.value:
875 config.radio.lastroot.value = path
876 config.radio.lastroot.save()
878 def restoreRoot(self):
881 tmp = re.findall(config.radio.lastroot.value)
884 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
887 path = self.servicePathRadio.pop()
890 self.showFavourites()
893 def preEnterPath(self, refstr):
894 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
895 pathstr = config.radio.lastroot.value
896 if pathstr is not None and pathstr.find(refstr) == 0:
898 lastservice=eServiceReference(config.radio.lastservice.value)
899 if lastservice is not None:
900 self.setCurrentSelection(lastservice)
907 lastservice=eServiceReference(config.radio.lastservice.value)
908 if lastservice.valid():
909 self.servicelist.setCurrent(lastservice)
910 self.session.nav.playService(lastservice)
911 self.servicelist.setPlayableIgnoreService(lastservice)
914 def channelSelected(self): # just return selected service
915 ref = self.getCurrentSelection()
917 self.toggleMoveMarked()
918 elif (ref.flags & 7) == 7:
920 elif self.bouquet_mark_edit:
923 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
924 if playingref is None or playingref != ref:
925 self.session.nav.playService(ref)
926 self.servicelist.setPlayableIgnoreService(ref)
927 config.radio.lastservice.value = ref.toString()
928 config.radio.lastservice.save()
931 def closeRadio(self):
933 #set previous tv service
934 lastservice=eServiceReference(config.tv.lastservice.value)
935 self.session.nav.playService(lastservice)
938 class SimpleChannelSelection(ChannelSelectionBase):
939 def __init__(self, session, title):
940 ChannelSelectionBase.__init__(self, session)
942 self.onShown.append(self.__onExecCallback)
944 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
946 "cancel": self.close,
947 "ok": self.channelSelected,
948 "keyRadio": self.setModeRadio,
949 "keyTV": self.setModeTv,
952 def __onExecCallback(self):
953 self.session.currentDialog.instance.setTitle(self.title)
956 def channelSelected(self): # just return selected service
957 ref = self.getCurrentSelection()
958 if (ref.flags & 7) == 7:
961 ref = self.getCurrentSelection()
966 self.showFavourites()
968 def setModeRadio(self):
970 self.showFavourites()