1 from Screen import Screen
2 from Components.Button import Button
3 from Components.ServiceList import ServiceList
4 from Components.ActionMap import NumberActionMap
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 ChannelSelectionEdit:
112 self.entry_marked = False
113 self.movemode = False
114 self.bouquet_mark_edit = False
115 self.mutableList = None
117 self.saved_title = None
118 self.saved_root = None
120 def getMutableList(self, root=eServiceReference()):
121 if not self.mutableList is None:
122 return self.mutableList
123 serviceHandler = eServiceCenter.getInstance()
126 list = serviceHandler.list(root)
128 return list.startEdit()
131 # multiple marked entry stuff ( edit mode, later multiepg selection )
132 def startMarkedEdit(self):
133 self.mutableList = self.getMutableList()
134 # add all services from the current list to internal marked set in listboxservicecontent
135 self.bouquetRoot = self.getRoot()
136 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
137 self.saved_title = self.instance.getTitle()
138 new_title = self.saved_title
139 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
140 new_title += ' ' + _("[bouquet edit]")
142 new_title += ' ' + _("[favourite edit]")
143 self.instance.setTitle(new_title)
144 self.bouquet_mark_edit = True
145 self.__marked = self.servicelist.getRootServices()
146 for x in self.__marked:
147 self.servicelist.addMarked(eServiceReference(x))
148 self.saved_root = self.getRoot()
149 self.showAllServices()
151 def endMarkedEdit(self, abort):
152 if not abort and self.mutableList is not None:
153 new_marked = set(self.servicelist.getMarked())
154 old_marked = set(self.__marked)
155 removed = old_marked - new_marked
156 added = new_marked - old_marked
160 self.mutableList.removeService(eServiceReference(x))
163 self.mutableList.addService(eServiceReference(x))
165 self.mutableList.flushChanges()
168 self.bouquet_mark_edit = False
169 self.bouquetRoot = None
170 self.mutableList = None
171 self.instance.setTitle(self.saved_title)
172 self.saved_title = None
173 self.setRoot(self.saved_root)
175 def clearMarks(self):
176 self.servicelist.clearMarks()
179 ref = self.servicelist.getCurrent()
180 if self.servicelist.isMarked(ref):
181 self.servicelist.removeMarked(ref)
183 self.servicelist.addMarked(ref)
185 def removeCurrentService(self):
186 ref = self.servicelist.getCurrent()
187 mutableList = self.getMutableList()
188 if ref.valid() and mutableList is not None:
189 if not mutableList.removeService(ref):
190 currentIndex = self.servicelist.getCurrentIndex()
191 self.servicelist.moveDown()
192 if self.servicelist.getCurrentIndex() == currentIndex:
194 mutableList.flushChanges() #FIXME dont flush on each single removed service
195 self.setRoot(self.getRoot())
196 self.servicelist.moveToIndex(currentIndex)
198 def addCurrentServiceToBouquet(self, dest):
199 mutableList = self.getMutableList(dest)
200 if not mutableList is None:
201 if not mutableList.addService(self.servicelist.getCurrent()):
202 mutableList.flushChanges()
205 def toggleMoveMode(self):
207 if self.entry_marked:
208 self.toggleMoveMarked() # unmark current entry
209 self.movemode = False
210 self.mutableList.flushChanges() # FIXME add check if changes was made
211 self.mutableList = None
212 self.instance.setTitle(self.saved_title)
213 self.saved_title = None
215 self.mutableList = self.getMutableList()
217 self.saved_title = self.instance.getTitle()
218 new_title = self.saved_title
219 new_title += ' ' + _("[move mode]");
220 self.instance.setTitle(new_title);
222 def handleEditCancel(self):
223 if self.movemode: #movemode active?
224 self.channelSelected() # unmark
225 self.toggleMoveMode() # disable move mode
226 elif self.bouquet_mark_edit:
227 self.endMarkedEdit(True) # abort edit mode
229 def toggleMoveMarked(self):
230 if self.entry_marked:
231 self.servicelist.setCurrentMarked(False)
232 self.entry_marked = False
234 self.servicelist.setCurrentMarked(True)
235 self.entry_marked = True
238 self.session.open(ChannelContextMenu, self)
243 class ChannelSelectionBase(Screen):
244 def __init__(self, session):
245 Screen.__init__(self, session)
247 # this makes it much simple to implement a selectable radio or tv mode :)
248 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
249 self.service_types_radio = '1:7:1:0:0:0:0:0:0:0:(type == 2)'
251 self["key_red"] = Button(_("All"))
252 self["key_green"] = Button(_("Satellites"))
253 self["key_yellow"] = Button(_("Provider"))
254 self["key_blue"] = Button(_("Favourites"))
256 self["list"] = ServiceList()
257 self.servicelist = self["list"]
259 self.numericalTextInput = NumericalTextInput()
261 self.servicePathTV = [ ]
262 self.servicePathRadio = [ ]
264 def appendDVBTypes(self, ref):
266 pos = path.find(' FROM BOUQUET')
268 return eServiceReference(self.service_types + path[pos:])
271 def getBouquetNumOffset(self, bouquet):
272 bouquet = self.appendDVBTypes(bouquet)
273 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
276 serviceHandler = eServiceCenter.getInstance()
277 bouquetlist = serviceHandler.list(self.bouquet_root)
278 if not bouquetlist is None:
280 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
281 if not bouquetIterator.valid() or bouquetIterator == bouquet: #end of list or bouquet found
283 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
285 servicelist = serviceHandler.list(bouquetIterator)
286 if not servicelist is None:
288 serviceIterator = servicelist.getNext()
289 if not serviceIterator.valid(): #check if end of list
291 if serviceIterator.flags: #playable services have no flags
296 def recallBouquetMode(self):
297 if self.mode == MODE_TV:
298 self.service_types = self.service_types_tv
299 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
300 self.bouquet_root = eServiceReference('1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet')
302 self.bouquet_root = eServiceReference('%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types))
304 self.service_types = self.service_types_radio
305 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
306 self.bouquet_root = eServiceReference('1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet')
308 self.bouquet_root = eServiceReference('%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types))
311 title = self.instance.getTitle()
312 pos = title.find(" (")
316 self.instance.setTitle(title)
318 self.recallBouquetMode()
320 def setRadioMode(self):
321 title = self.instance.getTitle()
322 pos = title.find(" (")
326 self.instance.setTitle(title)
327 self.mode = MODE_RADIO
328 self.recallBouquetMode()
330 def setRootBase(self, root, justSet=False):
331 path = root.getPath()
332 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
333 pos = path.find(' FROM BOUQUET')
334 isBouquet = pos != -1
335 if not inBouquetRootList and isBouquet:
336 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
337 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
338 refstr = self.service_types + path[pos:]
339 root = eServiceReference(refstr)
341 self.servicelist.setMode(ServiceList.MODE_NORMAL)
342 self.servicelist.setRoot(root, justSet)
345 self.servicelist.moveUp()
348 self.servicelist.moveDown()
351 if self.mode == MODE_RADIO:
352 self.servicePathRadio = [ ]
354 self.servicePathTV = [ ]
356 def enterPath(self, ref, justSet=False):
357 if self.mode == MODE_RADIO:
358 self.servicePathRadio.append(ref)
360 self.servicePathTV.append(ref)
361 self.setRoot(ref, justSet)
363 def pathUp(self, justSet=False):
364 if self.mode == MODE_TV:
365 prev = self.servicePathTV.pop()
366 length = len(self.servicePathTV)
368 current = self.servicePathTV[length-1]
370 prev = self.servicePathRadio.pop()
371 length = len(self.servicePathRadio)
373 current = self.servicePathRadio[length-1]
374 self.setRoot(current, justSet)
376 self.setCurrentSelection(prev)
379 def isBasePathEqual(self, ref):
380 if self.mode == MODE_RADIO and len(self.servicePathRadio) > 1 and self.servicePathRadio[0] == ref:
382 elif self.mode == MODE_TV and len(self.servicePathTV) > 1 and self.servicePathTV[0] == ref:
386 def isPrevPathEqual(self, ref):
387 path = self.servicePathRadio
388 if self.mode == MODE_TV:
389 path = self.servicePathTV
391 if length > 1 and path[length-2] == ref:
395 def showAllServices(self):
396 ref = eServiceReference('%s ORDER BY name'%(self.service_types))
400 def showSatellites(self):
403 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
404 if self.isBasePathEqual(ref):
405 if self.isPrevPathEqual(ref):
407 prev = self.pathUp(justSet)
411 self.enterPath(ref, True)
413 serviceHandler = eServiceCenter.getInstance()
414 servicelist = serviceHandler.list(ref)
415 if not servicelist is None:
417 service = servicelist.getNext()
418 if not service.valid(): #check if end of list
420 orbpos = service.getData(4) >> 16
421 if service.getPath().find("FROM PROVIDER") != -1:
422 service_name = _("Providers")
424 service_name = _("Services")
426 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
427 service.setName(service_name) # why we need this cast?
429 if orbpos > 1800: # west
430 service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
432 service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
433 # print service.toString()
434 self.servicelist.addService(service)
435 self.servicelist.finishFill()
437 # print "-->", prev.toString()
438 self.setCurrentSelection(prev)
440 def showProviders(self):
441 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
442 if self.isBasePathEqual(ref):
448 def showFavourites(self):
449 if self.isBasePathEqual(self.bouquet_root):
453 self.enterPath(self.bouquet_root)
455 def keyNumberGlobal(self, number):
456 char = self.numericalTextInput.getKey(number)
457 print "You pressed number " + str(number)
458 print "You would go to character " + str(char)
459 self.servicelist.moveToChar(char)
461 def enterBouquet(self, action):
462 if action[:7] == "bouquet":
463 if action.find("FROM BOUQUET") != -1:
464 self.setRoot(eServiceReference("1:7:1:0:0:0:0:0:0:0:" + action[8:]))
466 self.setRoot(eServiceReference("1:0:1:0:0:0:0:0:0:0:" + action[8:]))
471 return self.servicelist.getRoot()
473 def getCurrentSelection(self):
474 return self.servicelist.getCurrent()
476 def setCurrentSelection(self, service):
477 servicepath = service.getPath()
478 pos = servicepath.find(" FROM BOUQUET")
480 servicepath = '(type == 1)' + servicepath[pos:]
481 service.setPath(servicepath)
482 self.servicelist.setCurrent(service)
487 def getBouquetList(self):
490 serviceHandler = eServiceCenter.getInstance()
491 list = serviceHandler.list(self.bouquet_root)
497 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
498 info = serviceHandler.info(s)
500 bouquets.append((info.getName(s), s))
503 if len(bouquets) == 0 and serviceCount > 0:
504 info = serviceHandler.info(self.bouquet_root)
506 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
510 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit):
511 def __init__(self, session):
512 ChannelSelectionBase.__init__(self,session)
513 ChannelSelectionEdit.__init__(self)
515 #config for lastservice
516 config.tv = ConfigSubsection();
517 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
518 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
519 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
520 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
522 class ChannelActionMap(NumberActionMap):
523 def action(self, contexts, action):
524 if not self.csel.enterBouquet(action):
525 if action == "cancel":
526 self.csel.handleEditCancel()
527 NumberActionMap.action(self, contexts, action)
528 self["actions"] = ChannelActionMap(["ChannelSelectActions", "OkCancelActions", "ContextMenuActions"],
530 "cancel": self.cancel,
531 "ok": self.channelSelected,
533 "contextMenu": self.doContext,
534 "showFavourites": self.showFavourites,
535 "showAllServices": self.showAllServices,
536 "showProviders": self.showProviders,
537 "showSatellites": self.showSatellites,
538 "showEPGList": self.showEPGList,
539 "1": self.keyNumberGlobal,
540 "2": self.keyNumberGlobal,
541 "3": self.keyNumberGlobal,
542 "4": self.keyNumberGlobal,
543 "5": self.keyNumberGlobal,
544 "6": self.keyNumberGlobal,
545 "7": self.keyNumberGlobal,
546 "8": self.keyNumberGlobal,
547 "9": self.keyNumberGlobal,
548 "0": self.keyNumberGlobal
550 self["actions"].csel = self
551 self.onShown.append(self.onShow)
553 self.lastChannelRootTimer = eTimer()
554 self.lastChannelRootTimer.timeout.get().append(self.onCreate)
555 self.lastChannelRootTimer.start(100,True)
559 self.servicePathTV = [ ]
561 lastservice=eServiceReference(config.tv.lastservice.value)
562 if lastservice.valid():
563 self.setCurrentSelection(lastservice)
564 self.session.nav.playService(lastservice)
567 self.recallBouquetMode()
568 ref = self.session.nav.getCurrentlyPlayingServiceReference()
569 if ref is not None and ref.valid() and ref.getPath() == "":
570 self.servicelist.setPlayableIgnoreService(ref)
572 self.servicelist.setPlayableIgnoreService(eServiceReference())
574 def showEPGList(self):
575 ref=self.getCurrentSelection()
576 ptr=eEPGCache.getInstance()
577 if ptr.startTimeQuery(ref) != -1:
578 self.session.open(EPGSelection, ref)
580 print 'no epg for service', ref.toString()
582 def channelSelected(self):
583 ref = self.getCurrentSelection()
585 self.toggleMoveMarked()
586 elif (ref.flags & 7) == 7:
588 elif self.bouquet_mark_edit:
594 def setRoot(self, root, justSet=False):
595 if not self.movemode:
596 self.setRootBase(root, justSet)
598 #called from infoBar and channelSelected
600 ref = self.session.nav.getCurrentlyPlayingServiceReference()
601 if ref is None or ref != self.getCurrentSelection():
602 self.session.nav.playService(self.getCurrentSelection())
608 for i in self.servicePathTV:
611 if config.tv.prevroot.value != config.tv.lastroot.value:
612 config.tv.prevroot.value = config.tv.lastroot.value
613 config.tv.prevroot.save()
614 if len(path) and path != config.tv.lastroot.value:
615 config.tv.lastroot.value = path
616 config.tv.lastroot.save()
618 def restoreRoot(self):
619 self.servicePathTV = [ ]
621 tmp = re.findall(config.tv.lastroot.value)
624 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
627 path = self.servicePathTV.pop()
630 self.showFavourites()
633 def saveChannel(self):
634 ref = self.session.nav.getCurrentlyPlayingServiceReference()
636 refstr = ref.toString()
639 if refstr != config.tv.lastservice.value:
640 config.tv.prevservice.value = config.tv.lastservice.value
641 config.tv.prevservice.save()
642 config.tv.lastservice.value = refstr
643 config.tv.lastservice.save()
645 def recallPrevService(self):
646 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
647 if config.tv.lastroot.value != config.tv.prevroot.value:
648 tmp = config.tv.lastroot.value
649 config.tv.lastroot.value = config.tv.prevroot.value
650 config.tv.lastroot.save()
651 config.tv.prevroot.value = tmp
652 config.tv.prevroot.save()
654 if config.tv.lastservice.value != config.tv.prevservice.value:
655 tmp = config.tv.lastservice.value
656 config.tv.lastservice.value = config.tv.prevservice.value
657 config.tv.lastservice.save()
658 config.tv.prevservice.value = tmp
659 config.tv.prevservice.save()
660 lastservice=eServiceReference(config.tv.lastservice.value)
661 self.session.nav.playService(lastservice)
662 self.setCurrentSelection(lastservice)
667 lastservice=eServiceReference(config.tv.lastservice.value)
668 if lastservice.valid() and self.getCurrentSelection() != lastservice:
669 self.setCurrentSelection(lastservice)
671 class ServiceInfoWindow(Screen):
672 def __init__(self, session):
673 Screen.__init__(self, session)
674 self["Service_Name"] = ServiceName(self.session.nav)
675 self["Clock"] = Clock()
676 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
677 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
678 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
679 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
680 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
681 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
683 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit):
684 def __init__(self, session):
685 ChannelSelectionBase.__init__(self, session)
686 ChannelSelectionEdit.__init__(self)
688 config.radio = ConfigSubsection();
689 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
690 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
691 self.onLayoutFinish.append(self.onCreate)
693 self.info = session.instantiateDialog(ServiceInfoWindow)
695 class ChannelActionMap(NumberActionMap):
696 def action(self, contexts, action):
697 if not self.csel.enterBouquet(action):
698 NumberActionMap.action(self, contexts, action)
699 self["actions"] = ChannelActionMap(["ChannelSelectActions", "OkCancelActions", "ContextMenuActions", "TvRadioActions"],
701 "keyTV": self.closeRadio,
702 "keyRadio": self.closeRadio,
703 "contextMenu": self.doContext,
704 "cancel": self.closeRadio,
705 "ok": self.channelSelected,
706 "showFavourites": self.showFavourites,
707 "showAllServices": self.showAllServices,
708 "showProviders": self.showProviders,
709 "showSatellites": self.showSatellites,
710 "1": self.keyNumberGlobal,
711 "2": self.keyNumberGlobal,
712 "3": self.keyNumberGlobal,
713 "4": self.keyNumberGlobal,
714 "5": self.keyNumberGlobal,
715 "6": self.keyNumberGlobal,
716 "7": self.keyNumberGlobal,
717 "8": self.keyNumberGlobal,
718 "9": self.keyNumberGlobal,
719 "0": self.keyNumberGlobal
721 self["actions"].csel = self
725 for i in self.servicePathRadio:
728 if len(path) and path != config.radio.lastroot.value:
729 config.radio.lastroot.value = path
730 config.radio.lastroot.save()
732 def restoreRoot(self):
733 self.servicePathRadio = [ ]
735 tmp = re.findall(config.radio.lastroot.value)
738 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
741 path = self.servicePathRadio.pop()
744 self.showFavourites()
750 lastservice=eServiceReference(config.radio.lastservice.value)
751 if lastservice.valid():
752 self.servicelist.setCurrent(lastservice)
753 self.session.nav.playService(lastservice)
754 self.servicelist.setPlayableIgnoreService(lastservice)
755 self.info.instance.show()
757 def channelSelected(self): # just return selected service
758 ref = self.getCurrentSelection()
760 self.toggleMoveMarked()
761 elif (ref.flags & 7) == 7:
763 elif self.bouquet_mark_edit:
766 if self.session.nav.getCurrentlyPlayingServiceReference() != ref:
767 self.session.nav.playService(ref)
768 self.servicelist.setPlayableIgnoreService(ref)
769 config.radio.lastservice.value = ref.toString()
770 config.radio.lastservice.save()
773 def setRoot(self, root, justSet=False):
774 self.setRootBase(root, justSet)
776 def closeRadio(self):
777 self.info.instance.hide()
778 #set previous tv service
779 lastservice=eServiceReference(config.tv.lastservice.value)
780 self.session.nav.playService(lastservice)
783 class SimpleChannelSelection(ChannelSelectionBase):
784 def __init__(self, session, title):
785 ChannelSelectionBase.__init__(self, session)
787 self.onShown.append(self.onExecCallback)
789 class ChannelActionMap(NumberActionMap):
790 def action(self, contexts, action):
791 if not self.csel.enterBouquet(action):
792 NumberActionMap.action(self, contexts, action)
793 self["actions"] = ChannelActionMap(["ChannelSelectActions", "OkCancelActions", "ContextMenuActions", "TvRadioActions"],
795 "cancel": self.cancel,
796 "ok": self.channelSelected,
797 "showFavourites": self.showFavourites,
798 "showAllServices": self.showAllServices,
799 "showProviders": self.showProviders,
800 "showSatellites": self.showSatellites,
801 "keyRadio": self.setModeRadio,
802 "keyTV": self.setModeTv,
803 "1": self.keyNumberGlobal,
804 "2": self.keyNumberGlobal,
805 "3": self.keyNumberGlobal,
806 "4": self.keyNumberGlobal,
807 "5": self.keyNumberGlobal,
808 "6": self.keyNumberGlobal,
809 "7": self.keyNumberGlobal,
810 "8": self.keyNumberGlobal,
811 "9": self.keyNumberGlobal,
812 "0": self.keyNumberGlobal
814 self["actions"].csel = self
816 def onExecCallback(self):
817 self.session.currentDialog.instance.setTitle(self.title)
820 def channelSelected(self): # just return selected service
821 ref = self.getCurrentSelection()
822 if (ref.flags & 7) == 7:
825 ref = self.getCurrentSelection()
828 def setRoot(self, root, justSet=False):
829 self.setRootBase(root, justSet)
833 self.showFavourites()
835 def setModeRadio(self):
837 self.showFavourites()