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 mutableBouquetList.flushChanges()
226 eDVBDB.getInstance().reloadBouquets()
227 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
229 mutableBouquet.setListName(providerName)
231 services = serviceHandler.list(provider.ref)
232 if not services is None:
233 if not services.getContent(list, True):
235 if mutableBouquet.addService(service):
236 print "add", service.toString(), "to new bouquet failed"
237 mutableBouquet.flushChanges()
239 print "getContent failed"
241 print "list provider", providerName, "failed"
243 print "get mutable list for new created bouquet failed"
245 print "add", str, "to bouquets failed"
247 print "bouquetlist is not editable"
249 def removeBouquet(self):
250 refstr = self.getCurrentSelection().toString()
251 pos = refstr.find('FROM BOUQUET "')
253 refstr = refstr[pos+14:]
255 pos = refstr.find('"')
257 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
258 self.removeCurrentService()
260 eDVBDB.getInstance().reloadBouquets()
262 # multiple marked entry stuff ( edit mode, later multiepg selection )
263 def startMarkedEdit(self):
264 self.mutableList = self.getMutableList()
265 # add all services from the current list to internal marked set in listboxservicecontent
266 self.bouquetRoot = self.getRoot()
267 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
268 self.saved_title = self.instance.getTitle()
269 new_title = self.saved_title
270 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
271 new_title += ' ' + _("[bouquet edit]")
273 new_title += ' ' + _("[favourite edit]")
274 self.instance.setTitle(new_title)
275 self.bouquet_mark_edit = True
276 self.__marked = self.servicelist.getRootServices()
277 for x in self.__marked:
278 self.servicelist.addMarked(eServiceReference(x))
279 self.saved_root = self.getRoot()
280 self.showAllServices()
282 def endMarkedEdit(self, abort):
283 if not abort and self.mutableList is not None:
284 new_marked = set(self.servicelist.getMarked())
285 old_marked = set(self.__marked)
286 removed = old_marked - new_marked
287 added = new_marked - old_marked
291 self.mutableList.removeService(eServiceReference(x))
294 self.mutableList.addService(eServiceReference(x))
296 self.mutableList.flushChanges()
299 self.bouquet_mark_edit = False
300 self.bouquetRoot = None
301 self.mutableList = None
302 self.instance.setTitle(self.saved_title)
303 self.saved_title = None
304 self.setRoot(self.saved_root)
306 def clearMarks(self):
307 self.servicelist.clearMarks()
310 ref = self.servicelist.getCurrent()
311 if self.servicelist.isMarked(ref):
312 self.servicelist.removeMarked(ref)
314 self.servicelist.addMarked(ref)
316 def removeCurrentService(self):
317 ref = self.servicelist.getCurrent()
318 mutableList = self.getMutableList()
319 if ref.valid() and mutableList is not None:
320 if not mutableList.removeService(ref):
321 currentIndex = self.servicelist.getCurrentIndex()
322 self.servicelist.moveDown()
323 if self.servicelist.getCurrentIndex() == currentIndex:
325 mutableList.flushChanges() #FIXME dont flush on each single removed service
326 self.setRoot(self.getRoot())
327 self.servicelist.moveToIndex(currentIndex)
329 def addCurrentServiceToBouquet(self, dest):
330 mutableList = self.getMutableList(dest)
331 if not mutableList is None:
332 if not mutableList.addService(self.servicelist.getCurrent()):
333 mutableList.flushChanges()
336 def toggleMoveMode(self):
338 if self.entry_marked:
339 self.toggleMoveMarked() # unmark current entry
340 self.movemode = False
341 self.pathChangedDisabled = False # re-enable path change
342 self.mutableList.flushChanges() # FIXME add check if changes was made
343 self.mutableList = None
344 self.instance.setTitle(self.saved_title)
345 self.saved_title = None
347 self.mutableList = self.getMutableList()
349 self.pathChangedDisabled = True # no path change allowed in movemode
350 self.saved_title = self.instance.getTitle()
351 new_title = self.saved_title
352 new_title += ' ' + _("[move mode]");
353 self.instance.setTitle(new_title);
355 def handleEditCancel(self):
356 if self.movemode: #movemode active?
357 self.channelSelected() # unmark
358 self.toggleMoveMode() # disable move mode
359 elif self.bouquet_mark_edit:
360 self.endMarkedEdit(True) # abort edit mode
362 def toggleMoveMarked(self):
363 if self.entry_marked:
364 self.servicelist.setCurrentMarked(False)
365 self.entry_marked = False
367 self.servicelist.setCurrentMarked(True)
368 self.entry_marked = True
371 self.session.open(ChannelContextMenu, self)
376 class ChannelSelectionBase(Screen):
377 def __init__(self, session):
378 Screen.__init__(self, session)
380 # this makes it much simple to implement a selectable radio or tv mode :)
381 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
382 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
384 self["key_red"] = Button(_("All"))
385 self["key_green"] = Button(_("Satellites"))
386 self["key_yellow"] = Button(_("Provider"))
387 self["key_blue"] = Button(_("Favourites"))
389 self["list"] = ServiceList()
390 self.servicelist = self["list"]
392 self.numericalTextInput = NumericalTextInput()
394 self.servicePathTV = [ ]
395 self.servicePathRadio = [ ]
397 self.pathChangedDisabled = False
399 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
401 "showFavourites": self.showFavourites,
402 "showAllServices": self.showAllServices,
403 "showProviders": self.showProviders,
404 "showSatellites": self.showSatellites,
405 "nextBouquet": self.nextBouquet,
406 "prevBouquet": self.prevBouquet,
407 "1": self.keyNumberGlobal,
408 "2": self.keyNumberGlobal,
409 "3": self.keyNumberGlobal,
410 "4": self.keyNumberGlobal,
411 "5": self.keyNumberGlobal,
412 "6": self.keyNumberGlobal,
413 "7": self.keyNumberGlobal,
414 "8": self.keyNumberGlobal,
415 "9": self.keyNumberGlobal,
416 "0": self.keyNumberGlobal
419 def appendDVBTypes(self, ref):
421 pos = path.find(' FROM BOUQUET')
423 return eServiceReference(self.service_types + path[pos:])
426 def getBouquetNumOffset(self, bouquet):
427 bouquet = self.appendDVBTypes(bouquet)
428 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
431 serviceHandler = eServiceCenter.getInstance()
432 bouquetlist = serviceHandler.list(self.bouquet_root)
433 if not bouquetlist is None:
435 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
436 if not bouquetIterator.valid() or bouquetIterator == bouquet: #end of list or bouquet found
438 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
440 servicelist = serviceHandler.list(bouquetIterator)
441 if not servicelist is None:
443 serviceIterator = servicelist.getNext()
444 if not serviceIterator.valid(): #check if end of list
446 if serviceIterator.flags: #playable services have no flags
451 def recallBouquetMode(self):
452 if self.mode == MODE_TV:
453 self.service_types = self.service_types_tv
454 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
455 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
457 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
459 self.service_types = self.service_types_radio
460 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
461 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
463 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
464 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
467 title = self.instance.getTitle()
468 pos = title.find(" (")
472 self.instance.setTitle(title)
474 self.recallBouquetMode()
476 def setRadioMode(self):
477 title = self.instance.getTitle()
478 pos = title.find(" (")
482 self.instance.setTitle(title)
483 self.mode = MODE_RADIO
484 self.recallBouquetMode()
486 def setRoot(self, root, justSet=False):
487 path = root.getPath()
488 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
489 pos = path.find(' FROM BOUQUET')
490 isBouquet = pos != -1
491 if not inBouquetRootList and isBouquet:
492 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
493 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
494 refstr = self.service_types + path[pos:]
495 root = eServiceReference(refstr)
497 self.servicelist.setMode(ServiceList.MODE_NORMAL)
498 self.servicelist.setRoot(root, justSet)
501 self.servicelist.moveUp()
504 self.servicelist.moveDown()
507 if self.mode == MODE_RADIO:
508 self.servicePathRadio = [ ]
510 self.servicePathTV = [ ]
512 def enterPath(self, ref, justSet=False):
513 if self.mode == MODE_RADIO:
514 self.servicePathRadio.append(ref)
516 self.servicePathTV.append(ref)
517 self.setRoot(ref, justSet)
519 def pathUp(self, justSet=False):
520 if self.mode == MODE_TV:
521 prev = self.servicePathTV.pop()
522 length = len(self.servicePathTV)
524 current = self.servicePathTV[length-1]
526 prev = self.servicePathRadio.pop()
527 length = len(self.servicePathRadio)
529 current = self.servicePathRadio[length-1]
530 self.setRoot(current, justSet)
532 self.setCurrentSelection(prev)
535 def isBasePathEqual(self, ref):
536 if self.mode == MODE_RADIO and len(self.servicePathRadio) > 1 and self.servicePathRadio[0] == ref:
538 elif self.mode == MODE_TV and len(self.servicePathTV) > 1 and self.servicePathTV[0] == ref:
542 def isPrevPathEqual(self, ref):
543 path = self.servicePathRadio
544 if self.mode == MODE_TV:
545 path = self.servicePathTV
547 if length > 1 and path[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()
632 def nextBouquet(self):
633 self.changeBouquet(+1)
635 def prevBouquet(self):
636 self.changeBouquet(-1)
638 def showFavourites(self):
639 if not self.pathChangedDisabled:
640 if not self.preEnterPath(self.bouquet_rootstr):
641 if self.isBasePathEqual(self.bouquet_root):
644 currentRoot = self.getRoot()
645 if currentRoot is None or currentRoot != self.bouquet_root:
647 self.enterPath(self.bouquet_root)
649 def keyNumberGlobal(self, number):
650 char = self.numericalTextInput.getKey(number)
651 self.servicelist.moveToChar(char)
654 return self.servicelist.getRoot()
656 def getCurrentSelection(self):
657 return self.servicelist.getCurrent()
659 def setCurrentSelection(self, service):
660 servicepath = service.getPath()
661 pos = servicepath.find(" FROM BOUQUET")
663 if self.mode == MODE_TV:
664 servicepath = '(type == 1)' + servicepath[pos:]
666 servicepath = '(type == 2)' + servicepath[pos:]
667 service.setPath(servicepath)
668 self.servicelist.setCurrent(service)
670 def getBouquetList(self):
673 serviceHandler = eServiceCenter.getInstance()
674 list = serviceHandler.list(self.bouquet_root)
680 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
681 info = serviceHandler.info(s)
683 bouquets.append((info.getName(s), s))
686 if len(bouquets) == 0 and serviceCount > 0:
687 info = serviceHandler.info(self.bouquet_root)
689 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
693 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
694 def __init__(self, session):
695 ChannelSelectionBase.__init__(self,session)
696 ChannelSelectionEdit.__init__(self)
697 ChannelSelectionEPG.__init__(self)
699 #config for lastservice
700 config.tv = ConfigSubsection();
701 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
702 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
703 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
704 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
706 self["actions"] = ActionMap(["OkCancelActions"],
708 "cancel": self.cancel,
709 "ok": self.channelSelected,
711 self.onShown.append(self.__onShown)
713 self.lastChannelRootTimer = eTimer()
714 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
715 self.lastChannelRootTimer.start(100,True)
717 def __onCreate(self):
719 self.servicePathTV = [ ]
721 lastservice=eServiceReference(config.tv.lastservice.value)
722 if lastservice.valid():
723 self.setCurrentSelection(lastservice)
724 self.session.nav.playService(lastservice)
727 self.recallBouquetMode()
728 ref = self.session.nav.getCurrentlyPlayingServiceReference()
729 if ref is not None and ref.valid() and ref.getPath() == "":
730 self.servicelist.setPlayableIgnoreService(ref)
732 self.servicelist.setPlayableIgnoreService(eServiceReference())
734 def channelSelected(self):
735 ref = self.getCurrentSelection()
737 self.toggleMoveMarked()
738 elif (ref.flags & 7) == 7:
740 elif self.bouquet_mark_edit:
746 #called from infoBar and channelSelected
748 ref = self.session.nav.getCurrentlyPlayingServiceReference()
749 if ref is None or ref != self.getCurrentSelection():
750 self.session.nav.playService(self.getCurrentSelection())
756 for i in self.servicePathTV:
759 if config.tv.prevroot.value != config.tv.lastroot.value:
760 config.tv.prevroot.value = config.tv.lastroot.value
761 config.tv.prevroot.save()
762 if len(path) and path != config.tv.lastroot.value:
763 config.tv.lastroot.value = path
764 config.tv.lastroot.save()
766 def restoreRoot(self):
767 self.servicePathTV = [ ]
769 tmp = re.findall(config.tv.lastroot.value)
772 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
775 path = self.servicePathTV.pop()
778 self.showFavourites()
781 def preEnterPath(self, refstr):
782 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
783 pathstr = config.tv.lastroot.value
784 if pathstr is not None and pathstr.find(refstr) == 0:
786 lastservice=eServiceReference(config.tv.lastservice.value)
787 if lastservice is not None:
788 self.setCurrentSelection(lastservice)
792 def saveChannel(self):
793 ref = self.session.nav.getCurrentlyPlayingServiceReference()
795 refstr = ref.toString()
798 if refstr != config.tv.lastservice.value:
799 config.tv.prevservice.value = config.tv.lastservice.value
800 config.tv.prevservice.save()
801 config.tv.lastservice.value = refstr
802 config.tv.lastservice.save()
804 def recallPrevService(self):
805 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
806 if config.tv.lastroot.value != config.tv.prevroot.value:
807 tmp = config.tv.lastroot.value
808 config.tv.lastroot.value = config.tv.prevroot.value
809 config.tv.lastroot.save()
810 config.tv.prevroot.value = tmp
811 config.tv.prevroot.save()
813 if config.tv.lastservice.value != config.tv.prevservice.value:
814 tmp = config.tv.lastservice.value
815 config.tv.lastservice.value = config.tv.prevservice.value
816 config.tv.lastservice.save()
817 config.tv.prevservice.value = tmp
818 config.tv.prevservice.save()
819 lastservice=eServiceReference(config.tv.lastservice.value)
820 self.session.nav.playService(lastservice)
821 self.setCurrentSelection(lastservice)
826 lastservice=eServiceReference(config.tv.lastservice.value)
827 if lastservice.valid() and self.getCurrentSelection() != lastservice:
828 self.setCurrentSelection(lastservice)
830 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
832 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
833 def __init__(self, session):
834 Screen.__init__(self, session)
835 InfoBarEvent.__init__(self)
836 InfoBarServiceName.__init__(self)
837 InfoBarInstantRecord.__init__(self)
838 self["Clock"] = Clock()
840 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
841 def __init__(self, session):
842 ChannelSelectionBase.__init__(self, session)
843 ChannelSelectionEdit.__init__(self)
844 ChannelSelectionEPG.__init__(self)
846 config.radio = ConfigSubsection();
847 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
848 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
849 self.onLayoutFinish.append(self.onCreate)
851 self.info = session.instantiateDialog(RadioInfoBar)
853 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
855 "keyTV": self.closeRadio,
856 "keyRadio": self.closeRadio,
857 "cancel": self.closeRadio,
858 "ok": self.channelSelected,
863 for i in self.servicePathRadio:
866 if len(path) and path != config.radio.lastroot.value:
867 config.radio.lastroot.value = path
868 config.radio.lastroot.save()
870 def restoreRoot(self):
871 self.servicePathRadio = [ ]
873 tmp = re.findall(config.radio.lastroot.value)
876 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
879 path = self.servicePathRadio.pop()
882 self.showFavourites()
885 def preEnterPath(self, refstr):
886 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
887 pathstr = config.radio.lastroot.value
888 if pathstr is not None and pathstr.find(refstr) == 0:
890 lastservice=eServiceReference(config.radio.lastservice.value)
891 if lastservice is not None:
892 self.setCurrentSelection(lastservice)
899 lastservice=eServiceReference(config.radio.lastservice.value)
900 if lastservice.valid():
901 self.servicelist.setCurrent(lastservice)
902 self.session.nav.playService(lastservice)
903 self.servicelist.setPlayableIgnoreService(lastservice)
906 def channelSelected(self): # just return selected service
907 ref = self.getCurrentSelection()
909 self.toggleMoveMarked()
910 elif (ref.flags & 7) == 7:
912 elif self.bouquet_mark_edit:
915 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
916 if playingref is None or playingref != ref:
917 self.session.nav.playService(ref)
918 self.servicelist.setPlayableIgnoreService(ref)
919 config.radio.lastservice.value = ref.toString()
920 config.radio.lastservice.save()
923 def closeRadio(self):
925 #set previous tv service
926 lastservice=eServiceReference(config.tv.lastservice.value)
927 self.session.nav.playService(lastservice)
930 class SimpleChannelSelection(ChannelSelectionBase):
931 def __init__(self, session, title):
932 ChannelSelectionBase.__init__(self, session)
934 self.onShown.append(self.__onExecCallback)
936 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
938 "cancel": self.cancel,
939 "ok": self.channelSelected,
940 "keyRadio": self.setModeRadio,
941 "keyTV": self.setModeTv,
944 def __onExecCallback(self):
945 self.session.currentDialog.instance.setTitle(self.title)
948 def channelSelected(self): # just return selected service
949 ref = self.getCurrentSelection()
950 if (ref.flags & 7) == 7:
953 ref = self.getCurrentSelection()
958 self.showFavourites()
960 def setModeRadio(self):
962 self.showFavourites()