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 = False # 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 self.servicelist.moveToChar(char)
535 return self.servicelist.getRoot()
537 def getCurrentSelection(self):
538 return self.servicelist.getCurrent()
540 def setCurrentSelection(self, service):
541 servicepath = service.getPath()
542 pos = servicepath.find(" FROM BOUQUET")
544 if self.mode == MODE_TV:
545 servicepath = '(type == 1)' + servicepath[pos:]
547 servicepath = '(type == 2)' + servicepath[pos:]
548 service.setPath(servicepath)
549 self.servicelist.setCurrent(service)
551 def getBouquetList(self):
554 serviceHandler = eServiceCenter.getInstance()
555 list = serviceHandler.list(self.bouquet_root)
561 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
562 info = serviceHandler.info(s)
564 bouquets.append((info.getName(s), s))
567 if len(bouquets) == 0 and serviceCount > 0:
568 info = serviceHandler.info(self.bouquet_root)
570 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
574 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
575 def __init__(self, session):
576 ChannelSelectionBase.__init__(self,session)
577 ChannelSelectionEdit.__init__(self)
578 ChannelSelectionEPG.__init__(self)
580 #config for lastservice
581 config.tv = ConfigSubsection();
582 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
583 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
584 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
585 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
587 self["actions"] = ActionMap(["OkCancelActions"],
589 "cancel": self.cancel,
590 "ok": self.channelSelected,
592 self.onShown.append(self.onShow)
594 self.lastChannelRootTimer = eTimer()
595 self.lastChannelRootTimer.timeout.get().append(self.onCreate)
596 self.lastChannelRootTimer.start(100,True)
600 self.servicePathTV = [ ]
602 lastservice=eServiceReference(config.tv.lastservice.value)
603 if lastservice.valid():
604 self.setCurrentSelection(lastservice)
605 self.session.nav.playService(lastservice)
608 self.recallBouquetMode()
609 ref = self.session.nav.getCurrentlyPlayingServiceReference()
610 if ref is not None and ref.valid() and ref.getPath() == "":
611 self.servicelist.setPlayableIgnoreService(ref)
613 self.servicelist.setPlayableIgnoreService(eServiceReference())
615 def channelSelected(self):
616 ref = self.getCurrentSelection()
618 self.toggleMoveMarked()
619 elif (ref.flags & 7) == 7:
621 elif self.bouquet_mark_edit:
627 #called from infoBar and channelSelected
629 ref = self.session.nav.getCurrentlyPlayingServiceReference()
630 if ref is None or ref != self.getCurrentSelection():
631 self.session.nav.playService(self.getCurrentSelection())
637 for i in self.servicePathTV:
640 if config.tv.prevroot.value != config.tv.lastroot.value:
641 config.tv.prevroot.value = config.tv.lastroot.value
642 config.tv.prevroot.save()
643 if len(path) and path != config.tv.lastroot.value:
644 config.tv.lastroot.value = path
645 config.tv.lastroot.save()
647 def restoreRoot(self):
648 self.servicePathTV = [ ]
650 tmp = re.findall(config.tv.lastroot.value)
653 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
656 path = self.servicePathTV.pop()
659 self.showFavourites()
662 def preEnterPath(self, refstr):
663 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
664 pathstr = config.tv.lastroot.value
665 if pathstr is not None and pathstr.find(refstr) == 0:
667 lastservice=eServiceReference(config.tv.lastservice.value)
668 if lastservice is not None:
669 self.setCurrentSelection(lastservice)
673 def saveChannel(self):
674 ref = self.session.nav.getCurrentlyPlayingServiceReference()
676 refstr = ref.toString()
679 if refstr != config.tv.lastservice.value:
680 config.tv.prevservice.value = config.tv.lastservice.value
681 config.tv.prevservice.save()
682 config.tv.lastservice.value = refstr
683 config.tv.lastservice.save()
685 def recallPrevService(self):
686 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
687 if config.tv.lastroot.value != config.tv.prevroot.value:
688 tmp = config.tv.lastroot.value
689 config.tv.lastroot.value = config.tv.prevroot.value
690 config.tv.lastroot.save()
691 config.tv.prevroot.value = tmp
692 config.tv.prevroot.save()
694 if config.tv.lastservice.value != config.tv.prevservice.value:
695 tmp = config.tv.lastservice.value
696 config.tv.lastservice.value = config.tv.prevservice.value
697 config.tv.lastservice.save()
698 config.tv.prevservice.value = tmp
699 config.tv.prevservice.save()
700 lastservice=eServiceReference(config.tv.lastservice.value)
701 self.session.nav.playService(lastservice)
702 self.setCurrentSelection(lastservice)
707 lastservice=eServiceReference(config.tv.lastservice.value)
708 if lastservice.valid() and self.getCurrentSelection() != lastservice:
709 self.setCurrentSelection(lastservice)
711 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
713 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
714 def __init__(self, session):
715 Screen.__init__(self, session)
716 InfoBarEvent.__init__(self)
717 InfoBarServiceName.__init__(self)
718 InfoBarInstantRecord.__init__(self)
719 self["Clock"] = Clock()
721 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
722 def __init__(self, session):
723 ChannelSelectionBase.__init__(self, session)
724 ChannelSelectionEdit.__init__(self)
725 ChannelSelectionEPG.__init__(self)
727 config.radio = ConfigSubsection();
728 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
729 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
730 self.onLayoutFinish.append(self.onCreate)
732 self.info = session.instantiateDialog(RadioInfoBar)
734 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
736 "keyTV": self.closeRadio,
737 "keyRadio": self.closeRadio,
738 "cancel": self.closeRadio,
739 "ok": self.channelSelected,
744 for i in self.servicePathRadio:
747 if len(path) and path != config.radio.lastroot.value:
748 config.radio.lastroot.value = path
749 config.radio.lastroot.save()
751 def restoreRoot(self):
752 self.servicePathRadio = [ ]
754 tmp = re.findall(config.radio.lastroot.value)
757 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
760 path = self.servicePathRadio.pop()
763 self.showFavourites()
766 def preEnterPath(self, refstr):
767 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
768 pathstr = config.radio.lastroot.value
769 if pathstr is not None and pathstr.find(refstr) == 0:
771 lastservice=eServiceReference(config.radio.lastservice.value)
772 if lastservice is not None:
773 self.setCurrentSelection(lastservice)
780 lastservice=eServiceReference(config.radio.lastservice.value)
781 if lastservice.valid():
782 self.servicelist.setCurrent(lastservice)
783 self.session.nav.playService(lastservice)
784 self.servicelist.setPlayableIgnoreService(lastservice)
785 self.info.instance.show()
787 def channelSelected(self): # just return selected service
788 ref = self.getCurrentSelection()
790 self.toggleMoveMarked()
791 elif (ref.flags & 7) == 7:
793 elif self.bouquet_mark_edit:
796 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
797 if playingref is None or playingref != ref:
798 self.session.nav.playService(ref)
799 self.servicelist.setPlayableIgnoreService(ref)
800 config.radio.lastservice.value = ref.toString()
801 config.radio.lastservice.save()
804 def closeRadio(self):
805 self.info.instance.hide()
806 #set previous tv service
807 lastservice=eServiceReference(config.tv.lastservice.value)
808 self.session.nav.playService(lastservice)
811 class SimpleChannelSelection(ChannelSelectionBase):
812 def __init__(self, session, title):
813 ChannelSelectionBase.__init__(self, session)
815 self.onShown.append(self.onExecCallback)
817 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
819 "cancel": self.cancel,
820 "ok": self.channelSelected,
821 "keyRadio": self.setModeRadio,
822 "keyTV": self.setModeTv,
825 def onExecCallback(self):
826 self.session.currentDialog.instance.setTitle(self.title)
829 def channelSelected(self): # just return selected service
830 ref = self.getCurrentSelection()
831 if (ref.flags & 7) == 7:
834 ref = self.getCurrentSelection()
839 self.showFavourites()
841 def setModeRadio(self):
843 self.showFavourites()