1 from Tools.Profile import profile
3 from Screen import Screen
4 from Components.Button import Button
5 from Components.ServiceList import ServiceList
6 from Components.ActionMap import NumberActionMap, ActionMap, HelpableActionMap
7 from Components.MenuList import MenuList
8 from Components.ServiceEventTracker import ServiceEventTracker, InfoBarBase
9 profile("ChannelSelection.py 1")
10 from EpgSelection import EPGSelection
11 from enigma import eServiceReference, eEPGCache, eServiceCenter, eRCInput, eTimer, eDVBDB, iPlayableService, iServiceInformation, getPrevAsciiCode
12 from Components.config import config, ConfigSubsection, ConfigText
13 from Tools.NumericalTextInput import NumericalTextInput
14 profile("ChannelSelection.py 2")
15 from Components.NimManager import nimmanager
16 profile("ChannelSelection.py 2.1")
17 from Components.Sources.RdsDecoder import RdsDecoder
18 profile("ChannelSelection.py 2.2")
19 from Components.Sources.ServiceEvent import ServiceEvent
20 profile("ChannelSelection.py 2.3")
21 from Components.Input import Input
22 profile("ChannelSelection.py 3")
23 from Components.ParentalControl import parentalControl
24 from Components.Pixmap import Pixmap
25 from Screens.InputBox import InputBox, PinInput
26 from Screens.MessageBox import MessageBox
27 from Screens.ServiceInfo import ServiceInfo
28 profile("ChannelSelection.py 4")
29 from Screens.RdsDisplay import RassInteractive
30 from ServiceReference import ServiceReference
31 from Tools.BoundFunction import boundFunction
32 from re import compile
34 profile("ChannelSelection.py after imports")
36 FLAG_SERVICE_NEW_FOUND = 64 #define in lib/dvb/idvb.h as dxNewFound = 64
38 class BouquetSelector(Screen):
39 def __init__(self, session, bouquets, selectedFunc, enableWrapAround=False):
40 Screen.__init__(self, session)
42 self.selectedFunc=selectedFunc
44 self["actions"] = ActionMap(["OkCancelActions"],
46 "ok": self.okbuttonClick,
47 "cancel": self.cancelClick
49 entrys = [ (x[0], x[1]) for x in bouquets ]
50 self["menu"] = MenuList(entrys, enableWrapAround)
53 cur = self["menu"].getCurrent()
56 def okbuttonClick(self):
57 self.selectedFunc(self.getCurrent())
65 def cancelClick(self):
68 # csel.bouquet_mark_edit values
73 def append_when_current_valid(current, menu, args, level = 0):
74 if current and current.valid() and level <= config.usage.setup_level.index:
77 class ChannelContextMenu(Screen):
78 def __init__(self, session, csel):
79 Screen.__init__(self, session)
80 #raise "we need a better summary screen here"
84 self["actions"] = ActionMap(["OkCancelActions"],
86 "ok": self.okbuttonClick,
87 "cancel": self.cancelClick
91 current = csel.getCurrentSelection()
92 current_root = csel.getRoot()
93 current_sel_path = current.getPath()
94 current_sel_flags = current.flags
95 inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
96 inBouquet = csel.getMutableList() is not None
97 haveBouquets = config.usage.multibouquet.value
99 if not (len(current_sel_path) or current_sel_flags & (eServiceReference.isDirectory|eServiceReference.isMarker)):
100 append_when_current_valid(current, menu, (_("show transponder info"), self.showServiceInformations), level = 2)
101 if csel.bouquet_mark_edit == OFF and not csel.movemode:
102 if not inBouquetRootList:
103 isPlayable = not (current_sel_flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
105 if config.ParentalControl.configured.value:
106 if parentalControl.getProtectionLevel(csel.getCurrentSelection().toCompareString()) == -1:
107 append_when_current_valid(current, menu, (_("add to parental protection"), boundFunction(self.addParentalProtection, csel.getCurrentSelection())), level = 0)
109 append_when_current_valid(current, menu, (_("remove from parental protection"), boundFunction(self.removeParentalProtection, csel.getCurrentSelection())), level = 0)
111 append_when_current_valid(current, menu, (_("add service to bouquet"), self.addServiceToBouquetSelected), level = 0)
113 append_when_current_valid(current, menu, (_("add service to favourites"), self.addServiceToBouquetSelected), level = 0)
116 if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
117 append_when_current_valid(current, menu, (_("copy to bouquets"), self.copyCurrentToBouquetList), level = 0)
118 if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
119 append_when_current_valid(current, menu, (_("remove all new found flags"), self.removeAllNewFoundFlags), level = 0)
121 append_when_current_valid(current, menu, (_("remove entry"), self.removeCurrentService), level = 0)
122 if current_root and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
123 append_when_current_valid(current, menu, (_("remove new found flag"), self.removeNewFoundFlag), level = 0)
125 menu.append((_("add bouquet"), self.showBouquetInputBox))
126 append_when_current_valid(current, menu, (_("remove entry"), self.removeBouquet), level = 0)
128 if inBouquet: # current list is editable?
129 if csel.bouquet_mark_edit == OFF:
130 if not csel.movemode:
131 append_when_current_valid(current, menu, (_("enable move mode"), self.toggleMoveMode), level = 1)
132 if not inBouquetRootList and current_root and not (current_root.flags & eServiceReference.isGroup):
133 menu.append((_("add marker"), self.showMarkerInputBox))
135 append_when_current_valid(current, menu, (_("enable bouquet edit"), self.bouquetMarkStart), level = 0)
137 append_when_current_valid(current, menu, (_("enable favourite edit"), self.bouquetMarkStart), level = 0)
138 if current_sel_flags & eServiceReference.isGroup:
139 append_when_current_valid(current, menu, (_("edit alternatives"), self.editAlternativeServices), level = 2)
140 append_when_current_valid(current, menu, (_("show alternatives"), self.showAlternativeServices), level = 2)
141 append_when_current_valid(current, menu, (_("remove all alternatives"), self.removeAlternativeServices), level = 2)
142 elif not current_sel_flags & eServiceReference.isMarker:
143 append_when_current_valid(current, menu, (_("add alternatives"), self.addAlternativeServices), level = 2)
145 append_when_current_valid(current, menu, (_("disable move mode"), self.toggleMoveMode), level = 0)
147 if csel.bouquet_mark_edit == EDIT_BOUQUET:
149 append_when_current_valid(current, menu, (_("end bouquet edit"), self.bouquetMarkEnd), level = 0)
150 append_when_current_valid(current, menu, (_("abort bouquet edit"), self.bouquetMarkAbort), level = 0)
152 append_when_current_valid(current, menu, (_("end favourites edit"), self.bouquetMarkEnd), level = 0)
153 append_when_current_valid(current, menu, (_("abort favourites edit"), self.bouquetMarkAbort), level = 0)
155 append_when_current_valid(current, menu, (_("end alternatives edit"), self.bouquetMarkEnd), level = 0)
156 append_when_current_valid(current, menu, (_("abort alternatives edit"), self.bouquetMarkAbort), level = 0)
158 menu.append((_("back"), self.cancelClick))
159 self["menu"] = MenuList(menu)
161 def okbuttonClick(self):
162 self["menu"].getCurrent()[1]()
164 def cancelClick(self):
167 def showServiceInformations(self):
168 self.session.open( ServiceInfo, self.csel.getCurrentSelection() )
170 def showBouquetInputBox(self):
171 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)
173 def bouquetInputCallback(self, bouquet):
174 if bouquet is not None:
175 self.csel.addBouquet(bouquet, None)
178 def addParentalProtection(self, service):
179 parentalControl.protectService(service.toCompareString())
182 def removeParentalProtection(self, service):
183 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"))
185 def pinEntered(self, service, result):
187 parentalControl.unProtectService(service)
190 self.session.openWithCallback(self.close, MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR)
192 def addServiceToBouquetSelected(self):
193 bouquets = self.csel.getBouquetList()
198 if cnt > 1: # show bouquet list
199 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
200 elif cnt == 1: # add to only one existing bouquet
201 self.addCurrentServiceToBouquet(bouquets[0][1])
203 def bouquetSelClosed(self, recursive):
208 def copyCurrentToBouquetList(self):
209 self.csel.copyCurrentToBouquetList()
212 def removeBouquet(self):
213 self.csel.removeBouquet()
216 def showMarkerInputBox(self):
217 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)
219 def markerInputCallback(self, marker):
220 if marker is not None:
221 self.csel.addMarker(marker)
224 def addCurrentServiceToBouquet(self, dest):
225 self.csel.addServiceToBouquet(dest)
226 if self.bsel is not None:
227 self.bsel.close(True)
229 self.close(True) # close bouquet selection
231 def removeCurrentService(self):
232 self.csel.removeCurrentService()
235 def toggleMoveMode(self):
236 self.csel.toggleMoveMode()
239 def bouquetMarkStart(self):
240 self.csel.startMarkedEdit(EDIT_BOUQUET)
243 def bouquetMarkEnd(self):
244 self.csel.endMarkedEdit(abort=False)
247 def bouquetMarkAbort(self):
248 self.csel.endMarkedEdit(abort=True)
251 def removeNewFoundFlag(self):
252 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
255 def removeAllNewFoundFlags(self):
256 curpath = self.csel.getCurrentSelection().getPath()
257 idx = curpath.find("satellitePosition == ")
259 tmp = curpath[idx+21:]
262 satpos = int(tmp[:idx])
263 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
266 def editAlternativeServices(self):
267 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
270 def showAlternativeServices(self):
271 self.csel.enterPath(self.csel.getCurrentSelection())
274 def removeAlternativeServices(self):
275 self.csel.removeAlternativeServices()
278 def addAlternativeServices(self):
279 self.csel.addAlternativeServices()
280 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
283 class SelectionEventInfo:
285 self["ServiceEvent"] = ServiceEvent()
286 self.servicelist.connectSelChanged(self.__selectionChanged)
287 self.timer = eTimer()
288 self.timer.callback.append(self.updateEventInfo)
289 self.onShown.append(self.__selectionChanged)
291 def __selectionChanged(self):
293 self.timer.start(100, True)
295 def updateEventInfo(self):
296 cur = self.getCurrentSelection()
297 self["ServiceEvent"].newService(cur)
299 class ChannelSelectionEPG:
301 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
303 "showEPGList": self.showEPGList,
306 def showEPGList(self):
307 ref=self.getCurrentSelection()
308 ptr=eEPGCache.getInstance()
309 if ptr.startTimeQuery(ref) != -1:
310 self.session.open(EPGSelection, ref)
312 print 'no epg for service', ref.toString()
314 class ChannelSelectionEdit:
316 self.entry_marked = False
317 self.movemode = False
318 self.bouquet_mark_edit = OFF
319 self.mutableList = None
321 self.saved_title = None
322 self.saved_root = None
324 class ChannelSelectionEditActionMap(ActionMap):
325 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
326 ActionMap.__init__(self, contexts, actions, prio)
329 def action(self, contexts, action):
330 if action == "cancel":
331 self.csel.handleEditCancel()
332 return 0 # fall-trough
334 return 0 # fall-trough
336 return ActionMap.action(self, contexts, action)
338 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
340 "contextMenu": self.doContext,
343 def getMutableList(self, root=eServiceReference()):
344 if not self.mutableList is None:
345 return self.mutableList
346 serviceHandler = eServiceCenter.getInstance()
349 list = root and serviceHandler.list(root)
351 return list.startEdit()
354 def buildBouquetID(self, str):
358 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
364 def addMarker(self, name):
365 current = self.servicelist.getCurrent()
366 mutableList = self.getMutableList()
369 str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
370 ref = eServiceReference(str)
371 if current and current.valid():
372 if not mutableList.addService(ref, current):
373 self.servicelist.addService(ref, True)
374 mutableList.flushChanges()
376 elif not mutableList.addService(ref):
377 self.servicelist.addService(ref, True)
378 mutableList.flushChanges()
382 def addAlternativeServices(self):
383 cur_service = ServiceReference(self.getCurrentSelection())
384 root = self.getRoot()
385 cur_root = root and ServiceReference(root)
386 mutableBouquet = cur_root.list().startEdit()
388 name = cur_service.getServiceName()
390 if self.mode == MODE_TV:
391 str = '1:134:1:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(name))
393 str = '1:134:2:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(name))
394 new_ref = ServiceReference(str)
395 if not mutableBouquet.addService(new_ref.ref, cur_service.ref):
396 mutableBouquet.removeService(cur_service.ref)
397 mutableBouquet.flushChanges()
398 eDVBDB.getInstance().reloadBouquets()
399 mutableAlternatives = new_ref.list().startEdit()
400 if mutableAlternatives:
401 mutableAlternatives.setListName(name)
402 if mutableAlternatives.addService(cur_service.ref):
403 print "add", cur_service.toString(), "to new alternatives failed"
404 mutableAlternatives.flushChanges()
405 self.servicelist.addService(new_ref.ref, True)
406 self.servicelist.removeCurrent()
407 self.servicelist.moveUp()
409 print "get mutable list for new created alternatives failed"
411 print "add", str, "to", cur_root.getServiceName(), "failed"
413 print "bouquetlist is not editable"
415 def addBouquet(self, bName, services):
416 serviceHandler = eServiceCenter.getInstance()
417 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
418 if mutableBouquetList:
419 if self.mode == MODE_TV:
421 str = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
424 str = '1:7:2:0:0:0:0:0:0:0:FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
425 new_bouquet_ref = eServiceReference(str)
426 if not mutableBouquetList.addService(new_bouquet_ref):
427 mutableBouquetList.flushChanges()
428 eDVBDB.getInstance().reloadBouquets()
429 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
431 mutableBouquet.setListName(bName)
432 if services is not None:
433 for service in services:
434 if mutableBouquet.addService(service):
435 print "add", service.toString(), "to new bouquet failed"
436 mutableBouquet.flushChanges()
438 print "get mutable list for new created bouquet failed"
439 # do some voodoo to check if current_root is equal to bouquet_root
440 cur_root = self.getRoot();
441 str1 = cur_root and cur_root.toString()
442 pos1 = str1 and str1.find("FROM BOUQUET") or -1
443 pos2 = self.bouquet_rootstr.find("FROM BOUQUET")
444 if pos1 != -1 and pos2 != -1 and str1[pos1:] == self.bouquet_rootstr[pos2:]:
445 self.servicelist.addService(new_bouquet_ref)
447 print "add", str, "to bouquets failed"
449 print "bouquetlist is not editable"
451 def copyCurrentToBouquetList(self):
452 provider = ServiceReference(self.getCurrentSelection())
453 providerName = provider.getServiceName()
454 serviceHandler = eServiceCenter.getInstance()
455 services = serviceHandler.list(provider.ref)
456 self.addBouquet(providerName, services and services.getContent('R', True))
458 def removeAlternativeServices(self):
459 cur_service = ServiceReference(self.getCurrentSelection())
460 root = self.getRoot()
461 cur_root = root and ServiceReference(root)
462 list = cur_service.list()
463 first_in_alternative = list and list.getNext()
464 if first_in_alternative:
465 edit_root = cur_root and cur_root.list().startEdit()
467 if not edit_root.addService(first_in_alternative, cur_service.ref):
468 self.servicelist.addService(first_in_alternative, True)
470 print "couldn't add first alternative service to current root"
472 print "couldn't edit current root!!"
474 print "remove empty alternative list !!"
476 self.servicelist.moveUp()
478 def removeBouquet(self):
479 refstr = self.getCurrentSelection().toString()
480 print "removeBouquet", refstr
481 self.bouquetNumOffsetCache = { }
482 pos = refstr.find('FROM BOUQUET "')
485 refstr = refstr[pos+14:]
486 pos = refstr.find('"')
488 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
489 self.removeCurrentService()
491 if filename is not None:
494 print "error during remove of", filename
496 # multiple marked entry stuff ( edit mode, later multiepg selection )
497 def startMarkedEdit(self, type):
498 self.savedPath = self.servicePath[:]
499 if type == EDIT_ALTERNATIVES:
500 self.enterPath(self.getCurrentSelection())
501 self.mutableList = self.getMutableList()
502 # add all services from the current list to internal marked set in listboxservicecontent
503 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
504 self.saved_title = self.instance.getTitle()
505 pos = self.saved_title.find(')')
506 new_title = self.saved_title[:pos+1]
507 if type == EDIT_ALTERNATIVES:
508 self.bouquet_mark_edit = EDIT_ALTERNATIVES
509 new_title += ' ' + _("[alternative edit]")
511 self.bouquet_mark_edit = EDIT_BOUQUET
512 if config.usage.multibouquet.value:
513 new_title += ' ' + _("[bouquet edit]")
515 new_title += ' ' + _("[favourite edit]")
516 self.setTitle(new_title)
517 self.__marked = self.servicelist.getRootServices()
518 for x in self.__marked:
519 self.servicelist.addMarked(eServiceReference(x))
520 self.showAllServices()
522 def endMarkedEdit(self, abort):
523 if not abort and self.mutableList is not None:
524 self.bouquetNumOffsetCache = { }
525 new_marked = set(self.servicelist.getMarked())
526 old_marked = set(self.__marked)
527 removed = old_marked - new_marked
528 added = new_marked - old_marked
532 self.mutableList.removeService(eServiceReference(x))
535 self.mutableList.addService(eServiceReference(x))
537 self.mutableList.flushChanges()
540 self.bouquet_mark_edit = OFF
541 self.mutableList = None
542 self.setTitle(self.saved_title)
543 self.saved_title = None
544 # self.servicePath is just a reference to servicePathTv or Radio...
545 # so we never ever do use the asignment operator in self.servicePath
546 del self.servicePath[:] # remove all elements
547 self.servicePath += self.savedPath # add saved elements
549 self.setRoot(self.servicePath[len(self.servicePath)-1])
551 def clearMarks(self):
552 self.servicelist.clearMarks()
555 ref = self.servicelist.getCurrent()
556 if self.servicelist.isMarked(ref):
557 self.servicelist.removeMarked(ref)
559 self.servicelist.addMarked(ref)
561 def removeCurrentService(self):
562 ref = self.servicelist.getCurrent()
563 mutableList = self.getMutableList()
564 if ref.valid() and mutableList is not None:
565 if not mutableList.removeService(ref):
566 self.bouquetNumOffsetCache = { }
567 mutableList.flushChanges() #FIXME dont flush on each single removed service
568 self.servicelist.removeCurrent()
570 def addServiceToBouquet(self, dest, service=None):
571 mutableList = self.getMutableList(dest)
572 if not mutableList is None:
573 if service is None: #use current selected service
574 service = self.servicelist.getCurrent()
575 if not mutableList.addService(service):
576 self.bouquetNumOffsetCache = { }
577 mutableList.flushChanges()
578 # do some voodoo to check if current_root is equal to dest
579 cur_root = self.getRoot();
580 str1 = cur_root and cur_root.toString() or -1
581 str2 = dest.toString()
582 pos1 = str1.find("FROM BOUQUET")
583 pos2 = str2.find("FROM BOUQUET")
584 if pos1 != -1 and pos2 != -1 and str1[pos1:] == str2[pos2:]:
585 self.servicelist.addService(service)
587 def toggleMoveMode(self):
589 if self.entry_marked:
590 self.toggleMoveMarked() # unmark current entry
591 self.movemode = False
592 self.pathChangeDisabled = False # re-enable path change
593 self.mutableList.flushChanges() # FIXME add check if changes was made
594 self.mutableList = None
595 self.setTitle(self.saved_title)
596 self.saved_title = None
597 cur_root = self.getRoot()
598 if cur_root and cur_root == self.bouquet_root:
599 self.bouquetNumOffsetCache = { }
601 self.mutableList = self.getMutableList()
603 self.pathChangeDisabled = True # no path change allowed in movemode
604 self.saved_title = self.instance.getTitle()
605 new_title = self.saved_title
606 pos = self.saved_title.find(')')
607 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
608 self.setTitle(new_title);
610 def handleEditCancel(self):
611 if self.movemode: #movemode active?
612 self.channelSelected() # unmark
613 self.toggleMoveMode() # disable move mode
614 elif self.bouquet_mark_edit != OFF:
615 self.endMarkedEdit(True) # abort edit mode
617 def toggleMoveMarked(self):
618 if self.entry_marked:
619 self.servicelist.setCurrentMarked(False)
620 self.entry_marked = False
622 self.servicelist.setCurrentMarked(True)
623 self.entry_marked = True
626 self.session.open(ChannelContextMenu, self)
631 # this makes it much simple to implement a selectable radio or tv mode :)
632 service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25) || (type == 134)'
633 service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
635 class ChannelSelectionBase(Screen):
636 def __init__(self, session):
637 Screen.__init__(self, session)
639 self["key_red"] = Button(_("All"))
640 self["key_green"] = Button(_("Satellites"))
641 self["key_yellow"] = Button(_("Provider"))
642 self["key_blue"] = Button(_("Favourites"))
644 self["list"] = ServiceList()
645 self.servicelist = self["list"]
647 self.numericalTextInput = NumericalTextInput()
648 self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
650 self.servicePathTV = [ ]
651 self.servicePathRadio = [ ]
652 self.servicePath = [ ]
656 self.pathChangeDisabled = False
658 self.bouquetNumOffsetCache = { }
660 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions", "InputAsciiActions"],
662 "showFavourites": self.showFavourites,
663 "showAllServices": self.showAllServices,
664 "showProviders": self.showProviders,
665 "showSatellites": self.showSatellites,
666 "nextBouquet": self.nextBouquet,
667 "prevBouquet": self.prevBouquet,
668 "nextMarker": self.nextMarker,
669 "prevMarker": self.prevMarker,
670 "gotAsciiCode": self.keyAsciiCode,
671 "1": self.keyNumberGlobal,
672 "2": self.keyNumberGlobal,
673 "3": self.keyNumberGlobal,
674 "4": self.keyNumberGlobal,
675 "5": self.keyNumberGlobal,
676 "6": self.keyNumberGlobal,
677 "7": self.keyNumberGlobal,
678 "8": self.keyNumberGlobal,
679 "9": self.keyNumberGlobal,
682 self.recallBouquetMode()
684 def getBouquetNumOffset(self, bouquet):
685 if not config.usage.multibouquet.value:
687 str = bouquet.toString()
689 if not self.bouquetNumOffsetCache.has_key(str):
690 serviceHandler = eServiceCenter.getInstance()
691 bouquetlist = serviceHandler.list(self.bouquet_root)
692 if not bouquetlist is None:
694 bouquetIterator = bouquetlist.getNext()
695 if not bouquetIterator.valid(): #end of list
697 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
698 if not (bouquetIterator.flags & eServiceReference.isDirectory):
700 servicelist = serviceHandler.list(bouquetIterator)
701 if not servicelist is None:
703 serviceIterator = servicelist.getNext()
704 if not serviceIterator.valid(): #check if end of list
706 playable = not (serviceIterator.flags & (eServiceReference.isDirectory|eServiceReference.isMarker))
709 return self.bouquetNumOffsetCache.get(str, offsetCount)
711 def recallBouquetMode(self):
712 if self.mode == MODE_TV:
713 self.service_types = service_types_tv
714 if config.usage.multibouquet.value:
715 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
717 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
719 self.service_types = service_types_radio
720 if config.usage.multibouquet.value:
721 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
723 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
724 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
728 self.servicePath = self.servicePathTV
729 self.recallBouquetMode()
730 title = self.instance.getTitle()
731 pos = title.find(" (")
737 def setRadioMode(self):
738 self.mode = MODE_RADIO
739 self.servicePath = self.servicePathRadio
740 self.recallBouquetMode()
741 title = self.instance.getTitle()
742 pos = title.find(" (")
748 def setRoot(self, root, justSet=False):
749 path = root.getPath()
750 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
751 pos = path.find('FROM BOUQUET')
752 isBouquet = (pos != -1) and (root.flags & eServiceReference.isDirectory)
753 if not inBouquetRootList and isBouquet:
754 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
755 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
757 self.servicelist.setMode(ServiceList.MODE_NORMAL)
758 self.servicelist.setRoot(root, justSet)
759 self.buildTitleString()
761 def removeModeStr(self, str):
762 if self.mode == MODE_TV:
763 pos = str.find(' (TV)')
765 pos = str.find(' (Radio)')
770 def getServiceName(self, ref):
771 str = self.removeModeStr(ServiceReference(ref).getServiceName())
773 pathstr = ref.getPath()
774 if pathstr.find('FROM PROVIDERS') != -1:
776 if pathstr.find('FROM SATELLITES') != -1:
777 return _("Satellites")
778 if pathstr.find(') ORDER BY name') != -1:
782 def buildTitleString(self):
783 titleStr = self.instance.getTitle()
784 pos = titleStr.find(']')
786 pos = titleStr.find(')')
788 titleStr = titleStr[:pos+1]
789 Len = len(self.servicePath)
791 base_ref = self.servicePath[0]
793 end_ref = self.servicePath[Len-1]
796 nameStr = self.getServiceName(base_ref)
797 titleStr += ' ' + nameStr
798 if end_ref is not None:
803 nameStr = self.getServiceName(end_ref)
805 self.setTitle(titleStr)
808 self.servicelist.moveUp()
811 self.servicelist.moveDown()
814 del self.servicePath[:]
816 def enterPath(self, ref, justSet=False):
817 self.servicePath.append(ref)
818 self.setRoot(ref, justSet)
820 def pathUp(self, justSet=False):
821 prev = self.servicePath.pop()
822 length = len(self.servicePath)
824 current = self.servicePath[length-1]
825 self.setRoot(current, justSet)
827 self.setCurrentSelection(prev)
830 def isBasePathEqual(self, ref):
831 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
835 def isPrevPathEqual(self, ref):
836 length = len(self.servicePath)
837 if length > 1 and self.servicePath[length-2] == ref:
841 def preEnterPath(self, refstr):
844 def showAllServices(self):
845 if not self.pathChangeDisabled:
846 refstr = '%s ORDER BY name'%(self.service_types)
847 if not self.preEnterPath(refstr):
848 ref = eServiceReference(refstr)
849 currentRoot = self.getRoot()
850 if currentRoot is None or currentRoot != ref:
854 def showSatellites(self):
855 if not self.pathChangeDisabled:
856 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
857 if not self.preEnterPath(refstr):
858 ref = eServiceReference(refstr)
862 if self.isBasePathEqual(ref):
863 if self.isPrevPathEqual(ref):
865 prev = self.pathUp(justSet)
867 currentRoot = self.getRoot()
868 if currentRoot is None or currentRoot != ref:
871 self.enterPath(ref, True)
873 serviceHandler = eServiceCenter.getInstance()
874 servicelist = serviceHandler.list(ref)
875 if not servicelist is None:
877 service = servicelist.getNext()
878 if not service.valid(): #check if end of list
880 unsigned_orbpos = service.getUnsignedData(4) >> 16
881 orbpos = service.getData(4) >> 16
884 if service.getPath().find("FROM PROVIDER") != -1:
885 service_type = _("Providers")
886 elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
887 service_type = _("New")
889 service_type = _("Services")
891 # why we need this cast?
892 service_name = str(nimmanager.getSatDescription(orbpos))
894 if unsigned_orbpos == 0xFFFF: #Cable
895 service_name = _("Cable")
896 elif unsigned_orbpos == 0xEEEE: #Terrestrial
897 service_name = _("Terrestrial")
899 if orbpos > 1800: # west
900 orbpos = 3600 - orbpos
904 service_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
905 service.setName("%s - %s" % (service_name, service_type))
906 self.servicelist.addService(service)
907 cur_ref = self.session.nav.getCurrentlyPlayingServiceReference()
909 pos = self.service_types.rfind(':')
910 refstr = '%s (channelID == %08x%04x%04x) && %s ORDER BY name' %(self.service_types[:pos+1],
911 cur_ref.getUnsignedData(4), # NAMESPACE
912 cur_ref.getUnsignedData(2), # TSID
913 cur_ref.getUnsignedData(3), # ONID
914 self.service_types[pos+1:])
915 ref = eServiceReference(refstr)
916 ref.setName(_("Current Transponder"))
917 self.servicelist.addService(ref)
918 self.servicelist.finishFill()
920 self.setCurrentSelection(prev)
922 def showProviders(self):
923 if not self.pathChangeDisabled:
924 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
925 if not self.preEnterPath(refstr):
926 ref = eServiceReference(refstr)
927 if self.isBasePathEqual(ref):
930 currentRoot = self.getRoot()
931 if currentRoot is None or currentRoot != ref:
935 def changeBouquet(self, direction):
936 if not self.pathChangeDisabled:
937 if len(self.servicePath) > 1:
938 #when enter satellite root list we must do some magic stuff..
939 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
940 if self.isBasePathEqual(ref):
941 self.showSatellites()
948 ref = self.getCurrentSelection()
952 if len(self.servicePath) > 0 and self.servicePath[0] == self.bouquet_root:
957 return self.servicelist.atBegin()
960 return self.servicelist.atEnd()
962 def nextBouquet(self):
963 self.changeBouquet(+1)
965 def prevBouquet(self):
966 self.changeBouquet(-1)
968 def showFavourites(self):
969 if not self.pathChangeDisabled:
970 if not self.preEnterPath(self.bouquet_rootstr):
971 if self.isBasePathEqual(self.bouquet_root):
974 currentRoot = self.getRoot()
975 if currentRoot is None or currentRoot != self.bouquet_root:
977 self.enterPath(self.bouquet_root)
979 def keyNumberGlobal(self, number):
980 unichar = self.numericalTextInput.getKey(number)
981 charstr = unichar.encode("utf-8")
982 if len(charstr) == 1:
983 self.servicelist.moveToChar(charstr[0])
985 def keyAsciiCode(self):
986 unichar = unichr(getPrevAsciiCode())
987 charstr = unichar.encode("utf-8")
988 if len(charstr) == 1:
989 self.servicelist.moveToChar(charstr[0])
992 return self.servicelist.getRoot()
994 def getCurrentSelection(self):
995 return self.servicelist.getCurrent()
997 def setCurrentSelection(self, service):
998 self.servicelist.setCurrent(service)
1000 def getBouquetList(self):
1002 serviceHandler = eServiceCenter.getInstance()
1003 if config.usage.multibouquet.value:
1004 list = serviceHandler.list(self.bouquet_root)
1010 if s.flags & eServiceReference.isDirectory:
1011 info = serviceHandler.info(s)
1013 bouquets.append((info.getName(s), s))
1016 info = serviceHandler.info(self.bouquet_root)
1018 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
1022 def keyNumber0(self, num):
1023 if len(self.servicePath) > 1:
1026 self.keyNumberGlobal(num)
1029 if len(self.servicePath) > 1:
1030 if self.isBasePathEqual(self.bouquet_root):
1031 self.showFavourites()
1033 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
1034 if self.isBasePathEqual(ref):
1035 self.showSatellites()
1037 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
1038 if self.isBasePathEqual(ref):
1039 self.showProviders()
1041 self.showAllServices()
1043 def nextMarker(self):
1044 self.servicelist.moveToNextMarker()
1046 def prevMarker(self):
1047 self.servicelist.moveToPrevMarker()
1051 #config for lastservice
1052 config.tv = ConfigSubsection()
1053 config.tv.lastservice = ConfigText()
1054 config.tv.lastroot = ConfigText()
1055 config.radio = ConfigSubsection()
1056 config.radio.lastservice = ConfigText()
1057 config.radio.lastroot = ConfigText()
1058 config.servicelist = ConfigSubsection()
1059 config.servicelist.lastmode = ConfigText(default = "tv")
1061 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, SelectionEventInfo):
1062 def __init__(self, session):
1063 ChannelSelectionBase.__init__(self,session)
1064 ChannelSelectionEdit.__init__(self)
1065 ChannelSelectionEPG.__init__(self)
1066 SelectionEventInfo.__init__(self)
1068 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1070 "cancel": self.cancel,
1071 "ok": self.channelSelected,
1072 "keyRadio": self.setModeRadio,
1073 "keyTV": self.setModeTv,
1076 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1078 iPlayableService.evStart: self.__evServiceStart,
1079 iPlayableService.evEnd: self.__evServiceEnd
1082 self.lastChannelRootTimer = eTimer()
1083 self.lastChannelRootTimer.callback.append(self.__onCreate)
1084 self.lastChannelRootTimer.start(100,True)
1086 self.history_tv = [ ]
1087 self.history_radio = [ ]
1088 self.history = self.history_tv
1089 self.history_pos = 0
1091 self.lastservice = config.tv.lastservice
1092 self.lastroot = config.tv.lastroot
1093 self.revertMode = None
1094 config.usage.multibouquet.addNotifier(self.multibouquet_config_changed)
1095 self.new_service_played = False
1096 self.onExecBegin.append(self.asciiOn)
1099 rcinput = eRCInput.getInstance()
1100 rcinput.setKeyboardMode(rcinput.kmAscii)
1103 rcinput = eRCInput.getInstance()
1104 rcinput.setKeyboardMode(rcinput.kmNone)
1106 def multibouquet_config_changed(self, val):
1107 self.recallBouquetMode()
1109 def __evServiceStart(self):
1110 service = self.session.nav.getCurrentService()
1112 info = service.info()
1114 refstr = info.getInfoString(iServiceInformation.sServiceref)
1115 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1117 def __evServiceEnd(self):
1118 self.servicelist.setPlayableIgnoreService(eServiceReference())
1122 lastservice=eServiceReference(self.lastservice.value)
1123 if lastservice.valid():
1124 self.setCurrentSelection(lastservice)
1126 def setModeTv(self):
1127 if self.revertMode is None and config.servicelist.lastmode.value == "radio":
1128 self.revertMode = MODE_RADIO
1129 self.history = self.history_tv
1130 self.lastservice = config.tv.lastservice
1131 self.lastroot = config.tv.lastroot
1132 config.servicelist.lastmode.value = "tv"
1136 def setModeRadio(self):
1137 if self.revertMode is None and config.servicelist.lastmode.value == "tv":
1138 self.revertMode = MODE_TV
1139 if config.usage.e1like_radio_mode.value:
1140 self.history = self.history_radio
1141 self.lastservice = config.radio.lastservice
1142 self.lastroot = config.radio.lastroot
1143 config.servicelist.lastmode.value = "radio"
1147 def __onCreate(self):
1148 if config.usage.e1like_radio_mode.value:
1149 if config.servicelist.lastmode.value == "tv":
1155 lastservice=eServiceReference(self.lastservice.value)
1156 if lastservice.valid():
1159 def channelSelected(self):
1160 ref = self.getCurrentSelection()
1162 self.toggleMoveMarked()
1163 elif (ref.flags & 7) == 7:
1165 elif self.bouquet_mark_edit != OFF:
1166 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1168 elif not (ref.flags & eServiceReference.isMarker): # no marker
1169 root = self.getRoot()
1170 if not root or not (root.flags & eServiceReference.isGroup):
1175 #called from infoBar and channelSelected
1177 self.revertMode=None
1178 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1179 nref = self.getCurrentSelection()
1180 if ref is None or ref != nref:
1181 self.new_service_played = True
1182 self.session.nav.playService(nref)
1184 self.saveChannel(nref)
1185 config.servicelist.lastmode.save()
1186 self.addToHistory(nref)
1188 def newServicePlayed(self):
1189 ret = self.new_service_played
1190 self.new_service_played = False
1193 def addToHistory(self, ref):
1194 if self.servicePath is not None:
1195 tmp=self.servicePath[:]
1198 del self.history[self.history_pos+1:]
1201 self.history.append(tmp)
1202 hlen = len(self.history)
1203 if hlen > HISTORYSIZE:
1206 self.history_pos = hlen-1
1208 def historyBack(self):
1209 hlen = len(self.history)
1210 if hlen > 1 and self.history_pos > 0:
1211 self.history_pos -= 1
1212 self.setHistoryPath()
1214 def historyNext(self):
1215 hlen = len(self.history)
1216 if hlen > 1 and self.history_pos < (hlen-1):
1217 self.history_pos += 1
1218 self.setHistoryPath()
1220 def setHistoryPath(self):
1221 path = self.history[self.history_pos][:]
1223 del self.servicePath[:]
1224 self.servicePath += path
1228 cur_root = self.getRoot()
1229 if cur_root and cur_root != root:
1231 self.session.nav.playService(ref)
1232 self.setCurrentSelection(ref)
1233 self.saveChannel(ref)
1237 for i in self.servicePath:
1238 path += i.toString()
1240 if len(path) and path != self.lastroot.value:
1241 self.lastroot.value = path
1242 self.lastroot.save()
1244 def restoreRoot(self):
1246 re = compile('.+?;')
1247 tmp = re.findall(self.lastroot.value)
1250 self.servicePath.append(eServiceReference(i[:len(i)-1]))
1253 path = self.servicePath.pop()
1254 self.enterPath(path)
1256 self.showFavourites()
1259 def preEnterPath(self, refstr):
1260 if len(self.servicePath) and self.servicePath[0] != eServiceReference(refstr):
1261 pathstr = self.lastroot.value
1262 if pathstr is not None and pathstr.find(refstr) == 0:
1264 lastservice=eServiceReference(self.lastservice.value)
1265 if lastservice.valid():
1266 self.setCurrentSelection(lastservice)
1270 def saveChannel(self, ref):
1272 refstr = ref.toString()
1275 if refstr != self.lastservice.value:
1276 self.lastservice.value = refstr
1277 self.lastservice.save()
1279 def setCurrentServicePath(self, path):
1280 hlen = len(self.history)
1282 self.history[self.history_pos] = path
1284 self.history.append(path)
1285 self.setHistoryPath()
1287 def getCurrentServicePath(self):
1288 hlen = len(self.history)
1290 return self.history[self.history_pos]
1293 def recallPrevService(self):
1294 hlen = len(self.history)
1296 if self.history_pos == hlen-1:
1297 tmp = self.history[self.history_pos]
1298 self.history[self.history_pos] = self.history[self.history_pos-1]
1299 self.history[self.history_pos-1] = tmp
1301 tmp = self.history[self.history_pos+1]
1302 self.history[self.history_pos+1] = self.history[self.history_pos]
1303 self.history[self.history_pos] = tmp
1304 self.setHistoryPath()
1307 if self.revertMode is None:
1309 lastservice=eServiceReference(self.lastservice.value)
1310 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1311 self.setCurrentSelection(lastservice)
1312 elif self.revertMode == MODE_TV:
1314 elif self.revertMode == MODE_RADIO:
1316 self.revertMode = None
1320 class RadioInfoBar(Screen):
1321 def __init__(self, session):
1322 Screen.__init__(self, session)
1323 self["RdsDecoder"] = RdsDecoder(self.session.nav)
1325 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, InfoBarBase):
1326 ALLOW_SUSPEND = True
1328 def __init__(self, session, infobar):
1329 ChannelSelectionBase.__init__(self, session)
1330 ChannelSelectionEdit.__init__(self)
1331 ChannelSelectionEPG.__init__(self)
1332 InfoBarBase.__init__(self)
1333 self.infobar = infobar
1334 self.onLayoutFinish.append(self.onCreate)
1336 self.info = session.instantiateDialog(RadioInfoBar) # our simple infobar
1338 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1340 "keyTV": self.closeRadio,
1341 "keyRadio": self.closeRadio,
1342 "cancel": self.closeRadio,
1343 "ok": self.channelSelected,
1346 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1348 iPlayableService.evStart: self.__evServiceStart,
1349 iPlayableService.evEnd: self.__evServiceEnd
1352 ########## RDS Radiotext / Rass Support BEGIN
1353 self.infobar = infobar # reference to real infobar (the one and only)
1354 self["RdsDecoder"] = self.info["RdsDecoder"]
1355 self["RdsActions"] = HelpableActionMap(self, "InfobarRdsActions",
1357 "startRassInteractive": (self.startRassInteractive, _("View Rass interactive..."))
1359 self["RdsActions"].setEnabled(False)
1360 infobar.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
1362 def startRassInteractive(self):
1364 self.infobar.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
1366 def RassInteractiveClosed(self):
1368 self.infobar.rass_interactive = None
1369 self.infobar.RassSlidePicChanged()
1371 def RassInteractivePossibilityChanged(self, state):
1372 self["RdsActions"].setEnabled(state)
1373 ########## RDS Radiotext / Rass Support END
1375 def closeRadio(self):
1376 self.infobar.rds_display.onRassInteractivePossibilityChanged.remove(self.RassInteractivePossibilityChanged)
1378 #set previous tv service
1379 lastservice=eServiceReference(config.tv.lastservice.value)
1380 self.session.nav.playService(lastservice)
1383 def __evServiceStart(self):
1384 service = self.session.nav.getCurrentService()
1386 info = service.info()
1388 refstr = info.getInfoString(iServiceInformation.sServiceref)
1389 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1391 def __evServiceEnd(self):
1392 self.servicelist.setPlayableIgnoreService(eServiceReference())
1396 for i in self.servicePathRadio:
1397 path += i.toString()
1399 if len(path) and path != config.radio.lastroot.value:
1400 config.radio.lastroot.value = path
1401 config.radio.lastroot.save()
1403 def restoreRoot(self):
1405 re = compile('.+?;')
1406 tmp = re.findall(config.radio.lastroot.value)
1409 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1412 path = self.servicePathRadio.pop()
1413 self.enterPath(path)
1415 self.showFavourites()
1418 def preEnterPath(self, refstr):
1419 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1420 pathstr = config.radio.lastroot.value
1421 if pathstr is not None and pathstr.find(refstr) == 0:
1423 lastservice=eServiceReference(config.radio.lastservice.value)
1424 if lastservice.valid():
1425 self.setCurrentSelection(lastservice)
1432 lastservice=eServiceReference(config.radio.lastservice.value)
1433 if lastservice.valid():
1434 self.servicelist.setCurrent(lastservice)
1435 self.session.nav.playService(lastservice)
1437 self.session.nav.stopService()
1440 def channelSelected(self): # just return selected service
1441 ref = self.getCurrentSelection()
1443 self.toggleMoveMarked()
1444 elif (ref.flags & 7) == 7:
1446 elif self.bouquet_mark_edit != OFF:
1447 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1449 elif not (ref.flags & eServiceReference.isMarker): # no marker
1450 cur_root = self.getRoot()
1451 if not cur_root or not (cur_root.flags & eServiceReference.isGroup):
1452 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1453 if playingref is None or playingref != ref:
1454 self.session.nav.playService(ref)
1455 config.radio.lastservice.value = ref.toString()
1456 config.radio.lastservice.save()
1459 class SimpleChannelSelection(ChannelSelectionBase):
1460 def __init__(self, session, title):
1461 ChannelSelectionBase.__init__(self, session)
1463 self.onShown.append(self.__onExecCallback)
1465 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1467 "cancel": self.close,
1468 "ok": self.channelSelected,
1469 "keyRadio": self.setModeRadio,
1470 "keyTV": self.setModeTv,
1473 def __onExecCallback(self):
1474 self.setTitle(self.title)
1477 def channelSelected(self): # just return selected service
1478 ref = self.getCurrentSelection()
1479 if (ref.flags & 7) == 7:
1481 elif not (ref.flags & eServiceReference.isMarker):
1482 ref = self.getCurrentSelection()
1485 def setModeTv(self):
1487 self.showFavourites()
1489 def setModeRadio(self):
1491 self.showFavourites()