1 from Screen import Screen
2 from Components.Button import Button
3 from Components.ServiceList import ServiceList
4 from Components.ActionMap import NumberActionMap, ActionMap, HelpableActionMap
5 from Components.MenuList import MenuList
6 from Components.ServiceEventTracker import ServiceEventTracker
7 from EpgSelection import EPGSelection
8 from enigma import eServiceReference, eEPGCache, eServiceCenter, eRCInput, eTimer, eDVBDB, iPlayableService, iServiceInformation, getPrevAsciiCode
9 from Components.config import config, ConfigSubsection, ConfigText
10 from Tools.NumericalTextInput import NumericalTextInput
11 from Components.NimManager import nimmanager
12 from Components.Sources.Source import ObsoleteSource
13 from Components.Sources.RdsDecoder import RdsDecoder
14 from Components.Sources.ServiceEvent import ServiceEvent
15 from Components.Input import Input
16 from Components.ParentalControl import parentalControl
17 from Components.Pixmap import Pixmap
18 from Screens.InputBox import InputBox, PinInput
19 from Screens.MessageBox import MessageBox
20 from Screens.ServiceInfo import ServiceInfo
21 from Screens.RdsDisplay import RassInteractive
22 from ServiceReference import ServiceReference
23 from Tools.BoundFunction import boundFunction
24 from re import compile
27 FLAG_SERVICE_NEW_FOUND = 64 #define in lib/dvb/idvb.h as dxNewFound = 64
29 class BouquetSelector(Screen):
30 def __init__(self, session, bouquets, selectedFunc, enableWrapAround=False):
31 Screen.__init__(self, session)
33 self.selectedFunc=selectedFunc
35 self["actions"] = ActionMap(["OkCancelActions"],
37 "ok": self.okbuttonClick,
38 "cancel": self.cancelClick
40 entrys = [ (x[0], x[1]) for x in bouquets ]
41 self["menu"] = MenuList(entrys, enableWrapAround)
44 cur = self["menu"].getCurrent()
47 def okbuttonClick(self):
48 self.selectedFunc(self.getCurrent())
56 def cancelClick(self):
59 # csel.bouquet_mark_edit values
64 def append_when_current_valid(current, menu, args, level = 0):
65 if current and current.valid() and level <= config.usage.setup_level.index:
68 class ChannelContextMenu(Screen):
69 def __init__(self, session, csel):
70 Screen.__init__(self, session)
71 #raise "we need a better summary screen here"
75 self["actions"] = ActionMap(["OkCancelActions"],
77 "ok": self.okbuttonClick,
78 "cancel": self.cancelClick
82 current = csel.getCurrentSelection()
83 current_root = csel.getRoot()
84 current_sel_path = current.getPath()
85 current_sel_flags = current.flags
86 inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
87 inBouquet = csel.getMutableList() is not None
88 haveBouquets = config.usage.multibouquet.value
90 if not (len(current_sel_path) or current_sel_flags & (eServiceReference.isDirectory|eServiceReference.isMarker)):
91 append_when_current_valid(current, menu, (_("show transponder info"), self.showServiceInformations), level = 2)
92 if csel.bouquet_mark_edit == OFF and not csel.movemode:
93 if not inBouquetRootList:
94 isPlayable = not (current_sel_flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
96 if config.ParentalControl.configured.value:
97 if parentalControl.getProtectionLevel(csel.getCurrentSelection().toCompareString()) == -1:
98 append_when_current_valid(current, menu, (_("add to parental protection"), boundFunction(self.addParentalProtection, csel.getCurrentSelection())), level = 0)
100 append_when_current_valid(current, menu, (_("remove from parental protection"), boundFunction(self.removeParentalProtection, csel.getCurrentSelection())), level = 0)
102 append_when_current_valid(current, menu, (_("add service to bouquet"), self.addServiceToBouquetSelected), level = 0)
104 append_when_current_valid(current, menu, (_("add service to favourites"), self.addServiceToBouquetSelected), level = 0)
107 if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
108 append_when_current_valid(current, menu, (_("copy to bouquets"), self.copyCurrentToBouquetList), level = 0)
109 if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
110 append_when_current_valid(current, menu, (_("remove all new found flags"), self.removeAllNewFoundFlags), level = 0)
112 append_when_current_valid(current, menu, (_("remove entry"), self.removeCurrentService), level = 0)
113 if current_root and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
114 append_when_current_valid(current, menu, (_("remove new found flag"), self.removeNewFoundFlag), level = 0)
116 menu.append((_("add bouquet"), self.showBouquetInputBox))
117 append_when_current_valid(current, menu, (_("remove entry"), self.removeBouquet), level = 0)
119 if inBouquet: # current list is editable?
120 if csel.bouquet_mark_edit == OFF:
121 if not csel.movemode:
122 append_when_current_valid(current, menu, (_("enable move mode"), self.toggleMoveMode), level = 1)
123 if not inBouquetRootList and current_root and not (current_root.flags & eServiceReference.isGroup):
124 menu.append((_("add marker"), self.showMarkerInputBox))
126 append_when_current_valid(current, menu, (_("enable bouquet edit"), self.bouquetMarkStart), level = 0)
128 append_when_current_valid(current, menu, (_("enable favourite edit"), self.bouquetMarkStart), level = 0)
129 if current_sel_flags & eServiceReference.isGroup:
130 append_when_current_valid(current, menu, (_("edit alternatives"), self.editAlternativeServices), level = 2)
131 append_when_current_valid(current, menu, (_("show alternatives"), self.showAlternativeServices), level = 2)
132 append_when_current_valid(current, menu, (_("remove all alternatives"), self.removeAlternativeServices), level = 2)
133 elif not current_sel_flags & eServiceReference.isMarker:
134 append_when_current_valid(current, menu, (_("add alternatives"), self.addAlternativeServices), level = 2)
136 append_when_current_valid(current, menu, (_("disable move mode"), self.toggleMoveMode), level = 0)
138 if csel.bouquet_mark_edit == EDIT_BOUQUET:
140 append_when_current_valid(current, menu, (_("end bouquet edit"), self.bouquetMarkEnd), level = 0)
141 append_when_current_valid(current, menu, (_("abort bouquet edit"), self.bouquetMarkAbort), level = 0)
143 append_when_current_valid(current, menu, (_("end favourites edit"), self.bouquetMarkEnd), level = 0)
144 append_when_current_valid(current, menu, (_("abort favourites edit"), self.bouquetMarkAbort), level = 0)
146 append_when_current_valid(current, menu, (_("end alternatives edit"), self.bouquetMarkEnd), level = 0)
147 append_when_current_valid(current, menu, (_("abort alternatives edit"), self.bouquetMarkAbort), level = 0)
149 menu.append((_("back"), self.cancelClick))
150 self["menu"] = MenuList(menu)
152 def okbuttonClick(self):
153 self["menu"].getCurrent()[1]()
155 def cancelClick(self):
158 def showServiceInformations(self):
159 self.session.open( ServiceInfo, self.csel.getCurrentSelection() )
161 def showBouquetInputBox(self):
162 self.session.openWithCallback(self.bouquetInputCallback, InputBox, title=_("Please enter a name for the new bouquet"), text="bouquetname", maxSize=False, visible_width = 56, type=Input.TEXT)
164 def bouquetInputCallback(self, bouquet):
165 if bouquet is not None:
166 self.csel.addBouquet(bouquet, None)
169 def addParentalProtection(self, service):
170 parentalControl.protectService(service.toCompareString())
173 def removeParentalProtection(self, service):
174 self.session.openWithCallback(boundFunction(self.pinEntered, service.toCompareString()), PinInput, pinList = [config.ParentalControl.servicepin[0].value], triesEntry = config.ParentalControl.retries.servicepin, title = _("Enter the service pin"), windowTitle = _("Change pin code"))
176 def pinEntered(self, service, result):
178 parentalControl.unProtectService(service)
181 self.session.openWithCallback(self.close, MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR)
183 def addServiceToBouquetSelected(self):
184 bouquets = self.csel.getBouquetList()
189 if cnt > 1: # show bouquet list
190 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
191 elif cnt == 1: # add to only one existing bouquet
192 self.addCurrentServiceToBouquet(bouquets[0][1])
194 def bouquetSelClosed(self, recursive):
199 def copyCurrentToBouquetList(self):
200 self.csel.copyCurrentToBouquetList()
203 def removeBouquet(self):
204 self.csel.removeBouquet()
207 def showMarkerInputBox(self):
208 self.session.openWithCallback(self.markerInputCallback, InputBox, title=_("Please enter a name for the new marker"), text="markername", maxSize=False, visible_width = 56, type=Input.TEXT)
210 def markerInputCallback(self, marker):
211 if marker is not None:
212 self.csel.addMarker(marker)
215 def addCurrentServiceToBouquet(self, dest):
216 self.csel.addServiceToBouquet(dest)
217 if self.bsel is not None:
218 self.bsel.close(True)
220 self.close(True) # close bouquet selection
222 def removeCurrentService(self):
223 self.csel.removeCurrentService()
226 def toggleMoveMode(self):
227 self.csel.toggleMoveMode()
230 def bouquetMarkStart(self):
231 self.csel.startMarkedEdit(EDIT_BOUQUET)
234 def bouquetMarkEnd(self):
235 self.csel.endMarkedEdit(abort=False)
238 def bouquetMarkAbort(self):
239 self.csel.endMarkedEdit(abort=True)
242 def removeNewFoundFlag(self):
243 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
246 def removeAllNewFoundFlags(self):
247 curpath = self.csel.getCurrentSelection().getPath()
248 idx = curpath.find("satellitePosition == ")
250 tmp = curpath[idx+21:]
253 satpos = int(tmp[:idx])
254 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
257 def editAlternativeServices(self):
258 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
261 def showAlternativeServices(self):
262 self.csel.enterPath(self.csel.getCurrentSelection())
265 def removeAlternativeServices(self):
266 self.csel.removeAlternativeServices()
269 def addAlternativeServices(self):
270 self.csel.addAlternativeServices()
271 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
274 class SelectionEventInfo:
276 self["ServiceEvent"] = ServiceEvent()
277 self.servicelist.connectSelChanged(self.__selectionChanged)
278 self.timer = eTimer()
279 self.timer.timeout.get().append(self.updateEventInfo)
280 self.onShown.append(self.__selectionChanged)
282 def __selectionChanged(self):
284 self.timer.start(100, True)
286 def updateEventInfo(self):
287 cur = self.getCurrentSelection()
288 self["ServiceEvent"].newService(cur)
290 class ChannelSelectionEPG:
292 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
294 "showEPGList": self.showEPGList,
297 def showEPGList(self):
298 ref=self.getCurrentSelection()
299 ptr=eEPGCache.getInstance()
300 if ptr.startTimeQuery(ref) != -1:
301 self.session.open(EPGSelection, ref)
303 print 'no epg for service', ref.toString()
305 class ChannelSelectionEdit:
307 self.entry_marked = False
308 self.movemode = False
309 self.bouquet_mark_edit = OFF
310 self.mutableList = None
312 self.saved_title = None
313 self.saved_root = None
315 class ChannelSelectionEditActionMap(ActionMap):
316 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
317 ActionMap.__init__(self, contexts, actions, prio)
320 def action(self, contexts, action):
321 if action == "cancel":
322 self.csel.handleEditCancel()
323 return 0 # fall-trough
325 return 0 # fall-trough
327 return ActionMap.action(self, contexts, action)
329 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
331 "contextMenu": self.doContext,
334 def getMutableList(self, root=eServiceReference()):
335 if not self.mutableList is None:
336 return self.mutableList
337 serviceHandler = eServiceCenter.getInstance()
340 list = root and serviceHandler.list(root)
342 return list.startEdit()
345 def buildBouquetID(self, str):
349 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
355 def addMarker(self, name):
356 current = self.servicelist.getCurrent()
357 mutableList = self.getMutableList()
360 str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
361 ref = eServiceReference(str)
362 if current and current.valid():
363 if not mutableList.addService(ref, current):
364 self.servicelist.addService(ref, True)
365 mutableList.flushChanges()
367 elif not mutableList.addService(ref):
368 self.servicelist.addService(ref, True)
369 mutableList.flushChanges()
373 def addAlternativeServices(self):
374 cur_service = ServiceReference(self.getCurrentSelection())
375 root = self.getRoot()
376 cur_root = root and ServiceReference(root)
377 mutableBouquet = cur_root.list().startEdit()
379 name = cur_service.getServiceName()
381 if self.mode == MODE_TV:
382 str = '1:134:1:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(name))
384 str = '1:134:2:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(name))
385 new_ref = ServiceReference(str)
386 if not mutableBouquet.addService(new_ref.ref, cur_service.ref):
387 mutableBouquet.removeService(cur_service.ref)
388 mutableBouquet.flushChanges()
389 eDVBDB.getInstance().reloadBouquets()
390 mutableAlternatives = new_ref.list().startEdit()
391 if mutableAlternatives:
392 mutableAlternatives.setListName(name)
393 if mutableAlternatives.addService(cur_service.ref):
394 print "add", cur_service.toString(), "to new alternatives failed"
395 mutableAlternatives.flushChanges()
396 self.servicelist.addService(new_ref.ref, True)
397 self.servicelist.removeCurrent()
398 self.servicelist.moveUp()
400 print "get mutable list for new created alternatives failed"
402 print "add", str, "to", cur_root.getServiceName(), "failed"
404 print "bouquetlist is not editable"
406 def addBouquet(self, bName, services):
407 serviceHandler = eServiceCenter.getInstance()
408 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
409 if mutableBouquetList:
410 if self.mode == MODE_TV:
412 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
415 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
416 new_bouquet_ref = eServiceReference(str)
417 if not mutableBouquetList.addService(new_bouquet_ref):
418 mutableBouquetList.flushChanges()
419 eDVBDB.getInstance().reloadBouquets()
420 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
422 mutableBouquet.setListName(bName)
423 if services is not None:
424 for service in services:
425 if mutableBouquet.addService(service):
426 print "add", service.toString(), "to new bouquet failed"
427 mutableBouquet.flushChanges()
429 print "get mutable list for new created bouquet failed"
430 # do some voodoo to check if current_root is equal to bouquet_root
431 cur_root = self.getRoot();
432 str1 = cur_root and cur_root.toString()
433 pos1 = str1 and str1.find("FROM BOUQUET") or -1
434 pos2 = self.bouquet_rootstr.find("FROM BOUQUET")
435 if pos1 != -1 and pos2 != -1 and str1[pos1:] == self.bouquet_rootstr[pos2:]:
436 self.servicelist.addService(new_bouquet_ref)
438 print "add", str, "to bouquets failed"
440 print "bouquetlist is not editable"
442 def copyCurrentToBouquetList(self):
443 provider = ServiceReference(self.getCurrentSelection())
444 providerName = provider.getServiceName()
445 serviceHandler = eServiceCenter.getInstance()
446 services = serviceHandler.list(provider.ref)
447 self.addBouquet(providerName, services and services.getContent('R', True))
449 def removeAlternativeServices(self):
450 cur_service = ServiceReference(self.getCurrentSelection())
451 root = self.getRoot()
452 cur_root = root and ServiceReference(root)
453 list = cur_service.list()
454 first_in_alternative = list and list.getNext()
455 if first_in_alternative:
456 edit_root = cur_root and cur_root.list().startEdit()
458 if not edit_root.addService(first_in_alternative, cur_service.ref):
459 self.servicelist.addService(first_in_alternative, True)
461 print "couldn't add first alternative service to current root"
463 print "couldn't edit current root!!"
465 print "remove empty alternative list !!"
467 self.servicelist.moveUp()
469 def removeBouquet(self):
470 refstr = self.getCurrentSelection().toString()
471 print "removeBouquet", refstr
472 self.bouquetNumOffsetCache = { }
473 pos = refstr.find('FROM BOUQUET "')
476 refstr = refstr[pos+14:]
477 pos = refstr.find('"')
479 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
480 self.removeCurrentService()
482 if filename is not None:
485 print "error during remove of", filename
487 # multiple marked entry stuff ( edit mode, later multiepg selection )
488 def startMarkedEdit(self, type):
489 self.savedPath = self.servicePath[:]
490 if type == EDIT_ALTERNATIVES:
491 self.enterPath(self.getCurrentSelection())
492 self.mutableList = self.getMutableList()
493 # add all services from the current list to internal marked set in listboxservicecontent
494 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
495 self.saved_title = self.instance.getTitle()
496 pos = self.saved_title.find(')')
497 new_title = self.saved_title[:pos+1]
498 if type == EDIT_ALTERNATIVES:
499 self.bouquet_mark_edit = EDIT_ALTERNATIVES
500 new_title += ' ' + _("[alternative edit]")
502 self.bouquet_mark_edit = EDIT_BOUQUET
503 if config.usage.multibouquet.value:
504 new_title += ' ' + _("[bouquet edit]")
506 new_title += ' ' + _("[favourite edit]")
507 self.setTitle(new_title)
508 self.__marked = self.servicelist.getRootServices()
509 for x in self.__marked:
510 self.servicelist.addMarked(eServiceReference(x))
511 self.showAllServices()
513 def endMarkedEdit(self, abort):
514 if not abort and self.mutableList is not None:
515 self.bouquetNumOffsetCache = { }
516 new_marked = set(self.servicelist.getMarked())
517 old_marked = set(self.__marked)
518 removed = old_marked - new_marked
519 added = new_marked - old_marked
523 self.mutableList.removeService(eServiceReference(x))
526 self.mutableList.addService(eServiceReference(x))
528 self.mutableList.flushChanges()
531 self.bouquet_mark_edit = OFF
532 self.mutableList = None
533 self.setTitle(self.saved_title)
534 self.saved_title = None
535 # self.servicePath is just a reference to servicePathTv or Radio...
536 # so we never ever do use the asignment operator in self.servicePath
537 del self.servicePath[:] # remove all elements
538 self.servicePath += self.savedPath # add saved elements
540 self.setRoot(self.servicePath[len(self.servicePath)-1])
542 def clearMarks(self):
543 self.servicelist.clearMarks()
546 ref = self.servicelist.getCurrent()
547 if self.servicelist.isMarked(ref):
548 self.servicelist.removeMarked(ref)
550 self.servicelist.addMarked(ref)
552 def removeCurrentService(self):
553 ref = self.servicelist.getCurrent()
554 mutableList = self.getMutableList()
555 if ref.valid() and mutableList is not None:
556 if not mutableList.removeService(ref):
557 self.bouquetNumOffsetCache = { }
558 mutableList.flushChanges() #FIXME dont flush on each single removed service
559 self.servicelist.removeCurrent()
561 def addServiceToBouquet(self, dest, service=None):
562 mutableList = self.getMutableList(dest)
563 if not mutableList is None:
564 if service is None: #use current selected service
565 service = self.servicelist.getCurrent()
566 if not mutableList.addService(service):
567 self.bouquetNumOffsetCache = { }
568 mutableList.flushChanges()
569 # do some voodoo to check if current_root is equal to dest
570 cur_root = self.getRoot();
571 str1 = cur_root and cur_root.toString() or -1
572 str2 = dest.toString()
573 pos1 = str1.find("FROM BOUQUET")
574 pos2 = str2.find("FROM BOUQUET")
575 if pos1 != -1 and pos2 != -1 and str1[pos1:] == str2[pos2:]:
576 self.servicelist.addService(service)
578 def toggleMoveMode(self):
580 if self.entry_marked:
581 self.toggleMoveMarked() # unmark current entry
582 self.movemode = False
583 self.pathChangeDisabled = False # re-enable path change
584 self.mutableList.flushChanges() # FIXME add check if changes was made
585 self.mutableList = None
586 self.setTitle(self.saved_title)
587 self.saved_title = None
588 cur_root = self.getRoot()
589 if cur_root and cur_root == self.bouquet_root:
590 self.bouquetNumOffsetCache = { }
592 self.mutableList = self.getMutableList()
594 self.pathChangeDisabled = True # no path change allowed in movemode
595 self.saved_title = self.instance.getTitle()
596 new_title = self.saved_title
597 pos = self.saved_title.find(')')
598 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
599 self.setTitle(new_title);
601 def handleEditCancel(self):
602 if self.movemode: #movemode active?
603 self.channelSelected() # unmark
604 self.toggleMoveMode() # disable move mode
605 elif self.bouquet_mark_edit != OFF:
606 self.endMarkedEdit(True) # abort edit mode
608 def toggleMoveMarked(self):
609 if self.entry_marked:
610 self.servicelist.setCurrentMarked(False)
611 self.entry_marked = False
613 self.servicelist.setCurrentMarked(True)
614 self.entry_marked = True
617 self.session.open(ChannelContextMenu, self)
622 # this makes it much simple to implement a selectable radio or tv mode :)
623 service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
624 service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
626 class ChannelSelectionBase(Screen):
627 def __init__(self, session):
628 Screen.__init__(self, session)
630 self["key_red"] = Button(_("All"))
631 self["key_green"] = Button(_("Satellites"))
632 self["key_yellow"] = Button(_("Provider"))
633 self["key_blue"] = Button(_("Favourites"))
635 self["list"] = ServiceList()
636 self.servicelist = self["list"]
638 self.numericalTextInput = NumericalTextInput()
639 self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
641 self.servicePathTV = [ ]
642 self.servicePathRadio = [ ]
643 self.servicePath = [ ]
647 self.pathChangeDisabled = False
649 self.bouquetNumOffsetCache = { }
651 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions", "InputAsciiActions"],
653 "showFavourites": self.showFavourites,
654 "showAllServices": self.showAllServices,
655 "showProviders": self.showProviders,
656 "showSatellites": self.showSatellites,
657 "nextBouquet": self.nextBouquet,
658 "prevBouquet": self.prevBouquet,
659 "nextMarker": self.nextMarker,
660 "prevMarker": self.prevMarker,
661 "gotAsciiCode": self.keyAsciiCode,
662 "1": self.keyNumberGlobal,
663 "2": self.keyNumberGlobal,
664 "3": self.keyNumberGlobal,
665 "4": self.keyNumberGlobal,
666 "5": self.keyNumberGlobal,
667 "6": self.keyNumberGlobal,
668 "7": self.keyNumberGlobal,
669 "8": self.keyNumberGlobal,
670 "9": self.keyNumberGlobal,
673 self.recallBouquetMode()
675 def getBouquetNumOffset(self, bouquet):
676 if not config.usage.multibouquet.value:
678 str = bouquet.toString()
680 if not self.bouquetNumOffsetCache.has_key(str):
681 serviceHandler = eServiceCenter.getInstance()
682 bouquetlist = serviceHandler.list(self.bouquet_root)
683 if not bouquetlist is None:
685 bouquetIterator = bouquetlist.getNext()
686 if not bouquetIterator.valid(): #end of list
688 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
689 if not (bouquetIterator.flags & eServiceReference.isDirectory):
691 servicelist = serviceHandler.list(bouquetIterator)
692 if not servicelist is None:
694 serviceIterator = servicelist.getNext()
695 if not serviceIterator.valid(): #check if end of list
697 playable = not (serviceIterator.flags & (eServiceReference.isDirectory|eServiceReference.isMarker))
700 return self.bouquetNumOffsetCache.get(str, offsetCount)
702 def recallBouquetMode(self):
703 if self.mode == MODE_TV:
704 self.service_types = service_types_tv
705 if config.usage.multibouquet.value:
706 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
708 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
710 self.service_types = service_types_radio
711 if config.usage.multibouquet.value:
712 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
714 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
715 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
719 self.servicePath = self.servicePathTV
720 self.recallBouquetMode()
721 title = self.instance.getTitle()
722 pos = title.find(" (")
728 def setRadioMode(self):
729 self.mode = MODE_RADIO
730 self.servicePath = self.servicePathRadio
731 self.recallBouquetMode()
732 title = self.instance.getTitle()
733 pos = title.find(" (")
739 def setRoot(self, root, justSet=False):
740 path = root.getPath()
741 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
742 pos = path.find('FROM BOUQUET')
743 isBouquet = (pos != -1) and (root.flags & eServiceReference.isDirectory)
744 if not inBouquetRootList and isBouquet:
745 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
746 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
748 self.servicelist.setMode(ServiceList.MODE_NORMAL)
749 self.servicelist.setRoot(root, justSet)
750 self.buildTitleString()
752 def removeModeStr(self, str):
753 if self.mode == MODE_TV:
754 pos = str.find(' (TV)')
756 pos = str.find(' (Radio)')
761 def getServiceName(self, ref):
762 str = self.removeModeStr(ServiceReference(ref).getServiceName())
764 pathstr = ref.getPath()
765 if pathstr.find('FROM PROVIDERS') != -1:
767 if pathstr.find('FROM SATELLITES') != -1:
768 return _("Satellites")
769 if pathstr.find(') ORDER BY name') != -1:
773 def buildTitleString(self):
774 titleStr = self.instance.getTitle()
775 pos = titleStr.find(']')
777 pos = titleStr.find(')')
779 titleStr = titleStr[:pos+1]
780 Len = len(self.servicePath)
782 base_ref = self.servicePath[0]
784 end_ref = self.servicePath[Len-1]
787 nameStr = self.getServiceName(base_ref)
788 titleStr += ' ' + nameStr
789 if end_ref is not None:
794 nameStr = self.getServiceName(end_ref)
796 self.setTitle(titleStr)
799 self.servicelist.moveUp()
802 self.servicelist.moveDown()
805 del self.servicePath[:]
807 def enterPath(self, ref, justSet=False):
808 self.servicePath.append(ref)
809 self.setRoot(ref, justSet)
811 def pathUp(self, justSet=False):
812 prev = self.servicePath.pop()
813 length = len(self.servicePath)
815 current = self.servicePath[length-1]
816 self.setRoot(current, justSet)
818 self.setCurrentSelection(prev)
821 def isBasePathEqual(self, ref):
822 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
826 def isPrevPathEqual(self, ref):
827 length = len(self.servicePath)
828 if length > 1 and self.servicePath[length-2] == ref:
832 def preEnterPath(self, refstr):
835 def showAllServices(self):
836 if not self.pathChangeDisabled:
837 refstr = '%s ORDER BY name'%(self.service_types)
838 if not self.preEnterPath(refstr):
839 ref = eServiceReference(refstr)
840 currentRoot = self.getRoot()
841 if currentRoot is None or currentRoot != ref:
845 def showSatellites(self):
846 if not self.pathChangeDisabled:
847 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
848 if not self.preEnterPath(refstr):
849 ref = eServiceReference(refstr)
853 if self.isBasePathEqual(ref):
854 if self.isPrevPathEqual(ref):
856 prev = self.pathUp(justSet)
858 currentRoot = self.getRoot()
859 if currentRoot is None or currentRoot != ref:
862 self.enterPath(ref, True)
864 serviceHandler = eServiceCenter.getInstance()
865 servicelist = serviceHandler.list(ref)
866 if not servicelist is None:
868 service = servicelist.getNext()
869 if not service.valid(): #check if end of list
871 unsigned_orbpos = service.getUnsignedData(4) >> 16
872 orbpos = service.getData(4) >> 16
875 if service.getPath().find("FROM PROVIDER") != -1:
876 service_type = _("Providers")
877 elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
878 service_type = _("New")
880 service_type = _("Services")
882 # why we need this cast?
883 service_name = str(nimmanager.getSatDescription(orbpos))
885 if unsigned_orbpos == 0xFFFF: #Cable
886 service_name = _("Cable")
887 elif unsigned_orbpos == 0xEEEE: #Terrestrial
888 service_name = _("Terrestrial")
890 if orbpos > 1800: # west
891 orbpos = 3600 - orbpos
895 service_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
896 service.setName("%s - %s" % (service_name, service_type))
897 self.servicelist.addService(service)
898 cur_ref = self.session.nav.getCurrentlyPlayingServiceReference()
900 pos = self.service_types.rfind(':')
901 refstr = '%s (channelID == %08x%04x%04x) && %s ORDER BY name' %(self.service_types[:pos+1],
902 cur_ref.getUnsignedData(4), # NAMESPACE
903 cur_ref.getUnsignedData(2), # TSID
904 cur_ref.getUnsignedData(3), # ONID
905 self.service_types[pos+1:])
906 ref = eServiceReference(refstr)
907 ref.setName(_("Current Transponder"))
908 self.servicelist.addService(ref)
909 self.servicelist.finishFill()
911 self.setCurrentSelection(prev)
913 def showProviders(self):
914 if not self.pathChangeDisabled:
915 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
916 if not self.preEnterPath(refstr):
917 ref = eServiceReference(refstr)
918 if self.isBasePathEqual(ref):
921 currentRoot = self.getRoot()
922 if currentRoot is None or currentRoot != ref:
926 def changeBouquet(self, direction):
927 if not self.pathChangeDisabled:
928 if len(self.servicePath) > 1:
929 #when enter satellite root list we must do some magic stuff..
930 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
931 if self.isBasePathEqual(ref):
932 self.showSatellites()
939 ref = self.getCurrentSelection()
943 if len(self.servicePath) > 0 and self.servicePath[0] == self.bouquet_root:
948 return self.servicelist.atBegin()
951 return self.servicelist.atEnd()
953 def nextBouquet(self):
954 self.changeBouquet(+1)
956 def prevBouquet(self):
957 self.changeBouquet(-1)
959 def showFavourites(self):
960 if not self.pathChangeDisabled:
961 if not self.preEnterPath(self.bouquet_rootstr):
962 if self.isBasePathEqual(self.bouquet_root):
965 currentRoot = self.getRoot()
966 if currentRoot is None or currentRoot != self.bouquet_root:
968 self.enterPath(self.bouquet_root)
970 def keyNumberGlobal(self, number):
971 unichar = self.numericalTextInput.getKey(number)
972 charstr = unichar.encode("utf-8")
973 if len(charstr) == 1:
974 self.servicelist.moveToChar(charstr[0])
976 def keyAsciiCode(self):
977 unichar = unichr(getPrevAsciiCode())
978 charstr = unichar.encode("utf-8")
979 if len(charstr) == 1:
980 self.servicelist.moveToChar(charstr[0])
983 return self.servicelist.getRoot()
985 def getCurrentSelection(self):
986 return self.servicelist.getCurrent()
988 def setCurrentSelection(self, service):
989 servicepath = service.getPath()
990 pos = servicepath.find(" FROM BOUQUET")
992 if self.mode == MODE_TV:
993 servicepath = '(type == 1)' + servicepath[pos:]
995 servicepath = '(type == 2)' + servicepath[pos:]
996 service.setPath(servicepath)
997 self.servicelist.setCurrent(service)
999 def getBouquetList(self):
1001 serviceHandler = eServiceCenter.getInstance()
1002 if config.usage.multibouquet.value:
1003 list = serviceHandler.list(self.bouquet_root)
1009 if s.flags & eServiceReference.isDirectory:
1010 info = serviceHandler.info(s)
1012 bouquets.append((info.getName(s), s))
1015 info = serviceHandler.info(self.bouquet_root)
1017 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
1021 def keyNumber0(self, num):
1022 if len(self.servicePath) > 1:
1025 self.keyNumberGlobal(num)
1028 if len(self.servicePath) > 1:
1029 if self.isBasePathEqual(self.bouquet_root):
1030 self.showFavourites()
1032 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
1033 if self.isBasePathEqual(ref):
1034 self.showSatellites()
1036 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
1037 if self.isBasePathEqual(ref):
1038 self.showProviders()
1040 self.showAllServices()
1042 def nextMarker(self):
1043 self.servicelist.moveToNextMarker()
1045 def prevMarker(self):
1046 self.servicelist.moveToPrevMarker()
1050 #config for lastservice
1051 config.tv = ConfigSubsection()
1052 config.tv.lastservice = ConfigText()
1053 config.tv.lastroot = ConfigText()
1054 config.radio = ConfigSubsection()
1055 config.radio.lastservice = ConfigText()
1056 config.radio.lastroot = ConfigText()
1057 config.servicelist = ConfigSubsection()
1058 config.servicelist.lastmode = ConfigText(default = "tv")
1060 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, SelectionEventInfo):
1061 def __init__(self, session):
1062 ChannelSelectionBase.__init__(self,session)
1063 ChannelSelectionEdit.__init__(self)
1064 ChannelSelectionEPG.__init__(self)
1065 SelectionEventInfo.__init__(self)
1067 self["CurrentTime"] = ObsoleteSource(new_source = "global.CurrentTime", removal_date = "2008-01")
1069 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1071 "cancel": self.cancel,
1072 "ok": self.channelSelected,
1073 "keyRadio": self.setModeRadio,
1074 "keyTV": self.setModeTv,
1077 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1079 iPlayableService.evStart: self.__evServiceStart,
1080 iPlayableService.evEnd: self.__evServiceEnd
1083 self.lastChannelRootTimer = eTimer()
1084 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
1085 self.lastChannelRootTimer.start(100,True)
1087 self.history_tv = [ ]
1088 self.history_radio = [ ]
1089 self.history = self.history_tv
1090 self.history_pos = 0
1092 self.lastservice = config.tv.lastservice
1093 self.lastroot = config.tv.lastroot
1094 self.revertMode = None
1095 config.usage.multibouquet.addNotifier(self.multibouquet_config_changed)
1096 self.new_service_played = False
1097 self.onExecBegin.append(self.asciiOn)
1100 rcinput = eRCInput.getInstance()
1101 rcinput.setKeyboardMode(rcinput.kmAscii)
1104 rcinput = eRCInput.getInstance()
1105 rcinput.setKeyboardMode(rcinput.kmNone)
1107 def multibouquet_config_changed(self, val):
1108 self.recallBouquetMode()
1110 def __evServiceStart(self):
1111 service = self.session.nav.getCurrentService()
1113 info = service.info()
1115 refstr = info.getInfoString(iServiceInformation.sServiceref)
1116 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1118 def __evServiceEnd(self):
1119 self.servicelist.setPlayableIgnoreService(eServiceReference())
1123 lastservice=eServiceReference(self.lastservice.value)
1124 if lastservice.valid():
1125 self.setCurrentSelection(lastservice)
1127 def setModeTv(self):
1128 if self.revertMode is None and config.servicelist.lastmode.value == "radio":
1129 self.revertMode = MODE_RADIO
1130 self.history = self.history_tv
1131 self.lastservice = config.tv.lastservice
1132 self.lastroot = config.tv.lastroot
1133 config.servicelist.lastmode.value = "tv"
1137 def setModeRadio(self):
1138 if self.revertMode is None and config.servicelist.lastmode.value == "tv":
1139 self.revertMode = MODE_TV
1140 if config.usage.e1like_radio_mode.value:
1141 self.history = self.history_radio
1142 self.lastservice = config.radio.lastservice
1143 self.lastroot = config.radio.lastroot
1144 config.servicelist.lastmode.value = "radio"
1148 def __onCreate(self):
1149 if config.usage.e1like_radio_mode.value:
1150 if config.servicelist.lastmode.value == "tv":
1156 lastservice=eServiceReference(self.lastservice.value)
1157 if lastservice.valid():
1160 def channelSelected(self):
1161 ref = self.getCurrentSelection()
1163 self.toggleMoveMarked()
1164 elif (ref.flags & 7) == 7:
1166 elif self.bouquet_mark_edit != OFF:
1167 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1169 elif not (ref.flags & eServiceReference.isMarker): # no marker
1170 root = self.getRoot()
1171 if not root or not (root.flags & eServiceReference.isGroup):
1176 #called from infoBar and channelSelected
1178 self.revertMode=None
1179 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1180 nref = self.getCurrentSelection()
1181 if ref is None or ref != nref:
1182 self.new_service_played = True
1183 self.session.nav.playService(nref)
1185 self.saveChannel(nref)
1186 config.servicelist.lastmode.save()
1187 self.addToHistory(nref)
1189 def newServicePlayed(self):
1190 ret = self.new_service_played
1191 self.new_service_played = False
1194 def addToHistory(self, ref):
1195 if self.servicePath is not None:
1196 tmp=self.servicePath[:]
1199 del self.history[self.history_pos+1:]
1202 self.history.append(tmp)
1203 hlen = len(self.history)
1204 if hlen > HISTORYSIZE:
1207 self.history_pos = hlen-1
1209 def historyBack(self):
1210 hlen = len(self.history)
1211 if hlen > 1 and self.history_pos > 0:
1212 self.history_pos -= 1
1213 self.setHistoryPath()
1215 def historyNext(self):
1216 hlen = len(self.history)
1217 if hlen > 1 and self.history_pos < (hlen-1):
1218 self.history_pos += 1
1219 self.setHistoryPath()
1221 def setHistoryPath(self):
1222 path = self.history[self.history_pos][:]
1224 del self.servicePath[:]
1225 self.servicePath += path
1229 cur_root = self.getRoot()
1230 if cur_root and cur_root != root:
1232 self.session.nav.playService(ref)
1233 self.setCurrentSelection(ref)
1234 self.saveChannel(ref)
1238 for i in self.servicePath:
1239 path += i.toString()
1241 if len(path) and path != self.lastroot.value:
1242 self.lastroot.value = path
1243 self.lastroot.save()
1245 def restoreRoot(self):
1247 re = compile('.+?;')
1248 tmp = re.findall(self.lastroot.value)
1251 self.servicePath.append(eServiceReference(i[:len(i)-1]))
1254 path = self.servicePath.pop()
1255 self.enterPath(path)
1257 self.showFavourites()
1260 def preEnterPath(self, refstr):
1261 if len(self.servicePath) and self.servicePath[0] != eServiceReference(refstr):
1262 pathstr = self.lastroot.value
1263 if pathstr is not None and pathstr.find(refstr) == 0:
1265 lastservice=eServiceReference(self.lastservice.value)
1266 if lastservice.valid():
1267 self.setCurrentSelection(lastservice)
1271 def saveChannel(self, ref):
1273 refstr = ref.toString()
1276 if refstr != self.lastservice.value:
1277 self.lastservice.value = refstr
1278 self.lastservice.save()
1280 def setCurrentServicePath(self, path):
1281 hlen = len(self.history)
1283 self.history[self.history_pos] = path
1285 self.history.append(path)
1286 self.setHistoryPath()
1288 def getCurrentServicePath(self):
1289 hlen = len(self.history)
1291 return self.history[self.history_pos]
1294 def recallPrevService(self):
1295 hlen = len(self.history)
1297 if self.history_pos == hlen-1:
1298 tmp = self.history[self.history_pos]
1299 self.history[self.history_pos] = self.history[self.history_pos-1]
1300 self.history[self.history_pos-1] = tmp
1302 tmp = self.history[self.history_pos+1]
1303 self.history[self.history_pos+1] = self.history[self.history_pos]
1304 self.history[self.history_pos] = tmp
1305 self.setHistoryPath()
1308 if self.revertMode is None:
1310 lastservice=eServiceReference(self.lastservice.value)
1311 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1312 self.setCurrentSelection(lastservice)
1313 elif self.revertMode == MODE_TV:
1315 elif self.revertMode == MODE_RADIO:
1317 self.revertMode = None
1321 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName
1323 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName):
1324 def __init__(self, session):
1325 Screen.__init__(self, session)
1326 InfoBarEvent.__init__(self)
1327 InfoBarServiceName.__init__(self)
1328 self["CurrentTime"] = ObsoleteSource(new_source = "global.CurrentTime", removal_date = "2008-01")
1329 self["RdsDecoder"] = RdsDecoder(self.session.nav)
1330 self["BlinkingPoint"] = Pixmap()
1331 self["BlinkingPoint"].hide()
1333 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
1334 ALLOW_SUSPEND = True
1336 def __init__(self, session, infobar):
1337 ChannelSelectionBase.__init__(self, session)
1338 ChannelSelectionEdit.__init__(self)
1339 ChannelSelectionEPG.__init__(self)
1340 self.infobar = infobar
1341 self.onLayoutFinish.append(self.onCreate)
1343 self.info = session.instantiateDialog(RadioInfoBar) # our simple infobar
1345 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1347 "keyTV": self.closeRadio,
1348 "keyRadio": self.closeRadio,
1349 "cancel": self.closeRadio,
1350 "ok": self.channelSelected,
1353 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1355 iPlayableService.evStart: self.__evServiceStart,
1356 iPlayableService.evEnd: self.__evServiceEnd
1359 ########## RDS Radiotext / Rass Support BEGIN
1360 self.infobar = infobar # reference to real infobar (the one and only)
1361 self["RdsDecoder"] = self.info["RdsDecoder"]
1362 self["RdsActions"] = HelpableActionMap(self, "InfobarRdsActions",
1364 "startRassInteractive": (self.startRassInteractive, _("View Rass interactive..."))
1366 self["RdsActions"].setEnabled(False)
1367 infobar.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
1369 def startRassInteractive(self):
1371 self.infobar.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
1373 def RassInteractiveClosed(self):
1375 self.infobar.rass_interactive = None
1376 self.infobar.RassSlidePicChanged()
1378 def RassInteractivePossibilityChanged(self, state):
1379 self["RdsActions"].setEnabled(state)
1380 ########## RDS Radiotext / Rass Support END
1382 def closeRadio(self):
1383 self.infobar.rds_display.onRassInteractivePossibilityChanged.remove(self.RassInteractivePossibilityChanged)
1385 #set previous tv service
1386 lastservice=eServiceReference(config.tv.lastservice.value)
1387 self.session.nav.playService(lastservice)
1390 def __evServiceStart(self):
1391 service = self.session.nav.getCurrentService()
1393 info = service.info()
1395 refstr = info.getInfoString(iServiceInformation.sServiceref)
1396 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1398 def __evServiceEnd(self):
1399 self.servicelist.setPlayableIgnoreService(eServiceReference())
1403 for i in self.servicePathRadio:
1404 path += i.toString()
1406 if len(path) and path != config.radio.lastroot.value:
1407 config.radio.lastroot.value = path
1408 config.radio.lastroot.save()
1410 def restoreRoot(self):
1412 re = compile('.+?;')
1413 tmp = re.findall(config.radio.lastroot.value)
1416 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1419 path = self.servicePathRadio.pop()
1420 self.enterPath(path)
1422 self.showFavourites()
1425 def preEnterPath(self, refstr):
1426 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1427 pathstr = config.radio.lastroot.value
1428 if pathstr is not None and pathstr.find(refstr) == 0:
1430 lastservice=eServiceReference(config.radio.lastservice.value)
1431 if lastservice.valid():
1432 self.setCurrentSelection(lastservice)
1439 lastservice=eServiceReference(config.radio.lastservice.value)
1440 if lastservice.valid():
1441 self.servicelist.setCurrent(lastservice)
1442 self.session.nav.playService(lastservice)
1444 self.session.nav.stopService()
1447 def channelSelected(self): # just return selected service
1448 ref = self.getCurrentSelection()
1450 self.toggleMoveMarked()
1451 elif (ref.flags & 7) == 7:
1453 elif self.bouquet_mark_edit != OFF:
1454 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1456 elif not (ref.flags & eServiceReference.isMarker): # no marker
1457 cur_root = self.getRoot()
1458 if not cur_root or not (cur_root.flags & eServiceReference.isGroup):
1459 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1460 if playingref is None or playingref != ref:
1461 self.session.nav.playService(ref)
1462 config.radio.lastservice.value = ref.toString()
1463 config.radio.lastservice.save()
1466 class SimpleChannelSelection(ChannelSelectionBase):
1467 def __init__(self, session, title):
1468 ChannelSelectionBase.__init__(self, session)
1470 self.onShown.append(self.__onExecCallback)
1472 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1474 "cancel": self.close,
1475 "ok": self.channelSelected,
1476 "keyRadio": self.setModeRadio,
1477 "keyTV": self.setModeTv,
1480 def __onExecCallback(self):
1481 self.setTitle(self.title)
1484 def channelSelected(self): # just return selected service
1485 ref = self.getCurrentSelection()
1486 if (ref.flags & 7) == 7:
1488 elif not (ref.flags & eServiceReference.isMarker):
1489 ref = self.getCurrentSelection()
1492 def setModeTv(self):
1494 self.showFavourites()
1496 def setModeRadio(self):
1498 self.showFavourites()