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.ChoiceList import ChoiceList, ChoiceEntryComponent
24 from Components.SystemInfo import SystemInfo
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.PictureInPicture import PictureInPicture
30 from Screens.RdsDisplay import RassInteractive
31 from ServiceReference import ServiceReference
32 from Tools.BoundFunction import boundFunction
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, key = ""):
74 if current and current.valid() and level <= config.usage.setup_level.index:
75 menu.append(ChoiceEntryComponent(key, args))
77 class ChannelContextMenu(Screen):
78 def __init__(self, session, csel):
80 Screen.__init__(self, session)
81 #raise Exception("we need a better summary screen here")
85 self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "NumberActions"],
87 "ok": self.okbuttonClick,
88 "cancel": self.cancelClick,
89 "blue": self.showServiceInPiP
93 self.pipAvailable = False
94 current = csel.getCurrentSelection()
95 current_root = csel.getRoot()
96 current_sel_path = current.getPath()
97 current_sel_flags = current.flags
98 inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
99 inBouquet = csel.getMutableList() is not None
100 haveBouquets = config.usage.multibouquet.value
102 if not (current_sel_path or current_sel_flags & (eServiceReference.isDirectory|eServiceReference.isMarker)):
103 append_when_current_valid(current, menu, (_("show transponder info"), self.showServiceInformations), level = 2)
104 if csel.bouquet_mark_edit == OFF and not csel.movemode:
105 if not inBouquetRootList:
106 isPlayable = not (current_sel_flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
108 if config.ParentalControl.configured.value:
109 from Components.ParentalControl import parentalControl
110 if parentalControl.getProtectionLevel(csel.getCurrentSelection().toCompareString()) == -1:
111 append_when_current_valid(current, menu, (_("add to parental protection"), boundFunction(self.addParentalProtection, csel.getCurrentSelection())), level = 0)
113 append_when_current_valid(current, menu, (_("remove from parental protection"), boundFunction(self.removeParentalProtection, csel.getCurrentSelection())), level = 0)
115 bouquets = self.csel.getBouquetList()
119 bouquetCnt = len(bouquets)
120 if not inBouquet or bouquetCnt > 1:
121 append_when_current_valid(current, menu, (_("add service to bouquet"), self.addServiceToBouquetSelected), level = 0)
124 append_when_current_valid(current, menu, (_("add service to favourites"), self.addServiceToBouquetSelected), level = 0)
126 if current_root.getPath().find('FROM SATELLITES') != -1:
127 append_when_current_valid(current, menu, (_("remove selected satellite"), self.removeSatelliteServices), level = 0)
129 if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
130 append_when_current_valid(current, menu, (_("copy to bouquets"), self.copyCurrentToBouquetList), level = 0)
131 if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
132 append_when_current_valid(current, menu, (_("remove all new found flags"), self.removeAllNewFoundFlags), level = 0)
134 append_when_current_valid(current, menu, (_("remove entry"), self.removeCurrentService), level = 0)
135 if current_root and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
136 append_when_current_valid(current, menu, (_("remove new found flag"), self.removeNewFoundFlag), level = 0)
137 if isPlayable and SystemInfo.get("NumVideoDecoders", 1) > 1:
138 append_when_current_valid(current, menu, (_("Activate Picture in Picture"), self.showServiceInPiP), level = 0, key = "blue")
139 self.pipAvailable = True
141 menu.append(ChoiceEntryComponent(text = (_("add bouquet"), self.showBouquetInputBox)))
142 append_when_current_valid(current, menu, (_("remove entry"), self.removeBouquet), level = 0)
144 if inBouquet: # current list is editable?
145 if csel.bouquet_mark_edit == OFF:
146 if not csel.movemode:
147 append_when_current_valid(current, menu, (_("enable move mode"), self.toggleMoveMode), level = 1)
148 if not inBouquetRootList and current_root and not (current_root.flags & eServiceReference.isGroup):
149 menu.append(ChoiceEntryComponent(text = (_("add marker"), self.showMarkerInputBox)))
151 append_when_current_valid(current, menu, (_("enable bouquet edit"), self.bouquetMarkStart), level = 0)
153 append_when_current_valid(current, menu, (_("enable favourite edit"), self.bouquetMarkStart), level = 0)
154 if current_sel_flags & eServiceReference.isGroup:
155 append_when_current_valid(current, menu, (_("edit alternatives"), self.editAlternativeServices), level = 2)
156 append_when_current_valid(current, menu, (_("show alternatives"), self.showAlternativeServices), level = 2)
157 append_when_current_valid(current, menu, (_("remove all alternatives"), self.removeAlternativeServices), level = 2)
158 elif not current_sel_flags & eServiceReference.isMarker:
159 append_when_current_valid(current, menu, (_("add alternatives"), self.addAlternativeServices), level = 2)
161 append_when_current_valid(current, menu, (_("disable move mode"), self.toggleMoveMode), level = 0)
163 if csel.bouquet_mark_edit == EDIT_BOUQUET:
165 append_when_current_valid(current, menu, (_("end bouquet edit"), self.bouquetMarkEnd), level = 0)
166 append_when_current_valid(current, menu, (_("abort bouquet edit"), self.bouquetMarkAbort), level = 0)
168 append_when_current_valid(current, menu, (_("end favourites edit"), self.bouquetMarkEnd), level = 0)
169 append_when_current_valid(current, menu, (_("abort favourites edit"), self.bouquetMarkAbort), level = 0)
171 append_when_current_valid(current, menu, (_("end alternatives edit"), self.bouquetMarkEnd), level = 0)
172 append_when_current_valid(current, menu, (_("abort alternatives edit"), self.bouquetMarkAbort), level = 0)
174 menu.append(ChoiceEntryComponent(text = (_("back"), self.cancelClick)))
175 self["menu"] = ChoiceList(menu)
177 def okbuttonClick(self):
178 self["menu"].getCurrent()[0][1]()
180 def cancelClick(self):
183 def showServiceInformations(self):
184 self.session.open( ServiceInfo, self.csel.getCurrentSelection() )
186 def showBouquetInputBox(self):
187 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)
189 def bouquetInputCallback(self, bouquet):
190 if bouquet is not None:
191 self.csel.addBouquet(bouquet, None)
194 def addParentalProtection(self, service):
195 from Components.ParentalControl import parentalControl
196 parentalControl.protectService(service.toCompareString())
199 def removeParentalProtection(self, service):
200 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"))
202 def pinEntered(self, service, result):
204 from Components.ParentalControl import parentalControl
205 parentalControl.unProtectService(service)
208 self.session.openWithCallback(self.close, MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR)
210 def showServiceInPiP(self):
211 if not self.pipAvailable:
213 if self.session.pipshown:
215 self.session.pip = self.session.instantiateDialog(PictureInPicture)
216 self.session.pip.show()
217 newservice = self.csel.servicelist.getCurrent()
218 if self.session.pip.playService(newservice):
219 self.session.pipshown = True
220 self.session.pip.servicePath = self.csel.getCurrentServicePath()
223 self.session.pipshown = False
225 self.session.openWithCallback(self.close, MessageBox, _("Could not open Picture in Picture"), MessageBox.TYPE_ERROR)
227 def addServiceToBouquetSelected(self):
228 bouquets = self.csel.getBouquetList()
233 if cnt > 1: # show bouquet list
234 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
235 elif cnt == 1: # add to only one existing bouquet
236 self.addCurrentServiceToBouquet(bouquets[0][1], closeBouquetSelection = False)
238 def bouquetSelClosed(self, recursive):
243 def removeSatelliteServices(self):
244 curpath = self.csel.getCurrentSelection().getPath()
245 idx = curpath.find("satellitePosition == ")
247 tmp = curpath[idx+21:]
250 satpos = int(tmp[:idx])
251 eDVBDB.getInstance().removeServices(-1, -1, -1, satpos)
254 def copyCurrentToBouquetList(self):
255 self.csel.copyCurrentToBouquetList()
258 def removeBouquet(self):
259 self.csel.removeBouquet()
262 def showMarkerInputBox(self):
263 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)
265 def markerInputCallback(self, marker):
266 if marker is not None:
267 self.csel.addMarker(marker)
270 def addCurrentServiceToBouquet(self, dest, closeBouquetSelection = True):
271 self.csel.addServiceToBouquet(dest)
272 if self.bsel is not None:
273 self.bsel.close(True)
275 self.close(closeBouquetSelection) # close bouquet selection
277 def removeCurrentService(self):
278 self.csel.removeCurrentService()
281 def toggleMoveMode(self):
282 self.csel.toggleMoveMode()
285 def bouquetMarkStart(self):
286 self.csel.startMarkedEdit(EDIT_BOUQUET)
289 def bouquetMarkEnd(self):
290 self.csel.endMarkedEdit(abort=False)
293 def bouquetMarkAbort(self):
294 self.csel.endMarkedEdit(abort=True)
297 def removeNewFoundFlag(self):
298 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
301 def removeAllNewFoundFlags(self):
302 curpath = self.csel.getCurrentSelection().getPath()
303 idx = curpath.find("satellitePosition == ")
305 tmp = curpath[idx+21:]
308 satpos = int(tmp[:idx])
309 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
312 def editAlternativeServices(self):
313 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
316 def showAlternativeServices(self):
317 self.csel.enterPath(self.csel.getCurrentSelection())
320 def removeAlternativeServices(self):
321 self.csel.removeAlternativeServices()
324 def addAlternativeServices(self):
325 self.csel.addAlternativeServices()
326 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
329 class SelectionEventInfo:
331 self["ServiceEvent"] = ServiceEvent()
332 self.servicelist.connectSelChanged(self.__selectionChanged)
333 self.timer = eTimer()
334 self.timer.callback.append(self.updateEventInfo)
335 self.onShown.append(self.__selectionChanged)
337 def __selectionChanged(self):
339 self.timer.start(100, True)
341 def updateEventInfo(self):
342 cur = self.getCurrentSelection()
343 self["ServiceEvent"].newService(cur)
345 class ChannelSelectionEPG:
347 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
349 "showEPGList": self.showEPGList,
352 def showEPGList(self):
353 ref=self.getCurrentSelection()
355 self.savedService = ref
356 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB=self.changeServiceCB)
358 def SingleServiceEPGClosed(self, ret=False):
359 self.setCurrentSelection(self.savedService)
361 def changeServiceCB(self, direction, epg):
362 beg = self.getCurrentSelection()
368 cur = self.getCurrentSelection()
369 if cur == beg or not (cur.flags & eServiceReference.isMarker):
371 epg.setService(ServiceReference(self.getCurrentSelection()))
373 class ChannelSelectionEdit:
375 self.entry_marked = False
376 self.movemode = False
377 self.bouquet_mark_edit = OFF
378 self.mutableList = None
380 self.saved_title = None
381 self.saved_root = None
383 class ChannelSelectionEditActionMap(ActionMap):
384 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
385 ActionMap.__init__(self, contexts, actions, prio)
388 def action(self, contexts, action):
389 if action == "cancel":
390 self.csel.handleEditCancel()
391 return 0 # fall-trough
393 return 0 # fall-trough
395 return ActionMap.action(self, contexts, action)
397 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
399 "contextMenu": self.doContext,
402 def getMutableList(self, root=eServiceReference()):
403 if not self.mutableList is None:
404 return self.mutableList
405 serviceHandler = eServiceCenter.getInstance()
408 list = root and serviceHandler.list(root)
410 return list.startEdit()
413 def buildBouquetID(self, str):
417 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
423 def addMarker(self, name):
424 current = self.servicelist.getCurrent()
425 mutableList = self.getMutableList()
428 str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
429 ref = eServiceReference(str)
430 if current and current.valid():
431 if not mutableList.addService(ref, current):
432 self.servicelist.addService(ref, True)
433 mutableList.flushChanges()
435 elif not mutableList.addService(ref):
436 self.servicelist.addService(ref, True)
437 mutableList.flushChanges()
441 def addAlternativeServices(self):
442 cur_service = ServiceReference(self.getCurrentSelection())
443 root = self.getRoot()
444 cur_root = root and ServiceReference(root)
445 mutableBouquet = cur_root.list().startEdit()
447 name = cur_service.getServiceName()
449 if self.mode == MODE_TV:
450 str = '1:134:1:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(name))
452 str = '1:134:2:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(name))
453 new_ref = ServiceReference(str)
454 if not mutableBouquet.addService(new_ref.ref, cur_service.ref):
455 mutableBouquet.removeService(cur_service.ref)
456 mutableBouquet.flushChanges()
457 eDVBDB.getInstance().reloadBouquets()
458 mutableAlternatives = new_ref.list().startEdit()
459 if mutableAlternatives:
460 mutableAlternatives.setListName(name)
461 if mutableAlternatives.addService(cur_service.ref):
462 print "add", cur_service.ref.toString(), "to new alternatives failed"
463 mutableAlternatives.flushChanges()
464 self.servicelist.addService(new_ref.ref, True)
465 self.servicelist.removeCurrent()
466 self.servicelist.moveUp()
468 print "get mutable list for new created alternatives failed"
470 print "add", str, "to", cur_root.getServiceName(), "failed"
472 print "bouquetlist is not editable"
474 def addBouquet(self, bName, services):
475 serviceHandler = eServiceCenter.getInstance()
476 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
477 if mutableBouquetList:
478 if self.mode == MODE_TV:
480 str = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
483 str = '1:7:2:0:0:0:0:0:0:0:FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
484 new_bouquet_ref = eServiceReference(str)
485 if not mutableBouquetList.addService(new_bouquet_ref):
486 mutableBouquetList.flushChanges()
487 eDVBDB.getInstance().reloadBouquets()
488 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
490 mutableBouquet.setListName(bName)
491 if services is not None:
492 for service in services:
493 if mutableBouquet.addService(service):
494 print "add", service.toString(), "to new bouquet failed"
495 mutableBouquet.flushChanges()
497 print "get mutable list for new created bouquet failed"
498 # do some voodoo to check if current_root is equal to bouquet_root
499 cur_root = self.getRoot();
500 str1 = cur_root and cur_root.toString()
501 pos1 = str1 and str1.find("FROM BOUQUET") or -1
502 pos2 = self.bouquet_rootstr.find("FROM BOUQUET")
503 if pos1 != -1 and pos2 != -1 and str1[pos1:] == self.bouquet_rootstr[pos2:]:
504 self.servicelist.addService(new_bouquet_ref)
506 print "add", str, "to bouquets failed"
508 print "bouquetlist is not editable"
510 def copyCurrentToBouquetList(self):
511 provider = ServiceReference(self.getCurrentSelection())
512 providerName = provider.getServiceName()
513 serviceHandler = eServiceCenter.getInstance()
514 services = serviceHandler.list(provider.ref)
515 self.addBouquet(providerName, services and services.getContent('R', True))
517 def removeAlternativeServices(self):
518 cur_service = ServiceReference(self.getCurrentSelection())
519 root = self.getRoot()
520 cur_root = root and ServiceReference(root)
521 list = cur_service.list()
522 first_in_alternative = list and list.getNext()
523 if first_in_alternative:
524 edit_root = cur_root and cur_root.list().startEdit()
526 if not edit_root.addService(first_in_alternative, cur_service.ref):
527 self.servicelist.addService(first_in_alternative, True)
529 print "couldn't add first alternative service to current root"
531 print "couldn't edit current root!!"
533 print "remove empty alternative list !!"
535 self.servicelist.moveUp()
537 def removeBouquet(self):
538 refstr = self.getCurrentSelection().toString()
539 print "removeBouquet", refstr
540 self.bouquetNumOffsetCache = { }
541 pos = refstr.find('FROM BOUQUET "')
544 refstr = refstr[pos+14:]
545 pos = refstr.find('"')
547 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
548 self.removeCurrentService()
550 if filename is not None:
553 print "error during remove of", filename
555 # multiple marked entry stuff ( edit mode, later multiepg selection )
556 def startMarkedEdit(self, type):
557 self.savedPath = self.servicePath[:]
558 if type == EDIT_ALTERNATIVES:
559 self.enterPath(self.getCurrentSelection())
560 self.mutableList = self.getMutableList()
561 # add all services from the current list to internal marked set in listboxservicecontent
562 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
563 self.saved_title = self.getTitle()
564 pos = self.saved_title.find(')')
565 new_title = self.saved_title[:pos+1]
566 if type == EDIT_ALTERNATIVES:
567 self.bouquet_mark_edit = EDIT_ALTERNATIVES
568 new_title += ' ' + _("[alternative edit]")
570 self.bouquet_mark_edit = EDIT_BOUQUET
571 if config.usage.multibouquet.value:
572 new_title += ' ' + _("[bouquet edit]")
574 new_title += ' ' + _("[favourite edit]")
575 self.setTitle(new_title)
576 self.__marked = self.servicelist.getRootServices()
577 for x in self.__marked:
578 self.servicelist.addMarked(eServiceReference(x))
579 self.showAllServices()
581 def endMarkedEdit(self, abort):
582 if not abort and self.mutableList is not None:
583 self.bouquetNumOffsetCache = { }
584 new_marked = set(self.servicelist.getMarked())
585 old_marked = set(self.__marked)
586 removed = old_marked - new_marked
587 added = new_marked - old_marked
591 self.mutableList.removeService(eServiceReference(x))
594 self.mutableList.addService(eServiceReference(x))
596 self.mutableList.flushChanges()
599 self.bouquet_mark_edit = OFF
600 self.mutableList = None
601 self.setTitle(self.saved_title)
602 self.saved_title = None
603 # self.servicePath is just a reference to servicePathTv or Radio...
604 # so we never ever do use the asignment operator in self.servicePath
605 del self.servicePath[:] # remove all elements
606 self.servicePath += self.savedPath # add saved elements
608 self.setRoot(self.servicePath[-1])
610 def clearMarks(self):
611 self.servicelist.clearMarks()
614 ref = self.servicelist.getCurrent()
615 if self.servicelist.isMarked(ref):
616 self.servicelist.removeMarked(ref)
618 self.servicelist.addMarked(ref)
620 def removeCurrentService(self):
621 ref = self.servicelist.getCurrent()
622 mutableList = self.getMutableList()
623 if ref.valid() and mutableList is not None:
624 if not mutableList.removeService(ref):
625 self.bouquetNumOffsetCache = { }
626 mutableList.flushChanges() #FIXME dont flush on each single removed service
627 self.servicelist.removeCurrent()
629 def addServiceToBouquet(self, dest, service=None):
630 mutableList = self.getMutableList(dest)
631 if not mutableList is None:
632 if service is None: #use current selected service
633 service = self.servicelist.getCurrent()
634 if not mutableList.addService(service):
635 self.bouquetNumOffsetCache = { }
636 mutableList.flushChanges()
637 # do some voodoo to check if current_root is equal to dest
638 cur_root = self.getRoot();
639 str1 = cur_root and cur_root.toString() or -1
640 str2 = dest.toString()
641 pos1 = str1.find("FROM BOUQUET")
642 pos2 = str2.find("FROM BOUQUET")
643 if pos1 != -1 and pos2 != -1 and str1[pos1:] == str2[pos2:]:
644 self.servicelist.addService(service)
646 def toggleMoveMode(self):
648 if self.entry_marked:
649 self.toggleMoveMarked() # unmark current entry
650 self.movemode = False
651 self.pathChangeDisabled = False # re-enable path change
652 self.mutableList.flushChanges() # FIXME add check if changes was made
653 self.mutableList = None
654 self.setTitle(self.saved_title)
655 self.saved_title = None
656 cur_root = self.getRoot()
657 if cur_root and cur_root == self.bouquet_root:
658 self.bouquetNumOffsetCache = { }
660 self.mutableList = self.getMutableList()
662 self.pathChangeDisabled = True # no path change allowed in movemode
663 self.saved_title = self.getTitle()
664 new_title = self.saved_title
665 pos = self.saved_title.find(')')
666 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
667 self.setTitle(new_title);
669 def handleEditCancel(self):
670 if self.movemode: #movemode active?
671 self.channelSelected() # unmark
672 self.toggleMoveMode() # disable move mode
673 elif self.bouquet_mark_edit != OFF:
674 self.endMarkedEdit(True) # abort edit mode
676 def toggleMoveMarked(self):
677 if self.entry_marked:
678 self.servicelist.setCurrentMarked(False)
679 self.entry_marked = False
681 self.servicelist.setCurrentMarked(True)
682 self.entry_marked = True
685 self.session.openWithCallback(self.exitContext, ChannelContextMenu, self)
687 def exitContext(self, close = False):
694 # type 1 = digital television service
695 # type 4 = nvod reference service (NYI)
696 # type 17 = MPEG-2 HD digital television service
697 # type 22 = advanced codec SD digital television
698 # type 24 = advanced codec SD NVOD reference service (NYI)
699 # type 25 = advanced codec HD digital television
700 # type 27 = advanced codec HD NVOD reference service (NYI)
701 # type 2 = digital radio sound service
702 # type 10 = advanced codec digital radio sound service
704 service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 22) || (type == 25) || (type == 134) || (type == 195)'
705 service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2) || (type == 10)'
707 class ChannelSelectionBase(Screen):
708 def __init__(self, session):
709 Screen.__init__(self, session)
711 self["key_red"] = Button(_("All"))
712 self["key_green"] = Button(_("Satellites"))
713 self["key_yellow"] = Button(_("Provider"))
714 self["key_blue"] = Button(_("Favourites"))
716 self["list"] = ServiceList()
717 self.servicelist = self["list"]
719 self.numericalTextInput = NumericalTextInput()
720 self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
722 self.servicePathTV = [ ]
723 self.servicePathRadio = [ ]
724 self.servicePath = [ ]
725 self.rootChanged = False
729 self.pathChangeDisabled = False
731 self.bouquetNumOffsetCache = { }
733 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions", "InputAsciiActions"],
735 "showFavourites": self.showFavourites,
736 "showAllServices": self.showAllServices,
737 "showProviders": self.showProviders,
738 "showSatellites": self.showSatellites,
739 "nextBouquet": self.nextBouquet,
740 "prevBouquet": self.prevBouquet,
741 "nextMarker": self.nextMarker,
742 "prevMarker": self.prevMarker,
743 "gotAsciiCode": self.keyAsciiCode,
744 "1": self.keyNumberGlobal,
745 "2": self.keyNumberGlobal,
746 "3": self.keyNumberGlobal,
747 "4": self.keyNumberGlobal,
748 "5": self.keyNumberGlobal,
749 "6": self.keyNumberGlobal,
750 "7": self.keyNumberGlobal,
751 "8": self.keyNumberGlobal,
752 "9": self.keyNumberGlobal,
755 self.recallBouquetMode()
757 def getBouquetNumOffset(self, bouquet):
758 if not config.usage.multibouquet.value:
760 str = bouquet.toString()
762 if not self.bouquetNumOffsetCache.has_key(str):
763 serviceHandler = eServiceCenter.getInstance()
764 bouquetlist = serviceHandler.list(self.bouquet_root)
765 if not bouquetlist is None:
767 bouquetIterator = bouquetlist.getNext()
768 if not bouquetIterator.valid(): #end of list
770 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
771 if not (bouquetIterator.flags & eServiceReference.isDirectory):
773 servicelist = serviceHandler.list(bouquetIterator)
774 if not servicelist is None:
776 serviceIterator = servicelist.getNext()
777 if not serviceIterator.valid(): #check if end of list
779 playable = not (serviceIterator.flags & (eServiceReference.isDirectory|eServiceReference.isMarker))
782 return self.bouquetNumOffsetCache.get(str, offsetCount)
784 def recallBouquetMode(self):
785 if self.mode == MODE_TV:
786 self.service_types = service_types_tv
787 if config.usage.multibouquet.value:
788 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
790 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
792 self.service_types = service_types_radio
793 if config.usage.multibouquet.value:
794 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
796 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
797 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
801 self.servicePath = self.servicePathTV
802 self.recallBouquetMode()
803 title = self.getTitle()
804 pos = title.find(" (")
810 def setRadioMode(self):
811 self.mode = MODE_RADIO
812 self.servicePath = self.servicePathRadio
813 self.recallBouquetMode()
814 title = self.getTitle()
815 pos = title.find(" (")
821 def setRoot(self, root, justSet=False):
822 path = root.getPath()
823 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
824 pos = path.find('FROM BOUQUET')
825 isBouquet = (pos != -1) and (root.flags & eServiceReference.isDirectory)
826 if not inBouquetRootList and isBouquet:
827 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
828 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
830 self.servicelist.setMode(ServiceList.MODE_NORMAL)
831 self.servicelist.setRoot(root, justSet)
832 self.rootChanged = True
833 self.buildTitleString()
835 def removeModeStr(self, str):
836 if self.mode == MODE_TV:
837 pos = str.find(' (TV)')
839 pos = str.find(' (Radio)')
844 def getServiceName(self, ref):
845 str = self.removeModeStr(ServiceReference(ref).getServiceName())
847 pathstr = ref.getPath()
848 if 'FROM PROVIDERS' in pathstr:
850 if 'FROM SATELLITES' in pathstr:
851 return _("Satellites")
852 if ') ORDER BY name' in pathstr:
856 def buildTitleString(self):
857 titleStr = self.getTitle()
858 pos = titleStr.find(']')
860 pos = titleStr.find(')')
862 titleStr = titleStr[:pos+1]
863 Len = len(self.servicePath)
865 base_ref = self.servicePath[0]
867 end_ref = self.servicePath[Len-1]
870 nameStr = self.getServiceName(base_ref)
871 titleStr += ' ' + nameStr
872 if end_ref is not None:
877 nameStr = self.getServiceName(end_ref)
879 self.setTitle(titleStr)
882 self.servicelist.moveUp()
885 self.servicelist.moveDown()
888 del self.servicePath[:]
890 def enterPath(self, ref, justSet=False):
891 self.servicePath.append(ref)
892 self.setRoot(ref, justSet)
894 def pathUp(self, justSet=False):
895 prev = self.servicePath.pop()
897 current = self.servicePath[-1]
898 self.setRoot(current, justSet)
900 self.setCurrentSelection(prev)
903 def isBasePathEqual(self, ref):
904 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
908 def isPrevPathEqual(self, ref):
909 length = len(self.servicePath)
910 if length > 1 and self.servicePath[length-2] == ref:
914 def preEnterPath(self, refstr):
917 def showAllServices(self):
918 if not self.pathChangeDisabled:
919 refstr = '%s ORDER BY name'%(self.service_types)
920 if not self.preEnterPath(refstr):
921 ref = eServiceReference(refstr)
922 currentRoot = self.getRoot()
923 if currentRoot is None or currentRoot != ref:
927 def showSatellites(self):
928 if not self.pathChangeDisabled:
929 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
930 if not self.preEnterPath(refstr):
931 ref = eServiceReference(refstr)
935 if self.isBasePathEqual(ref):
936 if self.isPrevPathEqual(ref):
938 prev = self.pathUp(justSet)
940 currentRoot = self.getRoot()
941 if currentRoot is None or currentRoot != ref:
944 self.enterPath(ref, True)
946 serviceHandler = eServiceCenter.getInstance()
947 servicelist = serviceHandler.list(ref)
948 if not servicelist is None:
950 service = servicelist.getNext()
951 if not service.valid(): #check if end of list
953 unsigned_orbpos = service.getUnsignedData(4) >> 16
954 orbpos = service.getData(4) >> 16
957 if service.getPath().find("FROM PROVIDER") != -1:
958 service_type = _("Providers")
959 elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
960 service_type = _("New")
962 service_type = _("Services")
964 # why we need this cast?
965 service_name = str(nimmanager.getSatDescription(orbpos))
967 if unsigned_orbpos == 0xFFFF: #Cable
968 service_name = _("Cable")
969 elif unsigned_orbpos == 0xEEEE: #Terrestrial
970 service_name = _("Terrestrial")
972 if orbpos > 1800: # west
973 orbpos = 3600 - orbpos
977 service_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
978 service.setName("%s - %s" % (service_name, service_type))
979 self.servicelist.addService(service)
980 cur_ref = self.session.nav.getCurrentlyPlayingServiceReference()
982 pos = self.service_types.rfind(':')
983 refstr = '%s (channelID == %08x%04x%04x) && %s ORDER BY name' %(self.service_types[:pos+1],
984 cur_ref.getUnsignedData(4), # NAMESPACE
985 cur_ref.getUnsignedData(2), # TSID
986 cur_ref.getUnsignedData(3), # ONID
987 self.service_types[pos+1:])
988 ref = eServiceReference(refstr)
989 ref.setName(_("Current Transponder"))
990 self.servicelist.addService(ref)
991 self.servicelist.finishFill()
993 self.setCurrentSelection(prev)
995 def showProviders(self):
996 if not self.pathChangeDisabled:
997 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
998 if not self.preEnterPath(refstr):
999 ref = eServiceReference(refstr)
1000 if self.isBasePathEqual(ref):
1003 currentRoot = self.getRoot()
1004 if currentRoot is None or currentRoot != ref:
1008 def changeBouquet(self, direction):
1009 if not self.pathChangeDisabled:
1010 if len(self.servicePath) > 1:
1011 #when enter satellite root list we must do some magic stuff..
1012 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
1013 if self.isBasePathEqual(ref):
1014 self.showSatellites()
1021 ref = self.getCurrentSelection()
1024 def inBouquet(self):
1025 if self.servicePath and self.servicePath[0] == self.bouquet_root:
1030 return self.servicelist.atBegin()
1033 return self.servicelist.atEnd()
1035 def nextBouquet(self):
1036 self.changeBouquet(+1)
1038 def prevBouquet(self):
1039 self.changeBouquet(-1)
1041 def showFavourites(self):
1042 if not self.pathChangeDisabled:
1043 if not self.preEnterPath(self.bouquet_rootstr):
1044 if self.isBasePathEqual(self.bouquet_root):
1047 currentRoot = self.getRoot()
1048 if currentRoot is None or currentRoot != self.bouquet_root:
1050 self.enterPath(self.bouquet_root)
1052 def keyNumberGlobal(self, number):
1053 unichar = self.numericalTextInput.getKey(number)
1054 charstr = unichar.encode("utf-8")
1055 if len(charstr) == 1:
1056 self.servicelist.moveToChar(charstr[0])
1058 def keyAsciiCode(self):
1059 unichar = unichr(getPrevAsciiCode())
1060 charstr = unichar.encode("utf-8")
1061 if len(charstr) == 1:
1062 self.servicelist.moveToChar(charstr[0])
1065 return self.servicelist.getRoot()
1067 def getCurrentSelection(self):
1068 return self.servicelist.getCurrent()
1070 def setCurrentSelection(self, service):
1071 self.servicelist.setCurrent(service)
1073 def getBouquetList(self):
1075 serviceHandler = eServiceCenter.getInstance()
1076 if config.usage.multibouquet.value:
1077 list = serviceHandler.list(self.bouquet_root)
1083 if s.flags & eServiceReference.isDirectory:
1084 info = serviceHandler.info(s)
1086 bouquets.append((info.getName(s), s))
1089 info = serviceHandler.info(self.bouquet_root)
1091 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
1095 def keyNumber0(self, num):
1096 if len(self.servicePath) > 1:
1099 self.keyNumberGlobal(num)
1102 if len(self.servicePath) > 1:
1103 if self.isBasePathEqual(self.bouquet_root):
1104 self.showFavourites()
1106 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
1107 if self.isBasePathEqual(ref):
1108 self.showSatellites()
1110 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
1111 if self.isBasePathEqual(ref):
1112 self.showProviders()
1114 self.showAllServices()
1116 def nextMarker(self):
1117 self.servicelist.moveToNextMarker()
1119 def prevMarker(self):
1120 self.servicelist.moveToPrevMarker()
1124 #config for lastservice
1125 config.tv = ConfigSubsection()
1126 config.tv.lastservice = ConfigText()
1127 config.tv.lastroot = ConfigText()
1128 config.radio = ConfigSubsection()
1129 config.radio.lastservice = ConfigText()
1130 config.radio.lastroot = ConfigText()
1131 config.servicelist = ConfigSubsection()
1132 config.servicelist.lastmode = ConfigText(default = "tv")
1134 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, SelectionEventInfo):
1135 def __init__(self, session):
1136 ChannelSelectionBase.__init__(self,session)
1137 ChannelSelectionEdit.__init__(self)
1138 ChannelSelectionEPG.__init__(self)
1139 SelectionEventInfo.__init__(self)
1141 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1143 "cancel": self.cancel,
1144 "ok": self.channelSelected,
1145 "keyRadio": self.setModeRadio,
1146 "keyTV": self.setModeTv,
1149 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1151 iPlayableService.evStart: self.__evServiceStart,
1152 iPlayableService.evEnd: self.__evServiceEnd
1155 self.lastChannelRootTimer = eTimer()
1156 self.lastChannelRootTimer.callback.append(self.__onCreate)
1157 self.lastChannelRootTimer.start(100,True)
1159 self.history_tv = [ ]
1160 self.history_radio = [ ]
1161 self.history = self.history_tv
1162 self.history_pos = 0
1164 self.lastservice = config.tv.lastservice
1165 self.lastroot = config.tv.lastroot
1166 self.revertMode = None
1167 config.usage.multibouquet.addNotifier(self.multibouquet_config_changed)
1168 self.new_service_played = False
1169 self.onExecBegin.append(self.asciiOn)
1172 rcinput = eRCInput.getInstance()
1173 rcinput.setKeyboardMode(rcinput.kmAscii)
1176 rcinput = eRCInput.getInstance()
1177 rcinput.setKeyboardMode(rcinput.kmNone)
1179 def multibouquet_config_changed(self, val):
1180 self.recallBouquetMode()
1182 def __evServiceStart(self):
1183 service = self.session.nav.getCurrentService()
1185 info = service.info()
1187 refstr = info.getInfoString(iServiceInformation.sServiceref)
1188 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1190 def __evServiceEnd(self):
1191 self.servicelist.setPlayableIgnoreService(eServiceReference())
1194 self.rootChanged = True
1196 lastservice=eServiceReference(self.lastservice.value)
1197 if lastservice.valid():
1198 self.setCurrentSelection(lastservice)
1200 def setModeTv(self):
1201 if self.revertMode is None and config.servicelist.lastmode.value == "radio":
1202 self.revertMode = MODE_RADIO
1203 self.history = self.history_tv
1204 self.lastservice = config.tv.lastservice
1205 self.lastroot = config.tv.lastroot
1206 config.servicelist.lastmode.value = "tv"
1210 def setModeRadio(self):
1211 if self.revertMode is None and config.servicelist.lastmode.value == "tv":
1212 self.revertMode = MODE_TV
1213 if config.usage.e1like_radio_mode.value:
1214 self.history = self.history_radio
1215 self.lastservice = config.radio.lastservice
1216 self.lastroot = config.radio.lastroot
1217 config.servicelist.lastmode.value = "radio"
1221 def __onCreate(self):
1222 if config.usage.e1like_radio_mode.value:
1223 if config.servicelist.lastmode.value == "tv":
1229 lastservice=eServiceReference(self.lastservice.value)
1230 if lastservice.valid():
1233 def channelSelected(self):
1234 ref = self.getCurrentSelection()
1236 self.toggleMoveMarked()
1237 elif (ref.flags & 7) == 7:
1239 elif self.bouquet_mark_edit != OFF:
1240 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1242 elif not (ref.flags & eServiceReference.isMarker): # no marker
1243 root = self.getRoot()
1244 if not root or not (root.flags & eServiceReference.isGroup):
1249 #called from infoBar and channelSelected
1251 self.revertMode=None
1252 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1253 nref = self.getCurrentSelection()
1254 if ref is None or ref != nref:
1255 self.new_service_played = True
1256 self.session.nav.playService(nref)
1258 self.saveChannel(nref)
1259 config.servicelist.lastmode.save()
1260 self.addToHistory(nref)
1262 def newServicePlayed(self):
1263 ret = self.new_service_played
1264 self.new_service_played = False
1267 def addToHistory(self, ref):
1268 if self.servicePath is not None:
1269 tmp=self.servicePath[:]
1272 del self.history[self.history_pos+1:]
1275 self.history.append(tmp)
1276 hlen = len(self.history)
1277 if hlen > HISTORYSIZE:
1280 self.history_pos = hlen-1
1282 def historyBack(self):
1283 hlen = len(self.history)
1284 if hlen > 1 and self.history_pos > 0:
1285 self.history_pos -= 1
1286 self.setHistoryPath()
1288 def historyNext(self):
1289 hlen = len(self.history)
1290 if hlen > 1 and self.history_pos < (hlen-1):
1291 self.history_pos += 1
1292 self.setHistoryPath()
1294 def setHistoryPath(self):
1295 path = self.history[self.history_pos][:]
1297 del self.servicePath[:]
1298 self.servicePath += path
1301 cur_root = self.getRoot()
1302 if cur_root and cur_root != root:
1304 self.session.nav.playService(ref)
1305 self.setCurrentSelection(ref)
1306 self.saveChannel(ref)
1310 for i in self.servicePath:
1311 path += i.toString()
1313 if path and path != self.lastroot.value:
1314 self.lastroot.value = path
1315 self.lastroot.save()
1317 def restoreRoot(self):
1318 tmp = [x for x in self.lastroot.value.split(';') if x != '']
1319 current = [x.toString() for x in self.servicePath]
1320 if tmp != current or self.rootChanged:
1324 self.servicePath.append(eServiceReference(i))
1327 path = self.servicePath.pop()
1328 self.enterPath(path)
1330 self.showFavourites()
1332 self.rootChanged = False
1334 def preEnterPath(self, refstr):
1335 if self.servicePath and self.servicePath[0] != eServiceReference(refstr):
1336 pathstr = self.lastroot.value
1337 if pathstr is not None and pathstr.find(refstr) == 0:
1339 lastservice=eServiceReference(self.lastservice.value)
1340 if lastservice.valid():
1341 self.setCurrentSelection(lastservice)
1345 def saveChannel(self, ref):
1347 refstr = ref.toString()
1350 if refstr != self.lastservice.value:
1351 self.lastservice.value = refstr
1352 self.lastservice.save()
1354 def setCurrentServicePath(self, path):
1356 self.history[self.history_pos] = path
1358 self.history.append(path)
1359 self.setHistoryPath()
1361 def getCurrentServicePath(self):
1363 return self.history[self.history_pos]
1366 def recallPrevService(self):
1367 hlen = len(self.history)
1369 if self.history_pos == hlen-1:
1370 tmp = self.history[self.history_pos]
1371 self.history[self.history_pos] = self.history[self.history_pos-1]
1372 self.history[self.history_pos-1] = tmp
1374 tmp = self.history[self.history_pos+1]
1375 self.history[self.history_pos+1] = self.history[self.history_pos]
1376 self.history[self.history_pos] = tmp
1377 self.setHistoryPath()
1380 if self.revertMode is None:
1382 lastservice=eServiceReference(self.lastservice.value)
1383 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1384 self.setCurrentSelection(lastservice)
1385 elif self.revertMode == MODE_TV:
1387 elif self.revertMode == MODE_RADIO:
1389 self.revertMode = None
1393 class RadioInfoBar(Screen):
1394 def __init__(self, session):
1395 Screen.__init__(self, session)
1396 self["RdsDecoder"] = RdsDecoder(self.session.nav)
1398 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, InfoBarBase):
1399 ALLOW_SUSPEND = True
1401 def __init__(self, session, infobar):
1402 ChannelSelectionBase.__init__(self, session)
1403 ChannelSelectionEdit.__init__(self)
1404 ChannelSelectionEPG.__init__(self)
1405 InfoBarBase.__init__(self)
1406 self.infobar = infobar
1407 self.onLayoutFinish.append(self.onCreate)
1409 self.info = session.instantiateDialog(RadioInfoBar) # our simple infobar
1411 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1413 "keyTV": self.cancel,
1414 "keyRadio": self.cancel,
1415 "cancel": self.cancel,
1416 "ok": self.channelSelected,
1419 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1421 iPlayableService.evStart: self.__evServiceStart,
1422 iPlayableService.evEnd: self.__evServiceEnd
1425 ########## RDS Radiotext / Rass Support BEGIN
1426 self.infobar = infobar # reference to real infobar (the one and only)
1427 self["RdsDecoder"] = self.info["RdsDecoder"]
1428 self["RdsActions"] = HelpableActionMap(self, "InfobarRdsActions",
1430 "startRassInteractive": (self.startRassInteractive, _("View Rass interactive..."))
1432 self["RdsActions"].setEnabled(False)
1433 infobar.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
1434 self.onClose.append(self.__onClose)
1436 def __onClose(self):
1437 lastservice=eServiceReference(config.tv.lastservice.value)
1438 self.session.nav.playService(lastservice)
1440 def startRassInteractive(self):
1442 self.infobar.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
1444 def RassInteractiveClosed(self):
1446 self.infobar.rass_interactive = None
1447 self.infobar.RassSlidePicChanged()
1449 def RassInteractivePossibilityChanged(self, state):
1450 self["RdsActions"].setEnabled(state)
1451 ########## RDS Radiotext / Rass Support END
1454 self.infobar.rds_display.onRassInteractivePossibilityChanged.remove(self.RassInteractivePossibilityChanged)
1456 #set previous tv service
1459 def __evServiceStart(self):
1460 service = self.session.nav.getCurrentService()
1462 info = service.info()
1464 refstr = info.getInfoString(iServiceInformation.sServiceref)
1465 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1467 def __evServiceEnd(self):
1468 self.servicelist.setPlayableIgnoreService(eServiceReference())
1472 for i in self.servicePathRadio:
1473 path += i.toString()
1475 if path and path != config.radio.lastroot.value:
1476 config.radio.lastroot.value = path
1477 config.radio.lastroot.save()
1479 def restoreRoot(self):
1480 tmp = [x for x in config.radio.lastroot.value.split(';') if x != '']
1481 current = [x.toString() for x in self.servicePath]
1482 if tmp != current or self.rootChanged:
1485 self.servicePathRadio.append(eServiceReference(i))
1488 path = self.servicePathRadio.pop()
1489 self.enterPath(path)
1491 self.showFavourites()
1493 self.rootChanged = False
1495 def preEnterPath(self, refstr):
1496 if self.servicePathRadio and self.servicePathRadio[0] != eServiceReference(refstr):
1497 pathstr = config.radio.lastroot.value
1498 if pathstr is not None and pathstr.find(refstr) == 0:
1500 lastservice=eServiceReference(config.radio.lastservice.value)
1501 if lastservice.valid():
1502 self.setCurrentSelection(lastservice)
1509 lastservice=eServiceReference(config.radio.lastservice.value)
1510 if lastservice.valid():
1511 self.servicelist.setCurrent(lastservice)
1512 self.session.nav.playService(lastservice)
1514 self.session.nav.stopService()
1517 def channelSelected(self): # just return selected service
1518 ref = self.getCurrentSelection()
1520 self.toggleMoveMarked()
1521 elif (ref.flags & 7) == 7:
1523 elif self.bouquet_mark_edit != OFF:
1524 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1526 elif not (ref.flags & eServiceReference.isMarker): # no marker
1527 cur_root = self.getRoot()
1528 if not cur_root or not (cur_root.flags & eServiceReference.isGroup):
1529 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1530 if playingref is None or playingref != ref:
1531 self.session.nav.playService(ref)
1532 config.radio.lastservice.value = ref.toString()
1533 config.radio.lastservice.save()
1536 class SimpleChannelSelection(ChannelSelectionBase):
1537 def __init__(self, session, title):
1538 ChannelSelectionBase.__init__(self, session)
1539 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1541 "cancel": self.close,
1542 "ok": self.channelSelected,
1543 "keyRadio": self.setModeRadio,
1544 "keyTV": self.setModeTv,
1547 self.onLayoutFinish.append(self.layoutFinished)
1549 def layoutFinished(self):
1552 def channelSelected(self): # just return selected service
1553 ref = self.getCurrentSelection()
1554 if (ref.flags & 7) == 7:
1556 elif not (ref.flags & eServiceReference.isMarker):
1557 ref = self.getCurrentSelection()
1560 def setModeTv(self):
1562 self.showFavourites()
1564 def setModeRadio(self):
1566 self.showFavourites()