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()
142 ActionMap.action(self, contexts, action)
143 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions"],
145 "contextMenu": self.doContext,
148 def getMutableList(self, root=eServiceReference()):
149 if not self.mutableList is None:
150 return self.mutableList
151 serviceHandler = eServiceCenter.getInstance()
154 list = serviceHandler.list(root)
156 return list.startEdit()
159 # multiple marked entry stuff ( edit mode, later multiepg selection )
160 def startMarkedEdit(self):
161 self.mutableList = self.getMutableList()
162 # add all services from the current list to internal marked set in listboxservicecontent
163 self.bouquetRoot = self.getRoot()
164 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
165 self.saved_title = self.instance.getTitle()
166 new_title = self.saved_title
167 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
168 new_title += ' ' + _("[bouquet edit]")
170 new_title += ' ' + _("[favourite edit]")
171 self.instance.setTitle(new_title)
172 self.bouquet_mark_edit = True
173 self.__marked = self.servicelist.getRootServices()
174 for x in self.__marked:
175 self.servicelist.addMarked(eServiceReference(x))
176 self.saved_root = self.getRoot()
177 self.showAllServices()
179 def endMarkedEdit(self, abort):
180 if not abort and self.mutableList is not None:
181 new_marked = set(self.servicelist.getMarked())
182 old_marked = set(self.__marked)
183 removed = old_marked - new_marked
184 added = new_marked - old_marked
188 self.mutableList.removeService(eServiceReference(x))
191 self.mutableList.addService(eServiceReference(x))
193 self.mutableList.flushChanges()
196 self.bouquet_mark_edit = False
197 self.bouquetRoot = None
198 self.mutableList = None
199 self.instance.setTitle(self.saved_title)
200 self.saved_title = None
201 self.setRoot(self.saved_root)
203 def clearMarks(self):
204 self.servicelist.clearMarks()
207 ref = self.servicelist.getCurrent()
208 if self.servicelist.isMarked(ref):
209 self.servicelist.removeMarked(ref)
211 self.servicelist.addMarked(ref)
213 def removeCurrentService(self):
214 ref = self.servicelist.getCurrent()
215 mutableList = self.getMutableList()
216 if ref.valid() and mutableList is not None:
217 if not mutableList.removeService(ref):
218 currentIndex = self.servicelist.getCurrentIndex()
219 self.servicelist.moveDown()
220 if self.servicelist.getCurrentIndex() == currentIndex:
222 mutableList.flushChanges() #FIXME dont flush on each single removed service
223 self.setRoot(self.getRoot())
224 self.servicelist.moveToIndex(currentIndex)
226 def addCurrentServiceToBouquet(self, dest):
227 mutableList = self.getMutableList(dest)
228 if not mutableList is None:
229 if not mutableList.addService(self.servicelist.getCurrent()):
230 mutableList.flushChanges()
233 def toggleMoveMode(self):
235 if self.entry_marked:
236 self.toggleMoveMarked() # unmark current entry
237 self.movemode = False
238 self.mutableList.flushChanges() # FIXME add check if changes was made
239 self.mutableList = None
240 self.instance.setTitle(self.saved_title)
241 self.saved_title = None
243 self.mutableList = self.getMutableList()
245 self.saved_title = self.instance.getTitle()
246 new_title = self.saved_title
247 new_title += ' ' + _("[move mode]");
248 self.instance.setTitle(new_title);
250 def handleEditCancel(self):
251 if self.movemode: #movemode active?
252 self.channelSelected() # unmark
253 self.toggleMoveMode() # disable move mode
254 elif self.bouquet_mark_edit:
255 self.endMarkedEdit(True) # abort edit mode
257 def toggleMoveMarked(self):
258 if self.entry_marked:
259 self.servicelist.setCurrentMarked(False)
260 self.entry_marked = False
262 self.servicelist.setCurrentMarked(True)
263 self.entry_marked = True
266 self.session.open(ChannelContextMenu, self)
271 class ChannelSelectionBase(Screen):
272 def __init__(self, session):
273 Screen.__init__(self, session)
275 # this makes it much simple to implement a selectable radio or tv mode :)
276 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
277 self.service_types_radio = '1:7:1:0:0:0:0:0:0:0:(type == 2)'
279 self["key_red"] = Button(_("All"))
280 self["key_green"] = Button(_("Satellites"))
281 self["key_yellow"] = Button(_("Provider"))
282 self["key_blue"] = Button(_("Favourites"))
284 self["list"] = ServiceList()
285 self.servicelist = self["list"]
287 self.numericalTextInput = NumericalTextInput()
289 self.servicePathTV = [ ]
290 self.servicePathRadio = [ ]
292 class ChannelBaseActionMap(NumberActionMap):
293 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
294 NumberActionMap.__init__(self, contexts, actions, prio)
296 def action(self, contexts, action):
297 if not self.csel.enterBouquet(action):
298 NumberActionMap.action(self, contexts, action)
299 self["ChannelSelectBaseActions"] = ChannelBaseActionMap(self, ["ChannelSelectBaseActions"],
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 setRootBase(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 refstr = '%s ORDER BY name'%(self.service_types)
454 if not self.preEnterPath(refstr):
455 ref = eServiceReference(refstr)
456 currentRoot = self.getRoot()
457 if currentRoot is None or currentRoot != ref:
461 def showSatellites(self):
462 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
463 if not self.preEnterPath(refstr):
464 ref = eServiceReference(refstr)
468 if self.isBasePathEqual(ref):
469 if self.isPrevPathEqual(ref):
471 prev = self.pathUp(justSet)
473 currentRoot = self.getRoot()
474 if currentRoot is None or currentRoot != ref:
477 self.enterPath(ref, True)
479 serviceHandler = eServiceCenter.getInstance()
480 servicelist = serviceHandler.list(ref)
481 if not servicelist is None:
483 service = servicelist.getNext()
484 if not service.valid(): #check if end of list
486 orbpos = service.getData(4) >> 16
487 if service.getPath().find("FROM PROVIDER") != -1:
488 service_name = _("Providers")
490 service_name = _("Services")
492 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
493 service.setName(service_name) # why we need this cast?
495 if orbpos > 1800: # west
496 service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
498 service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
499 # print service.toString()
500 self.servicelist.addService(service)
501 self.servicelist.finishFill()
503 # print "-->", prev.toString()
504 self.setCurrentSelection(prev)
506 def showProviders(self):
507 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
508 if not self.preEnterPath(refstr):
509 ref = eServiceReference(refstr)
510 if self.isBasePathEqual(ref):
513 currentRoot = self.getRoot()
514 if currentRoot is None or currentRoot != ref:
518 def showFavourites(self):
519 if not self.preEnterPath(self.bouquet_rootstr):
520 if self.isBasePathEqual(self.bouquet_root):
523 currentRoot = self.getRoot()
524 if currentRoot is None or currentRoot != self.bouquet_root:
526 self.enterPath(self.bouquet_root)
528 def keyNumberGlobal(self, number):
529 char = self.numericalTextInput.getKey(number)
530 print "You pressed number " + str(number)
531 print "You would go to character " + str(char)
532 self.servicelist.moveToChar(char)
534 def enterBouquet(self, action):
535 if action[:7] == "bouquet":
536 if action.find("FROM BOUQUET") != -1:
537 self.setRoot(eServiceReference("1:7:1:0:0:0:0:0:0:0:" + action[8:]))
539 self.setRoot(eServiceReference("1:0:1:0:0:0:0:0:0:0:" + action[8:]))
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 servicepath = '(type == 1)' + servicepath[pos:]
554 service.setPath(servicepath)
555 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 def setRoot(self, root, justSet=False):
637 if not self.movemode:
638 self.setRootBase(root, justSet)
640 #called from infoBar and channelSelected
642 ref = self.session.nav.getCurrentlyPlayingServiceReference()
643 if ref is None or ref != self.getCurrentSelection():
644 self.session.nav.playService(self.getCurrentSelection())
650 for i in self.servicePathTV:
653 if config.tv.prevroot.value != config.tv.lastroot.value:
654 config.tv.prevroot.value = config.tv.lastroot.value
655 config.tv.prevroot.save()
656 if len(path) and path != config.tv.lastroot.value:
657 config.tv.lastroot.value = path
658 config.tv.lastroot.save()
660 def restoreRoot(self):
661 self.servicePathTV = [ ]
663 tmp = re.findall(config.tv.lastroot.value)
666 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
669 path = self.servicePathTV.pop()
672 self.showFavourites()
675 def preEnterPath(self, refstr):
676 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
677 pathstr = config.tv.lastroot.value
678 if pathstr is not None and pathstr.find(refstr) == 0:
680 lastservice=eServiceReference(config.tv.lastservice.value)
681 if lastservice is not None:
682 self.setCurrentSelection(lastservice)
686 def saveChannel(self):
687 ref = self.session.nav.getCurrentlyPlayingServiceReference()
689 refstr = ref.toString()
692 if refstr != config.tv.lastservice.value:
693 config.tv.prevservice.value = config.tv.lastservice.value
694 config.tv.prevservice.save()
695 config.tv.lastservice.value = refstr
696 config.tv.lastservice.save()
698 def recallPrevService(self):
699 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
700 if config.tv.lastroot.value != config.tv.prevroot.value:
701 tmp = config.tv.lastroot.value
702 config.tv.lastroot.value = config.tv.prevroot.value
703 config.tv.lastroot.save()
704 config.tv.prevroot.value = tmp
705 config.tv.prevroot.save()
707 if config.tv.lastservice.value != config.tv.prevservice.value:
708 tmp = config.tv.lastservice.value
709 config.tv.lastservice.value = config.tv.prevservice.value
710 config.tv.lastservice.save()
711 config.tv.prevservice.value = tmp
712 config.tv.prevservice.save()
713 lastservice=eServiceReference(config.tv.lastservice.value)
714 self.session.nav.playService(lastservice)
715 self.setCurrentSelection(lastservice)
720 lastservice=eServiceReference(config.tv.lastservice.value)
721 if lastservice.valid() and self.getCurrentSelection() != lastservice:
722 self.setCurrentSelection(lastservice)
724 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
726 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
727 def __init__(self, session):
728 Screen.__init__(self, session)
729 InfoBarEvent.__init__(self)
730 InfoBarServiceName.__init__(self)
731 InfoBarInstantRecord.__init__(self)
732 self["Clock"] = Clock()
734 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
735 def __init__(self, session):
736 ChannelSelectionBase.__init__(self, session)
737 ChannelSelectionEdit.__init__(self)
738 ChannelSelectionEPG.__init__(self)
740 config.radio = ConfigSubsection();
741 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
742 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
743 self.onLayoutFinish.append(self.onCreate)
745 self.info = session.instantiateDialog(RadioInfoBar)
747 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
749 "keyTV": self.closeRadio,
750 "keyRadio": self.closeRadio,
751 "cancel": self.closeRadio,
752 "ok": self.channelSelected,
757 for i in self.servicePathRadio:
760 if len(path) and path != config.radio.lastroot.value:
761 config.radio.lastroot.value = path
762 config.radio.lastroot.save()
764 def restoreRoot(self):
765 self.servicePathRadio = [ ]
767 tmp = re.findall(config.radio.lastroot.value)
770 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
773 path = self.servicePathRadio.pop()
776 self.showFavourites()
779 def preEnterPath(self, refstr):
780 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
781 pathstr = config.radio.lastroot.value
782 if pathstr is not None and pathstr.find(refstr) == 0:
784 lastservice=eServiceReference(config.radio.lastservice.value)
785 if lastservice is not None:
786 self.setCurrentSelection(lastservice)
793 lastservice=eServiceReference(config.radio.lastservice.value)
794 if lastservice.valid():
795 self.servicelist.setCurrent(lastservice)
796 self.session.nav.playService(lastservice)
797 self.servicelist.setPlayableIgnoreService(lastservice)
798 self.info.instance.show()
800 def channelSelected(self): # just return selected service
801 ref = self.getCurrentSelection()
803 self.toggleMoveMarked()
804 elif (ref.flags & 7) == 7:
806 elif self.bouquet_mark_edit:
809 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
810 if playingref is None or playingref != ref:
811 self.session.nav.playService(ref)
812 self.servicelist.setPlayableIgnoreService(ref)
813 config.radio.lastservice.value = ref.toString()
814 config.radio.lastservice.save()
817 def setRoot(self, root, justSet=False):
818 self.setRootBase(root, justSet)
820 def closeRadio(self):
821 self.info.instance.hide()
822 #set previous tv service
823 lastservice=eServiceReference(config.tv.lastservice.value)
824 self.session.nav.playService(lastservice)
827 class SimpleChannelSelection(ChannelSelectionBase):
828 def __init__(self, session, title):
829 ChannelSelectionBase.__init__(self, session)
831 self.onShown.append(self.onExecCallback)
833 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
835 "cancel": self.cancel,
836 "ok": self.channelSelected,
837 "keyRadio": self.setModeRadio,
838 "keyTV": self.setModeTv,
841 def onExecCallback(self):
842 self.session.currentDialog.instance.setTitle(self.title)
845 def channelSelected(self): # just return selected service
846 ref = self.getCurrentSelection()
847 if (ref.flags & 7) == 7:
850 ref = self.getCurrentSelection()
853 def setRoot(self, root, justSet=False):
854 self.setRootBase(root, justSet)
858 self.showFavourites()
860 def setModeRadio(self):
862 self.showFavourites()