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 EpgSelection import EPGSelection
6 from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer
7 from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
8 from Screens.FixedMenu import FixedMenu
9 from Tools.NumericalTextInput import NumericalTextInput
10 from Components.NimManager import nimmanager
11 from Components.ServiceName import ServiceName
12 from Components.Clock import Clock
13 from Components.EventInfo import EventInfo
16 import xml.dom.minidom
18 class BouquetSelector(FixedMenu):
19 def __init__(self, session, bouquets, selectedFunc):
20 self.selectedFunc=selectedFunc
23 entrys.append((x[0], self.bouquetSelected, x[1]))
24 FixedMenu.__init__(self, session, "Bouquetlist", entrys)
25 self.skinName = "Menu"
27 def bouquetSelected(self):
28 self.selectedFunc(self["menu"].getCurrent()[2])
30 class ChannelContextMenu(FixedMenu):
31 def __init__(self, session, csel):
36 inBouquetRootList = csel.getRoot().getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
37 inBouquet = csel.getMutableList() is not None
38 haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
40 if not csel.bouquet_mark_edit and not csel.movemode and not inBouquetRootList:
41 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
43 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
45 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
47 menu.append((_("remove service"), self.removeCurrentService))
49 if inBouquet: # current list is editable?
50 if not csel.bouquet_mark_edit:
52 menu.append((_("enable move mode"), self.toggleMoveMode))
53 if not inBouquetRootList:
55 menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
57 menu.append((_("enable favourite edit"), self.bouquetMarkStart))
59 menu.append((_("disable move mode"), self.toggleMoveMode))
60 elif not inBouquetRootList:
62 menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
63 menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
65 menu.append((_("end favourites edit"), self.bouquetMarkEnd))
66 menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
68 menu.append((_("back"), self.close))
70 FixedMenu.__init__(self, session, _("Channel Selection"), menu)
71 self.skinName = "Menu"
73 def addServiceToBouquetSelected(self):
74 bouquets = self.csel.getBouquetList()
79 if cnt > 1: # show bouquet list
80 self.session.open(BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
81 elif cnt == 1: # add to only one existing bouquet
82 self.addCurrentServiceToBouquet(bouquets[0][1])
83 else: #no bouquets in root.. so assume only one favourite list is used
84 self.addCurrentServiceToBouquet(self.csel.bouquet_root)
86 def addCurrentServiceToBouquet(self, dest):
87 self.csel.addCurrentServiceToBouquet(dest)
90 def removeCurrentService(self):
91 self.csel.removeCurrentService()
94 def toggleMoveMode(self):
95 self.csel.toggleMoveMode()
98 def bouquetMarkStart(self):
99 self.csel.startMarkedEdit()
102 def bouquetMarkEnd(self):
103 self.csel.endMarkedEdit(abort=False)
106 def bouquetMarkAbort(self):
107 self.csel.endMarkedEdit(abort=True)
110 class ChannelSelectionEPG:
112 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
114 "showEPGList": self.showEPGList,
117 def showEPGList(self):
118 ref=self.getCurrentSelection()
119 ptr=eEPGCache.getInstance()
120 if ptr.startTimeQuery(ref) != -1:
121 self.session.open(EPGSelection, ref)
123 print 'no epg for service', ref.toString()
125 class ChannelSelectionEdit:
127 self.entry_marked = False
128 self.movemode = False
129 self.bouquet_mark_edit = False
130 self.mutableList = None
132 self.saved_title = None
133 self.saved_root = None
135 class ChannelSelectionEditActionMap(ActionMap):
136 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
137 ActionMap.__init__(self, contexts, actions, prio)
139 def action(self, contexts, action):
140 if action == "cancel":
141 self.csel.handleEditCancel()
143 pass # avoid typo warning...
145 ActionMap.action(self, contexts, action)
146 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
148 "contextMenu": self.doContext,
151 def getMutableList(self, root=eServiceReference()):
152 if not self.mutableList is None:
153 return self.mutableList
154 serviceHandler = eServiceCenter.getInstance()
157 list = serviceHandler.list(root)
159 return list.startEdit()
162 # multiple marked entry stuff ( edit mode, later multiepg selection )
163 def startMarkedEdit(self):
164 self.mutableList = self.getMutableList()
165 # add all services from the current list to internal marked set in listboxservicecontent
166 self.bouquetRoot = self.getRoot()
167 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
168 self.saved_title = self.instance.getTitle()
169 new_title = self.saved_title
170 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
171 new_title += ' ' + _("[bouquet edit]")
173 new_title += ' ' + _("[favourite edit]")
174 self.instance.setTitle(new_title)
175 self.bouquet_mark_edit = True
176 self.__marked = self.servicelist.getRootServices()
177 for x in self.__marked:
178 self.servicelist.addMarked(eServiceReference(x))
179 self.saved_root = self.getRoot()
180 self.showAllServices()
182 def endMarkedEdit(self, abort):
183 if not abort and self.mutableList is not None:
184 new_marked = set(self.servicelist.getMarked())
185 old_marked = set(self.__marked)
186 removed = old_marked - new_marked
187 added = new_marked - old_marked
191 self.mutableList.removeService(eServiceReference(x))
194 self.mutableList.addService(eServiceReference(x))
196 self.mutableList.flushChanges()
199 self.bouquet_mark_edit = False
200 self.bouquetRoot = None
201 self.mutableList = None
202 self.instance.setTitle(self.saved_title)
203 self.saved_title = None
204 self.setRoot(self.saved_root)
206 def clearMarks(self):
207 self.servicelist.clearMarks()
210 ref = self.servicelist.getCurrent()
211 if self.servicelist.isMarked(ref):
212 self.servicelist.removeMarked(ref)
214 self.servicelist.addMarked(ref)
216 def removeCurrentService(self):
217 ref = self.servicelist.getCurrent()
218 mutableList = self.getMutableList()
219 if ref.valid() and mutableList is not None:
220 if not mutableList.removeService(ref):
221 currentIndex = self.servicelist.getCurrentIndex()
222 self.servicelist.moveDown()
223 if self.servicelist.getCurrentIndex() == currentIndex:
225 mutableList.flushChanges() #FIXME dont flush on each single removed service
226 self.setRoot(self.getRoot())
227 self.servicelist.moveToIndex(currentIndex)
229 def addCurrentServiceToBouquet(self, dest):
230 mutableList = self.getMutableList(dest)
231 if not mutableList is None:
232 if not mutableList.addService(self.servicelist.getCurrent()):
233 mutableList.flushChanges()
236 def toggleMoveMode(self):
238 if self.entry_marked:
239 self.toggleMoveMarked() # unmark current entry
240 self.movemode = False
241 self.pathChangedDisabled = True # re-enable path change
242 self.mutableList.flushChanges() # FIXME add check if changes was made
243 self.mutableList = None
244 self.instance.setTitle(self.saved_title)
245 self.saved_title = None
247 self.mutableList = self.getMutableList()
249 self.pathChangedDisabled = True # no path change allowed in movemode
250 self.saved_title = self.instance.getTitle()
251 new_title = self.saved_title
252 new_title += ' ' + _("[move mode]");
253 self.instance.setTitle(new_title);
255 def handleEditCancel(self):
256 if self.movemode: #movemode active?
257 self.channelSelected() # unmark
258 self.toggleMoveMode() # disable move mode
259 elif self.bouquet_mark_edit:
260 self.endMarkedEdit(True) # abort edit mode
262 def toggleMoveMarked(self):
263 if self.entry_marked:
264 self.servicelist.setCurrentMarked(False)
265 self.entry_marked = False
267 self.servicelist.setCurrentMarked(True)
268 self.entry_marked = True
271 self.session.open(ChannelContextMenu, self)
276 class ChannelSelectionBase(Screen):
277 def __init__(self, session):
278 Screen.__init__(self, session)
280 # this makes it much simple to implement a selectable radio or tv mode :)
281 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
282 self.service_types_radio = '1:7:1:0:0:0:0:0:0:0:(type == 2)'
284 self["key_red"] = Button(_("All"))
285 self["key_green"] = Button(_("Satellites"))
286 self["key_yellow"] = Button(_("Provider"))
287 self["key_blue"] = Button(_("Favourites"))
289 self["list"] = ServiceList()
290 self.servicelist = self["list"]
292 self.numericalTextInput = NumericalTextInput()
294 self.servicePathTV = [ ]
295 self.servicePathRadio = [ ]
297 self.pathChangedDisabled = False
299 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
301 "showFavourites": self.showFavourites,
302 "showAllServices": self.showAllServices,
303 "showProviders": self.showProviders,
304 "showSatellites": self.showSatellites,
305 "1": self.keyNumberGlobal,
306 "2": self.keyNumberGlobal,
307 "3": self.keyNumberGlobal,
308 "4": self.keyNumberGlobal,
309 "5": self.keyNumberGlobal,
310 "6": self.keyNumberGlobal,
311 "7": self.keyNumberGlobal,
312 "8": self.keyNumberGlobal,
313 "9": self.keyNumberGlobal,
314 "0": self.keyNumberGlobal
317 def appendDVBTypes(self, ref):
319 pos = path.find(' FROM BOUQUET')
321 return eServiceReference(self.service_types + path[pos:])
324 def getBouquetNumOffset(self, bouquet):
325 bouquet = self.appendDVBTypes(bouquet)
326 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
329 serviceHandler = eServiceCenter.getInstance()
330 bouquetlist = serviceHandler.list(self.bouquet_root)
331 if not bouquetlist is None:
333 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
334 if not bouquetIterator.valid() or bouquetIterator == bouquet: #end of list or bouquet found
336 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
338 servicelist = serviceHandler.list(bouquetIterator)
339 if not servicelist is None:
341 serviceIterator = servicelist.getNext()
342 if not serviceIterator.valid(): #check if end of list
344 if serviceIterator.flags: #playable services have no flags
349 def recallBouquetMode(self):
350 if self.mode == MODE_TV:
351 self.service_types = self.service_types_tv
352 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
353 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
355 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
357 self.service_types = self.service_types_radio
358 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
359 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
361 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
362 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
365 title = self.instance.getTitle()
366 pos = title.find(" (")
370 self.instance.setTitle(title)
372 self.recallBouquetMode()
374 def setRadioMode(self):
375 title = self.instance.getTitle()
376 pos = title.find(" (")
380 self.instance.setTitle(title)
381 self.mode = MODE_RADIO
382 self.recallBouquetMode()
384 def setRoot(self, root, justSet=False):
385 path = root.getPath()
386 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
387 pos = path.find(' FROM BOUQUET')
388 isBouquet = pos != -1
389 if not inBouquetRootList and isBouquet:
390 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
391 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
392 refstr = self.service_types + path[pos:]
393 root = eServiceReference(refstr)
395 self.servicelist.setMode(ServiceList.MODE_NORMAL)
396 self.servicelist.setRoot(root, justSet)
399 self.servicelist.moveUp()
402 self.servicelist.moveDown()
405 if self.mode == MODE_RADIO:
406 self.servicePathRadio = [ ]
408 self.servicePathTV = [ ]
410 def enterPath(self, ref, justSet=False):
411 if self.mode == MODE_RADIO:
412 self.servicePathRadio.append(ref)
414 self.servicePathTV.append(ref)
415 self.setRoot(ref, justSet)
417 def pathUp(self, justSet=False):
418 if self.mode == MODE_TV:
420 prev = self.servicePathTV.pop()
421 print "prev", prev.toString()
422 length = len(self.servicePathTV)
423 print "length", length
425 current = self.servicePathTV[length-1]
426 print "current", current.toString()
428 prev = self.servicePathRadio.pop()
429 length = len(self.servicePathRadio)
431 current = self.servicePathRadio[length-1]
432 self.setRoot(current, justSet)
434 print "setCurrentSelection prev"
435 self.setCurrentSelection(prev)
438 def isBasePathEqual(self, ref):
439 if self.mode == MODE_RADIO and len(self.servicePathRadio) > 1 and self.servicePathRadio[0] == ref:
441 elif self.mode == MODE_TV and len(self.servicePathTV) > 1 and self.servicePathTV[0] == ref:
445 def isPrevPathEqual(self, ref):
446 path = self.servicePathRadio
447 if self.mode == MODE_TV:
448 path = self.servicePathTV
450 if length > 1 and path[length-2] == ref:
454 def preEnterPath(self, refstr):
457 def showAllServices(self):
458 if not self.pathChangedDisabled:
459 refstr = '%s ORDER BY name'%(self.service_types)
460 if not self.preEnterPath(refstr):
461 ref = eServiceReference(refstr)
462 currentRoot = self.getRoot()
463 if currentRoot is None or currentRoot != ref:
467 def showSatellites(self):
468 if not self.pathChangedDisabled:
469 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
470 if not self.preEnterPath(refstr):
471 ref = eServiceReference(refstr)
475 if self.isBasePathEqual(ref):
476 if self.isPrevPathEqual(ref):
478 prev = self.pathUp(justSet)
480 currentRoot = self.getRoot()
481 if currentRoot is None or currentRoot != ref:
484 self.enterPath(ref, True)
486 serviceHandler = eServiceCenter.getInstance()
487 servicelist = serviceHandler.list(ref)
488 if not servicelist is None:
490 service = servicelist.getNext()
491 if not service.valid(): #check if end of list
493 orbpos = service.getData(4) >> 16
494 if service.getPath().find("FROM PROVIDER") != -1:
495 service_name = _("Providers")
497 service_name = _("Services")
499 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
500 service.setName(service_name) # why we need this cast?
502 if orbpos > 1800: # west
503 service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
505 service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
506 self.servicelist.addService(service)
507 self.servicelist.finishFill()
509 self.setCurrentSelection(prev)
511 def showProviders(self):
512 if not self.pathChangedDisabled:
513 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
514 if not self.preEnterPath(refstr):
515 ref = eServiceReference(refstr)
516 if self.isBasePathEqual(ref):
519 currentRoot = self.getRoot()
520 if currentRoot is None or currentRoot != ref:
524 def showFavourites(self):
525 if not self.pathChangedDisabled:
526 if not self.preEnterPath(self.bouquet_rootstr):
527 if self.isBasePathEqual(self.bouquet_root):
528 print "basepath equal"
531 print "basepath not equal"
532 currentRoot = self.getRoot()
533 if currentRoot is None or currentRoot != self.bouquet_root:
535 self.enterPath(self.bouquet_root)
537 def keyNumberGlobal(self, number):
538 char = self.numericalTextInput.getKey(number)
539 print "You pressed number " + str(number)
540 print "You would go to character " + str(char)
541 self.servicelist.moveToChar(char)
544 return self.servicelist.getRoot()
546 def getCurrentSelection(self):
547 return self.servicelist.getCurrent()
549 def setCurrentSelection(self, service):
550 servicepath = service.getPath()
551 pos = servicepath.find(" FROM BOUQUET")
553 if self.mode == MODE_TV:
554 servicepath = '(type == 1)' + servicepath[pos:]
556 servicepath = '(type == 2)' + servicepath[pos:]
557 service.setPath(servicepath)
558 self.servicelist.setCurrent(service)
560 def getBouquetList(self):
563 serviceHandler = eServiceCenter.getInstance()
564 list = serviceHandler.list(self.bouquet_root)
570 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
571 info = serviceHandler.info(s)
573 bouquets.append((info.getName(s), s))
576 if len(bouquets) == 0 and serviceCount > 0:
577 info = serviceHandler.info(self.bouquet_root)
579 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
583 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
584 def __init__(self, session):
585 ChannelSelectionBase.__init__(self,session)
586 ChannelSelectionEdit.__init__(self)
587 ChannelSelectionEPG.__init__(self)
589 #config for lastservice
590 config.tv = ConfigSubsection();
591 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
592 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
593 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
594 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
596 self["actions"] = ActionMap(["OkCancelActions"],
598 "cancel": self.cancel,
599 "ok": self.channelSelected,
601 self.onShown.append(self.onShow)
603 self.lastChannelRootTimer = eTimer()
604 self.lastChannelRootTimer.timeout.get().append(self.onCreate)
605 self.lastChannelRootTimer.start(100,True)
609 self.servicePathTV = [ ]
611 lastservice=eServiceReference(config.tv.lastservice.value)
612 if lastservice.valid():
613 self.setCurrentSelection(lastservice)
614 self.session.nav.playService(lastservice)
617 self.recallBouquetMode()
618 ref = self.session.nav.getCurrentlyPlayingServiceReference()
619 if ref is not None and ref.valid() and ref.getPath() == "":
620 self.servicelist.setPlayableIgnoreService(ref)
622 self.servicelist.setPlayableIgnoreService(eServiceReference())
624 def channelSelected(self):
625 ref = self.getCurrentSelection()
627 self.toggleMoveMarked()
628 elif (ref.flags & 7) == 7:
630 elif self.bouquet_mark_edit:
636 #called from infoBar and channelSelected
638 ref = self.session.nav.getCurrentlyPlayingServiceReference()
639 if ref is None or ref != self.getCurrentSelection():
640 self.session.nav.playService(self.getCurrentSelection())
646 for i in self.servicePathTV:
649 if config.tv.prevroot.value != config.tv.lastroot.value:
650 config.tv.prevroot.value = config.tv.lastroot.value
651 config.tv.prevroot.save()
652 if len(path) and path != config.tv.lastroot.value:
653 config.tv.lastroot.value = path
654 config.tv.lastroot.save()
656 def restoreRoot(self):
657 self.servicePathTV = [ ]
659 tmp = re.findall(config.tv.lastroot.value)
662 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
665 path = self.servicePathTV.pop()
668 self.showFavourites()
671 def preEnterPath(self, refstr):
672 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
673 pathstr = config.tv.lastroot.value
674 if pathstr is not None and pathstr.find(refstr) == 0:
676 lastservice=eServiceReference(config.tv.lastservice.value)
677 if lastservice is not None:
678 self.setCurrentSelection(lastservice)
682 def saveChannel(self):
683 ref = self.session.nav.getCurrentlyPlayingServiceReference()
685 refstr = ref.toString()
688 if refstr != config.tv.lastservice.value:
689 config.tv.prevservice.value = config.tv.lastservice.value
690 config.tv.prevservice.save()
691 config.tv.lastservice.value = refstr
692 config.tv.lastservice.save()
694 def recallPrevService(self):
695 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
696 if config.tv.lastroot.value != config.tv.prevroot.value:
697 tmp = config.tv.lastroot.value
698 config.tv.lastroot.value = config.tv.prevroot.value
699 config.tv.lastroot.save()
700 config.tv.prevroot.value = tmp
701 config.tv.prevroot.save()
703 if config.tv.lastservice.value != config.tv.prevservice.value:
704 tmp = config.tv.lastservice.value
705 config.tv.lastservice.value = config.tv.prevservice.value
706 config.tv.lastservice.save()
707 config.tv.prevservice.value = tmp
708 config.tv.prevservice.save()
709 lastservice=eServiceReference(config.tv.lastservice.value)
710 self.session.nav.playService(lastservice)
711 self.setCurrentSelection(lastservice)
716 lastservice=eServiceReference(config.tv.lastservice.value)
717 if lastservice.valid() and self.getCurrentSelection() != lastservice:
718 self.setCurrentSelection(lastservice)
720 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
722 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
723 def __init__(self, session):
724 Screen.__init__(self, session)
725 InfoBarEvent.__init__(self)
726 InfoBarServiceName.__init__(self)
727 InfoBarInstantRecord.__init__(self)
728 self["Clock"] = Clock()
730 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
731 def __init__(self, session):
732 ChannelSelectionBase.__init__(self, session)
733 ChannelSelectionEdit.__init__(self)
734 ChannelSelectionEPG.__init__(self)
736 config.radio = ConfigSubsection();
737 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
738 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
739 self.onLayoutFinish.append(self.onCreate)
741 self.info = session.instantiateDialog(RadioInfoBar)
743 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
745 "keyTV": self.closeRadio,
746 "keyRadio": self.closeRadio,
747 "cancel": self.closeRadio,
748 "ok": self.channelSelected,
753 for i in self.servicePathRadio:
756 if len(path) and path != config.radio.lastroot.value:
757 config.radio.lastroot.value = path
758 config.radio.lastroot.save()
760 def restoreRoot(self):
761 self.servicePathRadio = [ ]
763 tmp = re.findall(config.radio.lastroot.value)
766 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
769 path = self.servicePathRadio.pop()
772 self.showFavourites()
775 def preEnterPath(self, refstr):
776 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
777 pathstr = config.radio.lastroot.value
778 if pathstr is not None and pathstr.find(refstr) == 0:
780 lastservice=eServiceReference(config.radio.lastservice.value)
781 if lastservice is not None:
782 self.setCurrentSelection(lastservice)
789 lastservice=eServiceReference(config.radio.lastservice.value)
790 if lastservice.valid():
791 self.servicelist.setCurrent(lastservice)
792 self.session.nav.playService(lastservice)
793 self.servicelist.setPlayableIgnoreService(lastservice)
794 self.info.instance.show()
796 def channelSelected(self): # just return selected service
797 ref = self.getCurrentSelection()
799 self.toggleMoveMarked()
800 elif (ref.flags & 7) == 7:
802 elif self.bouquet_mark_edit:
805 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
806 if playingref is None or playingref != ref:
807 self.session.nav.playService(ref)
808 self.servicelist.setPlayableIgnoreService(ref)
809 config.radio.lastservice.value = ref.toString()
810 config.radio.lastservice.save()
813 def closeRadio(self):
814 self.info.instance.hide()
815 #set previous tv service
816 lastservice=eServiceReference(config.tv.lastservice.value)
817 self.session.nav.playService(lastservice)
820 class SimpleChannelSelection(ChannelSelectionBase):
821 def __init__(self, session, title):
822 ChannelSelectionBase.__init__(self, session)
824 self.onShown.append(self.onExecCallback)
826 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
828 "cancel": self.cancel,
829 "ok": self.channelSelected,
830 "keyRadio": self.setModeRadio,
831 "keyTV": self.setModeTv,
834 def onExecCallback(self):
835 self.session.currentDialog.instance.setTitle(self.title)
838 def channelSelected(self): # just return selected service
839 ref = self.getCurrentSelection()
840 if (ref.flags & 7) == 7:
843 ref = self.getCurrentSelection()
848 self.showFavourites()
850 def setModeRadio(self):
852 self.showFavourites()