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:
419 prev = self.servicePathTV.pop()
420 length = len(self.servicePathTV)
422 current = self.servicePathTV[length-1]
424 prev = self.servicePathRadio.pop()
425 length = len(self.servicePathRadio)
427 current = self.servicePathRadio[length-1]
428 self.setRoot(current, justSet)
430 self.setCurrentSelection(prev)
433 def isBasePathEqual(self, ref):
434 if self.mode == MODE_RADIO and len(self.servicePathRadio) > 1 and self.servicePathRadio[0] == ref:
436 elif self.mode == MODE_TV and len(self.servicePathTV) > 1 and self.servicePathTV[0] == ref:
440 def isPrevPathEqual(self, ref):
441 path = self.servicePathRadio
442 if self.mode == MODE_TV:
443 path = self.servicePathTV
445 if length > 1 and path[length-2] == ref:
449 def preEnterPath(self, refstr):
452 def showAllServices(self):
453 if not self.pathChangedDisabled:
454 refstr = '%s ORDER BY name'%(self.service_types)
455 if not self.preEnterPath(refstr):
456 ref = eServiceReference(refstr)
457 currentRoot = self.getRoot()
458 if currentRoot is None or currentRoot != ref:
462 def showSatellites(self):
463 if not self.pathChangedDisabled:
464 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
465 if not self.preEnterPath(refstr):
466 ref = eServiceReference(refstr)
470 if self.isBasePathEqual(ref):
471 if self.isPrevPathEqual(ref):
473 prev = self.pathUp(justSet)
475 currentRoot = self.getRoot()
476 if currentRoot is None or currentRoot != ref:
479 self.enterPath(ref, True)
481 serviceHandler = eServiceCenter.getInstance()
482 servicelist = serviceHandler.list(ref)
483 if not servicelist is None:
485 service = servicelist.getNext()
486 if not service.valid(): #check if end of list
488 orbpos = service.getData(4) >> 16
489 if service.getPath().find("FROM PROVIDER") != -1:
490 service_name = _("Providers")
492 service_name = _("Services")
494 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
495 service.setName(service_name) # why we need this cast?
497 if orbpos > 1800: # west
498 service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
500 service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
501 self.servicelist.addService(service)
502 self.servicelist.finishFill()
504 self.setCurrentSelection(prev)
506 def showProviders(self):
507 if not self.pathChangedDisabled:
508 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
509 if not self.preEnterPath(refstr):
510 ref = eServiceReference(refstr)
511 if self.isBasePathEqual(ref):
514 currentRoot = self.getRoot()
515 if currentRoot is None or currentRoot != ref:
519 def showFavourites(self):
520 if not self.pathChangedDisabled:
521 if not self.preEnterPath(self.bouquet_rootstr):
522 if self.isBasePathEqual(self.bouquet_root):
525 currentRoot = self.getRoot()
526 if currentRoot is None or currentRoot != self.bouquet_root:
528 self.enterPath(self.bouquet_root)
530 def keyNumberGlobal(self, number):
531 char = self.numericalTextInput.getKey(number)
532 print "You pressed number " + str(number)
533 print "You would go to character " + str(char)
534 self.servicelist.moveToChar(char)
537 return self.servicelist.getRoot()
539 def getCurrentSelection(self):
540 return self.servicelist.getCurrent()
542 def setCurrentSelection(self, service):
543 servicepath = service.getPath()
544 pos = servicepath.find(" FROM BOUQUET")
546 servicepath = '(type == 1)' + servicepath[pos:]
547 service.setPath(servicepath)
548 self.servicelist.setCurrent(service)
550 def getBouquetList(self):
553 serviceHandler = eServiceCenter.getInstance()
554 list = serviceHandler.list(self.bouquet_root)
560 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
561 info = serviceHandler.info(s)
563 bouquets.append((info.getName(s), s))
566 if len(bouquets) == 0 and serviceCount > 0:
567 info = serviceHandler.info(self.bouquet_root)
569 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
573 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
574 def __init__(self, session):
575 ChannelSelectionBase.__init__(self,session)
576 ChannelSelectionEdit.__init__(self)
577 ChannelSelectionEPG.__init__(self)
579 #config for lastservice
580 config.tv = ConfigSubsection();
581 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
582 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
583 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
584 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
586 self["actions"] = ActionMap(["OkCancelActions"],
588 "cancel": self.cancel,
589 "ok": self.channelSelected,
591 self.onShown.append(self.onShow)
593 self.lastChannelRootTimer = eTimer()
594 self.lastChannelRootTimer.timeout.get().append(self.onCreate)
595 self.lastChannelRootTimer.start(100,True)
599 self.servicePathTV = [ ]
601 lastservice=eServiceReference(config.tv.lastservice.value)
602 if lastservice.valid():
603 self.setCurrentSelection(lastservice)
604 self.session.nav.playService(lastservice)
607 self.recallBouquetMode()
608 ref = self.session.nav.getCurrentlyPlayingServiceReference()
609 if ref is not None and ref.valid() and ref.getPath() == "":
610 self.servicelist.setPlayableIgnoreService(ref)
612 self.servicelist.setPlayableIgnoreService(eServiceReference())
614 def channelSelected(self):
615 ref = self.getCurrentSelection()
617 self.toggleMoveMarked()
618 elif (ref.flags & 7) == 7:
620 elif self.bouquet_mark_edit:
626 #called from infoBar and channelSelected
628 ref = self.session.nav.getCurrentlyPlayingServiceReference()
629 if ref is None or ref != self.getCurrentSelection():
630 self.session.nav.playService(self.getCurrentSelection())
636 for i in self.servicePathTV:
639 if config.tv.prevroot.value != config.tv.lastroot.value:
640 config.tv.prevroot.value = config.tv.lastroot.value
641 config.tv.prevroot.save()
642 if len(path) and path != config.tv.lastroot.value:
643 config.tv.lastroot.value = path
644 config.tv.lastroot.save()
646 def restoreRoot(self):
647 self.servicePathTV = [ ]
649 tmp = re.findall(config.tv.lastroot.value)
652 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
655 path = self.servicePathTV.pop()
658 self.showFavourites()
661 def preEnterPath(self, refstr):
662 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
663 pathstr = config.tv.lastroot.value
664 if pathstr is not None and pathstr.find(refstr) == 0:
666 lastservice=eServiceReference(config.tv.lastservice.value)
667 if lastservice is not None:
668 self.setCurrentSelection(lastservice)
672 def saveChannel(self):
673 ref = self.session.nav.getCurrentlyPlayingServiceReference()
675 refstr = ref.toString()
678 if refstr != config.tv.lastservice.value:
679 config.tv.prevservice.value = config.tv.lastservice.value
680 config.tv.prevservice.save()
681 config.tv.lastservice.value = refstr
682 config.tv.lastservice.save()
684 def recallPrevService(self):
685 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
686 if config.tv.lastroot.value != config.tv.prevroot.value:
687 tmp = config.tv.lastroot.value
688 config.tv.lastroot.value = config.tv.prevroot.value
689 config.tv.lastroot.save()
690 config.tv.prevroot.value = tmp
691 config.tv.prevroot.save()
693 if config.tv.lastservice.value != config.tv.prevservice.value:
694 tmp = config.tv.lastservice.value
695 config.tv.lastservice.value = config.tv.prevservice.value
696 config.tv.lastservice.save()
697 config.tv.prevservice.value = tmp
698 config.tv.prevservice.save()
699 lastservice=eServiceReference(config.tv.lastservice.value)
700 self.session.nav.playService(lastservice)
701 self.setCurrentSelection(lastservice)
706 lastservice=eServiceReference(config.tv.lastservice.value)
707 if lastservice.valid() and self.getCurrentSelection() != lastservice:
708 self.setCurrentSelection(lastservice)
710 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
712 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
713 def __init__(self, session):
714 Screen.__init__(self, session)
715 InfoBarEvent.__init__(self)
716 InfoBarServiceName.__init__(self)
717 InfoBarInstantRecord.__init__(self)
718 self["Clock"] = Clock()
720 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
721 def __init__(self, session):
722 ChannelSelectionBase.__init__(self, session)
723 ChannelSelectionEdit.__init__(self)
724 ChannelSelectionEPG.__init__(self)
726 config.radio = ConfigSubsection();
727 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
728 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
729 self.onLayoutFinish.append(self.onCreate)
731 self.info = session.instantiateDialog(RadioInfoBar)
733 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
735 "keyTV": self.closeRadio,
736 "keyRadio": self.closeRadio,
737 "cancel": self.closeRadio,
738 "ok": self.channelSelected,
743 for i in self.servicePathRadio:
746 if len(path) and path != config.radio.lastroot.value:
747 config.radio.lastroot.value = path
748 config.radio.lastroot.save()
750 def restoreRoot(self):
751 self.servicePathRadio = [ ]
753 tmp = re.findall(config.radio.lastroot.value)
756 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
759 path = self.servicePathRadio.pop()
762 self.showFavourites()
765 def preEnterPath(self, refstr):
766 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
767 pathstr = config.radio.lastroot.value
768 if pathstr is not None and pathstr.find(refstr) == 0:
770 lastservice=eServiceReference(config.radio.lastservice.value)
771 if lastservice is not None:
772 self.setCurrentSelection(lastservice)
779 lastservice=eServiceReference(config.radio.lastservice.value)
780 if lastservice.valid():
781 self.servicelist.setCurrent(lastservice)
782 self.session.nav.playService(lastservice)
783 self.servicelist.setPlayableIgnoreService(lastservice)
784 self.info.instance.show()
786 def channelSelected(self): # just return selected service
787 ref = self.getCurrentSelection()
789 self.toggleMoveMarked()
790 elif (ref.flags & 7) == 7:
792 elif self.bouquet_mark_edit:
795 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
796 if playingref is None or playingref != ref:
797 self.session.nav.playService(ref)
798 self.servicelist.setPlayableIgnoreService(ref)
799 config.radio.lastservice.value = ref.toString()
800 config.radio.lastservice.save()
803 def closeRadio(self):
804 self.info.instance.hide()
805 #set previous tv service
806 lastservice=eServiceReference(config.tv.lastservice.value)
807 self.session.nav.playService(lastservice)
810 class SimpleChannelSelection(ChannelSelectionBase):
811 def __init__(self, session, title):
812 ChannelSelectionBase.__init__(self, session)
814 self.onShown.append(self.onExecCallback)
816 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
818 "cancel": self.cancel,
819 "ok": self.channelSelected,
820 "keyRadio": self.setModeRadio,
821 "keyTV": self.setModeTv,
824 def onExecCallback(self):
825 self.session.currentDialog.instance.setTitle(self.title)
828 def channelSelected(self): # just return selected service
829 ref = self.getCurrentSelection()
830 if (ref.flags & 7) == 7:
833 ref = self.getCurrentSelection()
838 self.showFavourites()
840 def setModeRadio(self):
842 self.showFavourites()