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.ChoiceList import ChoiceList, ChoiceEntryComponent
25 from Components.SystemInfo import SystemInfo
26 from Screens.InputBox import InputBox, PinInput
27 from Screens.MessageBox import MessageBox
28 from Screens.ServiceInfo import ServiceInfo
29 profile("ChannelSelection.py 4")
30 from Screens.PictureInPicture import PictureInPicture
31 from Screens.RdsDisplay import RassInteractive
32 from ServiceReference import ServiceReference
33 from Tools.BoundFunction import boundFunction
35 profile("ChannelSelection.py after imports")
37 FLAG_SERVICE_NEW_FOUND = 64 #define in lib/dvb/idvb.h as dxNewFound = 64
39 class BouquetSelector(Screen):
40 def __init__(self, session, bouquets, selectedFunc, enableWrapAround=False):
41 Screen.__init__(self, session)
43 self.selectedFunc=selectedFunc
45 self["actions"] = ActionMap(["OkCancelActions"],
47 "ok": self.okbuttonClick,
48 "cancel": self.cancelClick
50 entrys = [ (x[0], x[1]) for x in bouquets ]
51 self["menu"] = MenuList(entrys, enableWrapAround)
54 cur = self["menu"].getCurrent()
57 def okbuttonClick(self):
58 self.selectedFunc(self.getCurrent())
66 def cancelClick(self):
69 # csel.bouquet_mark_edit values
74 def append_when_current_valid(current, menu, args, level = 0, key = ""):
75 if current and current.valid() and level <= config.usage.setup_level.index:
76 menu.append(ChoiceEntryComponent(key, args))
78 class ChannelContextMenu(Screen):
79 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 if parentalControl.getProtectionLevel(csel.getCurrentSelection().toCompareString()) == -1:
110 append_when_current_valid(current, menu, (_("add to parental protection"), boundFunction(self.addParentalProtection, csel.getCurrentSelection())), level = 0)
112 append_when_current_valid(current, menu, (_("remove from parental protection"), boundFunction(self.removeParentalProtection, csel.getCurrentSelection())), level = 0)
114 bouquets = self.csel.getBouquetList()
118 bouquetCnt = len(bouquets)
119 if not inBouquet or bouquetCnt > 1:
120 append_when_current_valid(current, menu, (_("add service to bouquet"), self.addServiceToBouquetSelected), level = 0)
123 append_when_current_valid(current, menu, (_("add service to favourites"), self.addServiceToBouquetSelected), level = 0)
125 if current_root.getPath().find('FROM SATELLITES') != -1:
126 append_when_current_valid(current, menu, (_("remove selected satellite"), self.removeSatelliteServices), level = 0)
128 if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
129 append_when_current_valid(current, menu, (_("copy to bouquets"), self.copyCurrentToBouquetList), level = 0)
130 if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
131 append_when_current_valid(current, menu, (_("remove all new found flags"), self.removeAllNewFoundFlags), level = 0)
133 append_when_current_valid(current, menu, (_("remove entry"), self.removeCurrentService), level = 0)
134 if current_root and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
135 append_when_current_valid(current, menu, (_("remove new found flag"), self.removeNewFoundFlag), level = 0)
136 if isPlayable and SystemInfo.get("NumVideoDecoders", 1) > 1:
137 append_when_current_valid(current, menu, (_("Activate Picture in Picture"), self.showServiceInPiP), level = 0, key = "blue")
138 self.pipAvailable = True
140 menu.append(ChoiceEntryComponent(text = (_("add bouquet"), self.showBouquetInputBox)))
141 append_when_current_valid(current, menu, (_("remove entry"), self.removeBouquet), level = 0)
143 if inBouquet: # current list is editable?
144 if csel.bouquet_mark_edit == OFF:
145 if not csel.movemode:
146 append_when_current_valid(current, menu, (_("enable move mode"), self.toggleMoveMode), level = 1)
147 if not inBouquetRootList and current_root and not (current_root.flags & eServiceReference.isGroup):
148 menu.append(ChoiceEntryComponent(text = (_("add marker"), self.showMarkerInputBox)))
150 append_when_current_valid(current, menu, (_("enable bouquet edit"), self.bouquetMarkStart), level = 0)
152 append_when_current_valid(current, menu, (_("enable favourite edit"), self.bouquetMarkStart), level = 0)
153 if current_sel_flags & eServiceReference.isGroup:
154 append_when_current_valid(current, menu, (_("edit alternatives"), self.editAlternativeServices), level = 2)
155 append_when_current_valid(current, menu, (_("show alternatives"), self.showAlternativeServices), level = 2)
156 append_when_current_valid(current, menu, (_("remove all alternatives"), self.removeAlternativeServices), level = 2)
157 elif not current_sel_flags & eServiceReference.isMarker:
158 append_when_current_valid(current, menu, (_("add alternatives"), self.addAlternativeServices), level = 2)
160 append_when_current_valid(current, menu, (_("disable move mode"), self.toggleMoveMode), level = 0)
162 if csel.bouquet_mark_edit == EDIT_BOUQUET:
164 append_when_current_valid(current, menu, (_("end bouquet edit"), self.bouquetMarkEnd), level = 0)
165 append_when_current_valid(current, menu, (_("abort bouquet edit"), self.bouquetMarkAbort), level = 0)
167 append_when_current_valid(current, menu, (_("end favourites edit"), self.bouquetMarkEnd), level = 0)
168 append_when_current_valid(current, menu, (_("abort favourites edit"), self.bouquetMarkAbort), level = 0)
170 append_when_current_valid(current, menu, (_("end alternatives edit"), self.bouquetMarkEnd), level = 0)
171 append_when_current_valid(current, menu, (_("abort alternatives edit"), self.bouquetMarkAbort), level = 0)
173 menu.append(ChoiceEntryComponent(text = (_("back"), self.cancelClick)))
174 self["menu"] = ChoiceList(menu)
176 def okbuttonClick(self):
177 self["menu"].getCurrent()[0][1]()
179 def cancelClick(self):
182 def showServiceInformations(self):
183 self.session.open( ServiceInfo, self.csel.getCurrentSelection() )
185 def showBouquetInputBox(self):
186 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)
188 def bouquetInputCallback(self, bouquet):
189 if bouquet is not None:
190 self.csel.addBouquet(bouquet, None)
193 def addParentalProtection(self, service):
194 parentalControl.protectService(service.toCompareString())
197 def removeParentalProtection(self, service):
198 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"))
200 def pinEntered(self, service, result):
202 parentalControl.unProtectService(service)
205 self.session.openWithCallback(self.close, MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR)
207 def showServiceInPiP(self):
208 if not self.pipAvailable:
210 if self.session.pipshown:
212 self.session.pip = self.session.instantiateDialog(PictureInPicture)
213 self.session.pip.show()
214 newservice = self.csel.servicelist.getCurrent()
215 if self.session.pip.playService(newservice):
216 self.session.pipshown = True
217 self.session.pip.servicePath = self.csel.getCurrentServicePath()
220 self.session.pipshown = False
222 self.session.openWithCallback(self.close, MessageBox, _("Could not open Picture in Picture"), MessageBox.TYPE_ERROR)
224 def addServiceToBouquetSelected(self):
225 bouquets = self.csel.getBouquetList()
230 if cnt > 1: # show bouquet list
231 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
232 elif cnt == 1: # add to only one existing bouquet
233 self.addCurrentServiceToBouquet(bouquets[0][1], closeBouquetSelection = False)
235 def bouquetSelClosed(self, recursive):
240 def removeSatelliteServices(self):
241 curpath = self.csel.getCurrentSelection().getPath()
242 idx = curpath.find("satellitePosition == ")
244 tmp = curpath[idx+21:]
247 satpos = int(tmp[:idx])
248 eDVBDB.getInstance().removeServices(-1, -1, -1, satpos)
251 def copyCurrentToBouquetList(self):
252 self.csel.copyCurrentToBouquetList()
255 def removeBouquet(self):
256 self.csel.removeBouquet()
259 def showMarkerInputBox(self):
260 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)
262 def markerInputCallback(self, marker):
263 if marker is not None:
264 self.csel.addMarker(marker)
267 def addCurrentServiceToBouquet(self, dest, closeBouquetSelection = True):
268 self.csel.addServiceToBouquet(dest)
269 if self.bsel is not None:
270 self.bsel.close(True)
272 self.close(closeBouquetSelection) # close bouquet selection
274 def removeCurrentService(self):
275 self.csel.removeCurrentService()
278 def toggleMoveMode(self):
279 self.csel.toggleMoveMode()
282 def bouquetMarkStart(self):
283 self.csel.startMarkedEdit(EDIT_BOUQUET)
286 def bouquetMarkEnd(self):
287 self.csel.endMarkedEdit(abort=False)
290 def bouquetMarkAbort(self):
291 self.csel.endMarkedEdit(abort=True)
294 def removeNewFoundFlag(self):
295 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
298 def removeAllNewFoundFlags(self):
299 curpath = self.csel.getCurrentSelection().getPath()
300 idx = curpath.find("satellitePosition == ")
302 tmp = curpath[idx+21:]
305 satpos = int(tmp[:idx])
306 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
309 def editAlternativeServices(self):
310 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
313 def showAlternativeServices(self):
314 self.csel.enterPath(self.csel.getCurrentSelection())
317 def removeAlternativeServices(self):
318 self.csel.removeAlternativeServices()
321 def addAlternativeServices(self):
322 self.csel.addAlternativeServices()
323 self.csel.startMarkedEdit(EDIT_ALTERNATIVES)
326 class SelectionEventInfo:
328 self["ServiceEvent"] = ServiceEvent()
329 self.servicelist.connectSelChanged(self.__selectionChanged)
330 self.timer = eTimer()
331 self.timer.callback.append(self.updateEventInfo)
332 self.onShown.append(self.__selectionChanged)
334 def __selectionChanged(self):
336 self.timer.start(100, True)
338 def updateEventInfo(self):
339 cur = self.getCurrentSelection()
340 self["ServiceEvent"].newService(cur)
342 class ChannelSelectionEPG:
344 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
346 "showEPGList": self.showEPGList,
349 def showEPGList(self):
350 ref=self.getCurrentSelection()
352 self.savedService = ref
353 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB=self.changeServiceCB)
355 def SingleServiceEPGClosed(self, ret=False):
356 self.setCurrentSelection(self.savedService)
358 def changeServiceCB(self, direction, epg):
359 beg = self.getCurrentSelection()
365 cur = self.getCurrentSelection()
366 if cur == beg or not (cur.flags & eServiceReference.isMarker):
368 epg.setService(ServiceReference(self.getCurrentSelection()))
370 class ChannelSelectionEdit:
372 self.entry_marked = False
373 self.movemode = False
374 self.bouquet_mark_edit = OFF
375 self.mutableList = None
377 self.saved_title = None
378 self.saved_root = None
380 class ChannelSelectionEditActionMap(ActionMap):
381 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
382 ActionMap.__init__(self, contexts, actions, prio)
385 def action(self, contexts, action):
386 if action == "cancel":
387 self.csel.handleEditCancel()
388 return 0 # fall-trough
390 return 0 # fall-trough
392 return ActionMap.action(self, contexts, action)
394 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
396 "contextMenu": self.doContext,
399 def getMutableList(self, root=eServiceReference()):
400 if not self.mutableList is None:
401 return self.mutableList
402 serviceHandler = eServiceCenter.getInstance()
405 list = root and serviceHandler.list(root)
407 return list.startEdit()
410 def buildBouquetID(self, str):
414 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
420 def addMarker(self, name):
421 current = self.servicelist.getCurrent()
422 mutableList = self.getMutableList()
425 str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
426 ref = eServiceReference(str)
427 if current and current.valid():
428 if not mutableList.addService(ref, current):
429 self.servicelist.addService(ref, True)
430 mutableList.flushChanges()
432 elif not mutableList.addService(ref):
433 self.servicelist.addService(ref, True)
434 mutableList.flushChanges()
438 def addAlternativeServices(self):
439 cur_service = ServiceReference(self.getCurrentSelection())
440 root = self.getRoot()
441 cur_root = root and ServiceReference(root)
442 mutableBouquet = cur_root.list().startEdit()
444 name = cur_service.getServiceName()
446 if self.mode == MODE_TV:
447 str = '1:134:1:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(name))
449 str = '1:134:2:0:0:0:0:0:0:0:FROM BOUQUET \"alternatives.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(name))
450 new_ref = ServiceReference(str)
451 if not mutableBouquet.addService(new_ref.ref, cur_service.ref):
452 mutableBouquet.removeService(cur_service.ref)
453 mutableBouquet.flushChanges()
454 eDVBDB.getInstance().reloadBouquets()
455 mutableAlternatives = new_ref.list().startEdit()
456 if mutableAlternatives:
457 mutableAlternatives.setListName(name)
458 if mutableAlternatives.addService(cur_service.ref):
459 print "add", cur_service.ref.toString(), "to new alternatives failed"
460 mutableAlternatives.flushChanges()
461 self.servicelist.addService(new_ref.ref, True)
462 self.servicelist.removeCurrent()
463 self.servicelist.moveUp()
465 print "get mutable list for new created alternatives failed"
467 print "add", str, "to", cur_root.getServiceName(), "failed"
469 print "bouquetlist is not editable"
471 def addBouquet(self, bName, services):
472 serviceHandler = eServiceCenter.getInstance()
473 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
474 if mutableBouquetList:
475 if self.mode == MODE_TV:
477 str = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
480 str = '1:7:2:0:0:0:0:0:0:0:FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
481 new_bouquet_ref = eServiceReference(str)
482 if not mutableBouquetList.addService(new_bouquet_ref):
483 mutableBouquetList.flushChanges()
484 eDVBDB.getInstance().reloadBouquets()
485 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
487 mutableBouquet.setListName(bName)
488 if services is not None:
489 for service in services:
490 if mutableBouquet.addService(service):
491 print "add", service.toString(), "to new bouquet failed"
492 mutableBouquet.flushChanges()
494 print "get mutable list for new created bouquet failed"
495 # do some voodoo to check if current_root is equal to bouquet_root
496 cur_root = self.getRoot();
497 str1 = cur_root and cur_root.toString()
498 pos1 = str1 and str1.find("FROM BOUQUET") or -1
499 pos2 = self.bouquet_rootstr.find("FROM BOUQUET")
500 if pos1 != -1 and pos2 != -1 and str1[pos1:] == self.bouquet_rootstr[pos2:]:
501 self.servicelist.addService(new_bouquet_ref)
503 print "add", str, "to bouquets failed"
505 print "bouquetlist is not editable"
507 def copyCurrentToBouquetList(self):
508 provider = ServiceReference(self.getCurrentSelection())
509 providerName = provider.getServiceName()
510 serviceHandler = eServiceCenter.getInstance()
511 services = serviceHandler.list(provider.ref)
512 self.addBouquet(providerName, services and services.getContent('R', True))
514 def removeAlternativeServices(self):
515 cur_service = ServiceReference(self.getCurrentSelection())
516 root = self.getRoot()
517 cur_root = root and ServiceReference(root)
518 list = cur_service.list()
519 first_in_alternative = list and list.getNext()
520 if first_in_alternative:
521 edit_root = cur_root and cur_root.list().startEdit()
523 if not edit_root.addService(first_in_alternative, cur_service.ref):
524 self.servicelist.addService(first_in_alternative, True)
526 print "couldn't add first alternative service to current root"
528 print "couldn't edit current root!!"
530 print "remove empty alternative list !!"
532 self.servicelist.moveUp()
534 def removeBouquet(self):
535 refstr = self.getCurrentSelection().toString()
536 print "removeBouquet", refstr
537 self.bouquetNumOffsetCache = { }
538 pos = refstr.find('FROM BOUQUET "')
541 refstr = refstr[pos+14:]
542 pos = refstr.find('"')
544 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
545 self.removeCurrentService()
547 if filename is not None:
550 print "error during remove of", filename
552 # multiple marked entry stuff ( edit mode, later multiepg selection )
553 def startMarkedEdit(self, type):
554 self.savedPath = self.servicePath[:]
555 if type == EDIT_ALTERNATIVES:
556 self.enterPath(self.getCurrentSelection())
557 self.mutableList = self.getMutableList()
558 # add all services from the current list to internal marked set in listboxservicecontent
559 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
560 self.saved_title = self.getTitle()
561 pos = self.saved_title.find(')')
562 new_title = self.saved_title[:pos+1]
563 if type == EDIT_ALTERNATIVES:
564 self.bouquet_mark_edit = EDIT_ALTERNATIVES
565 new_title += ' ' + _("[alternative edit]")
567 self.bouquet_mark_edit = EDIT_BOUQUET
568 if config.usage.multibouquet.value:
569 new_title += ' ' + _("[bouquet edit]")
571 new_title += ' ' + _("[favourite edit]")
572 self.setTitle(new_title)
573 self.__marked = self.servicelist.getRootServices()
574 for x in self.__marked:
575 self.servicelist.addMarked(eServiceReference(x))
576 self.showAllServices()
578 def endMarkedEdit(self, abort):
579 if not abort and self.mutableList is not None:
580 self.bouquetNumOffsetCache = { }
581 new_marked = set(self.servicelist.getMarked())
582 old_marked = set(self.__marked)
583 removed = old_marked - new_marked
584 added = new_marked - old_marked
588 self.mutableList.removeService(eServiceReference(x))
591 self.mutableList.addService(eServiceReference(x))
593 self.mutableList.flushChanges()
596 self.bouquet_mark_edit = OFF
597 self.mutableList = None
598 self.setTitle(self.saved_title)
599 self.saved_title = None
600 # self.servicePath is just a reference to servicePathTv or Radio...
601 # so we never ever do use the asignment operator in self.servicePath
602 del self.servicePath[:] # remove all elements
603 self.servicePath += self.savedPath # add saved elements
605 self.setRoot(self.servicePath[-1])
607 def clearMarks(self):
608 self.servicelist.clearMarks()
611 ref = self.servicelist.getCurrent()
612 if self.servicelist.isMarked(ref):
613 self.servicelist.removeMarked(ref)
615 self.servicelist.addMarked(ref)
617 def removeCurrentService(self):
618 ref = self.servicelist.getCurrent()
619 mutableList = self.getMutableList()
620 if ref.valid() and mutableList is not None:
621 if not mutableList.removeService(ref):
622 self.bouquetNumOffsetCache = { }
623 mutableList.flushChanges() #FIXME dont flush on each single removed service
624 self.servicelist.removeCurrent()
626 def addServiceToBouquet(self, dest, service=None):
627 mutableList = self.getMutableList(dest)
628 if not mutableList is None:
629 if service is None: #use current selected service
630 service = self.servicelist.getCurrent()
631 if not mutableList.addService(service):
632 self.bouquetNumOffsetCache = { }
633 mutableList.flushChanges()
634 # do some voodoo to check if current_root is equal to dest
635 cur_root = self.getRoot();
636 str1 = cur_root and cur_root.toString() or -1
637 str2 = dest.toString()
638 pos1 = str1.find("FROM BOUQUET")
639 pos2 = str2.find("FROM BOUQUET")
640 if pos1 != -1 and pos2 != -1 and str1[pos1:] == str2[pos2:]:
641 self.servicelist.addService(service)
643 def toggleMoveMode(self):
645 if self.entry_marked:
646 self.toggleMoveMarked() # unmark current entry
647 self.movemode = False
648 self.pathChangeDisabled = False # re-enable path change
649 self.mutableList.flushChanges() # FIXME add check if changes was made
650 self.mutableList = None
651 self.setTitle(self.saved_title)
652 self.saved_title = None
653 cur_root = self.getRoot()
654 if cur_root and cur_root == self.bouquet_root:
655 self.bouquetNumOffsetCache = { }
657 self.mutableList = self.getMutableList()
659 self.pathChangeDisabled = True # no path change allowed in movemode
660 self.saved_title = self.getTitle()
661 new_title = self.saved_title
662 pos = self.saved_title.find(')')
663 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
664 self.setTitle(new_title);
666 def handleEditCancel(self):
667 if self.movemode: #movemode active?
668 self.channelSelected() # unmark
669 self.toggleMoveMode() # disable move mode
670 elif self.bouquet_mark_edit != OFF:
671 self.endMarkedEdit(True) # abort edit mode
673 def toggleMoveMarked(self):
674 if self.entry_marked:
675 self.servicelist.setCurrentMarked(False)
676 self.entry_marked = False
678 self.servicelist.setCurrentMarked(True)
679 self.entry_marked = True
682 self.session.openWithCallback(self.exitContext, ChannelContextMenu, self)
684 def exitContext(self, close = False):
691 # type 1 = digital television service
692 # type 4 = nvod reference service (NYI)
693 # type 17 = MPEG-2 HD digital television service
694 # type 22 = advanced codec SD digital television
695 # type 24 = advanced codec SD NVOD reference service (NYI)
696 # type 25 = advanced codec HD digital television
697 # type 27 = advanced codec HD NVOD reference service (NYI)
698 # type 2 = digital radio sound service
699 # type 10 = advanced codec digital radio sound service
701 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)'
702 service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2) || (type == 10)'
704 class ChannelSelectionBase(Screen):
705 def __init__(self, session):
706 Screen.__init__(self, session)
708 self["key_red"] = Button(_("All"))
709 self["key_green"] = Button(_("Satellites"))
710 self["key_yellow"] = Button(_("Provider"))
711 self["key_blue"] = Button(_("Favourites"))
713 self["list"] = ServiceList()
714 self.servicelist = self["list"]
716 self.numericalTextInput = NumericalTextInput()
717 self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
719 self.servicePathTV = [ ]
720 self.servicePathRadio = [ ]
721 self.servicePath = [ ]
722 self.rootChanged = False
726 self.pathChangeDisabled = False
728 self.bouquetNumOffsetCache = { }
730 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions", "InputAsciiActions"],
732 "showFavourites": self.showFavourites,
733 "showAllServices": self.showAllServices,
734 "showProviders": self.showProviders,
735 "showSatellites": self.showSatellites,
736 "nextBouquet": self.nextBouquet,
737 "prevBouquet": self.prevBouquet,
738 "nextMarker": self.nextMarker,
739 "prevMarker": self.prevMarker,
740 "gotAsciiCode": self.keyAsciiCode,
741 "1": self.keyNumberGlobal,
742 "2": self.keyNumberGlobal,
743 "3": self.keyNumberGlobal,
744 "4": self.keyNumberGlobal,
745 "5": self.keyNumberGlobal,
746 "6": self.keyNumberGlobal,
747 "7": self.keyNumberGlobal,
748 "8": self.keyNumberGlobal,
749 "9": self.keyNumberGlobal,
752 self.recallBouquetMode()
754 def getBouquetNumOffset(self, bouquet):
755 if not config.usage.multibouquet.value:
757 str = bouquet.toString()
759 if not self.bouquetNumOffsetCache.has_key(str):
760 serviceHandler = eServiceCenter.getInstance()
761 bouquetlist = serviceHandler.list(self.bouquet_root)
762 if not bouquetlist is None:
764 bouquetIterator = bouquetlist.getNext()
765 if not bouquetIterator.valid(): #end of list
767 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
768 if not (bouquetIterator.flags & eServiceReference.isDirectory):
770 servicelist = serviceHandler.list(bouquetIterator)
771 if not servicelist is None:
773 serviceIterator = servicelist.getNext()
774 if not serviceIterator.valid(): #check if end of list
776 playable = not (serviceIterator.flags & (eServiceReference.isDirectory|eServiceReference.isMarker))
779 return self.bouquetNumOffsetCache.get(str, offsetCount)
781 def recallBouquetMode(self):
782 if self.mode == MODE_TV:
783 self.service_types = service_types_tv
784 if config.usage.multibouquet.value:
785 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
787 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
789 self.service_types = service_types_radio
790 if config.usage.multibouquet.value:
791 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
793 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
794 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
798 self.servicePath = self.servicePathTV
799 self.recallBouquetMode()
800 title = self.getTitle()
801 pos = title.find(" (")
807 def setRadioMode(self):
808 self.mode = MODE_RADIO
809 self.servicePath = self.servicePathRadio
810 self.recallBouquetMode()
811 title = self.getTitle()
812 pos = title.find(" (")
818 def setRoot(self, root, justSet=False):
819 path = root.getPath()
820 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
821 pos = path.find('FROM BOUQUET')
822 isBouquet = (pos != -1) and (root.flags & eServiceReference.isDirectory)
823 if not inBouquetRootList and isBouquet:
824 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
825 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
827 self.servicelist.setMode(ServiceList.MODE_NORMAL)
828 self.servicelist.setRoot(root, justSet)
829 self.rootChanged = True
830 self.buildTitleString()
832 def removeModeStr(self, str):
833 if self.mode == MODE_TV:
834 pos = str.find(' (TV)')
836 pos = str.find(' (Radio)')
841 def getServiceName(self, ref):
842 str = self.removeModeStr(ServiceReference(ref).getServiceName())
844 pathstr = ref.getPath()
845 if 'FROM PROVIDERS' in pathstr:
847 if 'FROM SATELLITES' in pathstr:
848 return _("Satellites")
849 if ') ORDER BY name' in pathstr:
853 def buildTitleString(self):
854 titleStr = self.getTitle()
855 pos = titleStr.find(']')
857 pos = titleStr.find(')')
859 titleStr = titleStr[:pos+1]
860 Len = len(self.servicePath)
862 base_ref = self.servicePath[0]
864 end_ref = self.servicePath[Len-1]
867 nameStr = self.getServiceName(base_ref)
868 titleStr += ' ' + nameStr
869 if end_ref is not None:
874 nameStr = self.getServiceName(end_ref)
876 self.setTitle(titleStr)
879 self.servicelist.moveUp()
882 self.servicelist.moveDown()
885 del self.servicePath[:]
887 def enterPath(self, ref, justSet=False):
888 self.servicePath.append(ref)
889 self.setRoot(ref, justSet)
891 def pathUp(self, justSet=False):
892 prev = self.servicePath.pop()
894 current = self.servicePath[-1]
895 self.setRoot(current, justSet)
897 self.setCurrentSelection(prev)
900 def isBasePathEqual(self, ref):
901 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
905 def isPrevPathEqual(self, ref):
906 length = len(self.servicePath)
907 if length > 1 and self.servicePath[length-2] == ref:
911 def preEnterPath(self, refstr):
914 def showAllServices(self):
915 if not self.pathChangeDisabled:
916 refstr = '%s ORDER BY name'%(self.service_types)
917 if not self.preEnterPath(refstr):
918 ref = eServiceReference(refstr)
919 currentRoot = self.getRoot()
920 if currentRoot is None or currentRoot != ref:
924 def showSatellites(self):
925 if not self.pathChangeDisabled:
926 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
927 if not self.preEnterPath(refstr):
928 ref = eServiceReference(refstr)
932 if self.isBasePathEqual(ref):
933 if self.isPrevPathEqual(ref):
935 prev = self.pathUp(justSet)
937 currentRoot = self.getRoot()
938 if currentRoot is None or currentRoot != ref:
941 self.enterPath(ref, True)
943 serviceHandler = eServiceCenter.getInstance()
944 servicelist = serviceHandler.list(ref)
945 if not servicelist is None:
947 service = servicelist.getNext()
948 if not service.valid(): #check if end of list
950 unsigned_orbpos = service.getUnsignedData(4) >> 16
951 orbpos = service.getData(4) >> 16
954 if service.getPath().find("FROM PROVIDER") != -1:
955 service_type = _("Providers")
956 elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
957 service_type = _("New")
959 service_type = _("Services")
961 # why we need this cast?
962 service_name = str(nimmanager.getSatDescription(orbpos))
964 if unsigned_orbpos == 0xFFFF: #Cable
965 service_name = _("Cable")
966 elif unsigned_orbpos == 0xEEEE: #Terrestrial
967 service_name = _("Terrestrial")
969 if orbpos > 1800: # west
970 orbpos = 3600 - orbpos
974 service_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
975 service.setName("%s - %s" % (service_name, service_type))
976 self.servicelist.addService(service)
977 cur_ref = self.session.nav.getCurrentlyPlayingServiceReference()
979 pos = self.service_types.rfind(':')
980 refstr = '%s (channelID == %08x%04x%04x) && %s ORDER BY name' %(self.service_types[:pos+1],
981 cur_ref.getUnsignedData(4), # NAMESPACE
982 cur_ref.getUnsignedData(2), # TSID
983 cur_ref.getUnsignedData(3), # ONID
984 self.service_types[pos+1:])
985 ref = eServiceReference(refstr)
986 ref.setName(_("Current Transponder"))
987 self.servicelist.addService(ref)
988 self.servicelist.finishFill()
990 self.setCurrentSelection(prev)
992 def showProviders(self):
993 if not self.pathChangeDisabled:
994 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
995 if not self.preEnterPath(refstr):
996 ref = eServiceReference(refstr)
997 if self.isBasePathEqual(ref):
1000 currentRoot = self.getRoot()
1001 if currentRoot is None or currentRoot != ref:
1005 def changeBouquet(self, direction):
1006 if not self.pathChangeDisabled:
1007 if len(self.servicePath) > 1:
1008 #when enter satellite root list we must do some magic stuff..
1009 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
1010 if self.isBasePathEqual(ref):
1011 self.showSatellites()
1018 ref = self.getCurrentSelection()
1021 def inBouquet(self):
1022 if self.servicePath and self.servicePath[0] == self.bouquet_root:
1027 return self.servicelist.atBegin()
1030 return self.servicelist.atEnd()
1032 def nextBouquet(self):
1033 self.changeBouquet(+1)
1035 def prevBouquet(self):
1036 self.changeBouquet(-1)
1038 def showFavourites(self):
1039 if not self.pathChangeDisabled:
1040 if not self.preEnterPath(self.bouquet_rootstr):
1041 if self.isBasePathEqual(self.bouquet_root):
1044 currentRoot = self.getRoot()
1045 if currentRoot is None or currentRoot != self.bouquet_root:
1047 self.enterPath(self.bouquet_root)
1049 def keyNumberGlobal(self, number):
1050 unichar = self.numericalTextInput.getKey(number)
1051 charstr = unichar.encode("utf-8")
1052 if len(charstr) == 1:
1053 self.servicelist.moveToChar(charstr[0])
1055 def keyAsciiCode(self):
1056 unichar = unichr(getPrevAsciiCode())
1057 charstr = unichar.encode("utf-8")
1058 if len(charstr) == 1:
1059 self.servicelist.moveToChar(charstr[0])
1062 return self.servicelist.getRoot()
1064 def getCurrentSelection(self):
1065 return self.servicelist.getCurrent()
1067 def setCurrentSelection(self, service):
1068 self.servicelist.setCurrent(service)
1070 def getBouquetList(self):
1072 serviceHandler = eServiceCenter.getInstance()
1073 if config.usage.multibouquet.value:
1074 list = serviceHandler.list(self.bouquet_root)
1080 if s.flags & eServiceReference.isDirectory:
1081 info = serviceHandler.info(s)
1083 bouquets.append((info.getName(s), s))
1086 info = serviceHandler.info(self.bouquet_root)
1088 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
1092 def keyNumber0(self, num):
1093 if len(self.servicePath) > 1:
1096 self.keyNumberGlobal(num)
1099 if len(self.servicePath) > 1:
1100 if self.isBasePathEqual(self.bouquet_root):
1101 self.showFavourites()
1103 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
1104 if self.isBasePathEqual(ref):
1105 self.showSatellites()
1107 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
1108 if self.isBasePathEqual(ref):
1109 self.showProviders()
1111 self.showAllServices()
1113 def nextMarker(self):
1114 self.servicelist.moveToNextMarker()
1116 def prevMarker(self):
1117 self.servicelist.moveToPrevMarker()
1121 #config for lastservice
1122 config.tv = ConfigSubsection()
1123 config.tv.lastservice = ConfigText()
1124 config.tv.lastroot = ConfigText()
1125 config.radio = ConfigSubsection()
1126 config.radio.lastservice = ConfigText()
1127 config.radio.lastroot = ConfigText()
1128 config.servicelist = ConfigSubsection()
1129 config.servicelist.lastmode = ConfigText(default = "tv")
1131 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, SelectionEventInfo):
1132 def __init__(self, session):
1133 ChannelSelectionBase.__init__(self,session)
1134 ChannelSelectionEdit.__init__(self)
1135 ChannelSelectionEPG.__init__(self)
1136 SelectionEventInfo.__init__(self)
1138 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1140 "cancel": self.cancel,
1141 "ok": self.channelSelected,
1142 "keyRadio": self.setModeRadio,
1143 "keyTV": self.setModeTv,
1146 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1148 iPlayableService.evStart: self.__evServiceStart,
1149 iPlayableService.evEnd: self.__evServiceEnd
1152 self.lastChannelRootTimer = eTimer()
1153 self.lastChannelRootTimer.callback.append(self.__onCreate)
1154 self.lastChannelRootTimer.start(100,True)
1156 self.history_tv = [ ]
1157 self.history_radio = [ ]
1158 self.history = self.history_tv
1159 self.history_pos = 0
1161 self.lastservice = config.tv.lastservice
1162 self.lastroot = config.tv.lastroot
1163 self.revertMode = None
1164 config.usage.multibouquet.addNotifier(self.multibouquet_config_changed)
1165 self.new_service_played = False
1166 self.onExecBegin.append(self.asciiOn)
1169 rcinput = eRCInput.getInstance()
1170 rcinput.setKeyboardMode(rcinput.kmAscii)
1173 rcinput = eRCInput.getInstance()
1174 rcinput.setKeyboardMode(rcinput.kmNone)
1176 def multibouquet_config_changed(self, val):
1177 self.recallBouquetMode()
1179 def __evServiceStart(self):
1180 service = self.session.nav.getCurrentService()
1182 info = service.info()
1184 refstr = info.getInfoString(iServiceInformation.sServiceref)
1185 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1187 def __evServiceEnd(self):
1188 self.servicelist.setPlayableIgnoreService(eServiceReference())
1191 self.rootChanged = True
1193 lastservice=eServiceReference(self.lastservice.value)
1194 if lastservice.valid():
1195 self.setCurrentSelection(lastservice)
1197 def setModeTv(self):
1198 if self.revertMode is None and config.servicelist.lastmode.value == "radio":
1199 self.revertMode = MODE_RADIO
1200 self.history = self.history_tv
1201 self.lastservice = config.tv.lastservice
1202 self.lastroot = config.tv.lastroot
1203 config.servicelist.lastmode.value = "tv"
1207 def setModeRadio(self):
1208 if self.revertMode is None and config.servicelist.lastmode.value == "tv":
1209 self.revertMode = MODE_TV
1210 if config.usage.e1like_radio_mode.value:
1211 self.history = self.history_radio
1212 self.lastservice = config.radio.lastservice
1213 self.lastroot = config.radio.lastroot
1214 config.servicelist.lastmode.value = "radio"
1218 def __onCreate(self):
1219 if config.usage.e1like_radio_mode.value:
1220 if config.servicelist.lastmode.value == "tv":
1226 lastservice=eServiceReference(self.lastservice.value)
1227 if lastservice.valid():
1230 def channelSelected(self):
1231 ref = self.getCurrentSelection()
1233 self.toggleMoveMarked()
1234 elif (ref.flags & 7) == 7:
1236 elif self.bouquet_mark_edit != OFF:
1237 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1239 elif not (ref.flags & eServiceReference.isMarker): # no marker
1240 root = self.getRoot()
1241 if not root or not (root.flags & eServiceReference.isGroup):
1246 #called from infoBar and channelSelected
1248 self.revertMode=None
1249 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1250 nref = self.getCurrentSelection()
1251 if ref is None or ref != nref:
1252 self.new_service_played = True
1253 self.session.nav.playService(nref)
1255 self.saveChannel(nref)
1256 config.servicelist.lastmode.save()
1257 self.addToHistory(nref)
1259 def newServicePlayed(self):
1260 ret = self.new_service_played
1261 self.new_service_played = False
1264 def addToHistory(self, ref):
1265 if self.servicePath is not None:
1266 tmp=self.servicePath[:]
1269 del self.history[self.history_pos+1:]
1272 self.history.append(tmp)
1273 hlen = len(self.history)
1274 if hlen > HISTORYSIZE:
1277 self.history_pos = hlen-1
1279 def historyBack(self):
1280 hlen = len(self.history)
1281 if hlen > 1 and self.history_pos > 0:
1282 self.history_pos -= 1
1283 self.setHistoryPath()
1285 def historyNext(self):
1286 hlen = len(self.history)
1287 if hlen > 1 and self.history_pos < (hlen-1):
1288 self.history_pos += 1
1289 self.setHistoryPath()
1291 def setHistoryPath(self):
1292 path = self.history[self.history_pos][:]
1294 del self.servicePath[:]
1295 self.servicePath += path
1298 cur_root = self.getRoot()
1299 if cur_root and cur_root != root:
1301 self.session.nav.playService(ref)
1302 self.setCurrentSelection(ref)
1303 self.saveChannel(ref)
1307 for i in self.servicePath:
1308 path += i.toString()
1310 if path and path != self.lastroot.value:
1311 self.lastroot.value = path
1312 self.lastroot.save()
1314 def restoreRoot(self):
1315 tmp = [x for x in self.lastroot.value.split(';') if x != '']
1316 current = [x.toString() for x in self.servicePath]
1317 if tmp != current or self.rootChanged:
1321 self.servicePath.append(eServiceReference(i))
1324 path = self.servicePath.pop()
1325 self.enterPath(path)
1327 self.showFavourites()
1329 self.rootChanged = False
1331 def preEnterPath(self, refstr):
1332 if self.servicePath and self.servicePath[0] != eServiceReference(refstr):
1333 pathstr = self.lastroot.value
1334 if pathstr is not None and pathstr.find(refstr) == 0:
1336 lastservice=eServiceReference(self.lastservice.value)
1337 if lastservice.valid():
1338 self.setCurrentSelection(lastservice)
1342 def saveChannel(self, ref):
1344 refstr = ref.toString()
1347 if refstr != self.lastservice.value:
1348 self.lastservice.value = refstr
1349 self.lastservice.save()
1351 def setCurrentServicePath(self, path):
1353 self.history[self.history_pos] = path
1355 self.history.append(path)
1356 self.setHistoryPath()
1358 def getCurrentServicePath(self):
1360 return self.history[self.history_pos]
1363 def recallPrevService(self):
1364 hlen = len(self.history)
1366 if self.history_pos == hlen-1:
1367 tmp = self.history[self.history_pos]
1368 self.history[self.history_pos] = self.history[self.history_pos-1]
1369 self.history[self.history_pos-1] = tmp
1371 tmp = self.history[self.history_pos+1]
1372 self.history[self.history_pos+1] = self.history[self.history_pos]
1373 self.history[self.history_pos] = tmp
1374 self.setHistoryPath()
1377 if self.revertMode is None:
1379 lastservice=eServiceReference(self.lastservice.value)
1380 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1381 self.setCurrentSelection(lastservice)
1382 elif self.revertMode == MODE_TV:
1384 elif self.revertMode == MODE_RADIO:
1386 self.revertMode = None
1390 class RadioInfoBar(Screen):
1391 def __init__(self, session):
1392 Screen.__init__(self, session)
1393 self["RdsDecoder"] = RdsDecoder(self.session.nav)
1395 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, InfoBarBase):
1396 ALLOW_SUSPEND = True
1398 def __init__(self, session, infobar):
1399 ChannelSelectionBase.__init__(self, session)
1400 ChannelSelectionEdit.__init__(self)
1401 ChannelSelectionEPG.__init__(self)
1402 InfoBarBase.__init__(self)
1403 self.infobar = infobar
1404 self.onLayoutFinish.append(self.onCreate)
1406 self.info = session.instantiateDialog(RadioInfoBar) # our simple infobar
1408 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1410 "keyTV": self.cancel,
1411 "keyRadio": self.cancel,
1412 "cancel": self.cancel,
1413 "ok": self.channelSelected,
1416 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1418 iPlayableService.evStart: self.__evServiceStart,
1419 iPlayableService.evEnd: self.__evServiceEnd
1422 ########## RDS Radiotext / Rass Support BEGIN
1423 self.infobar = infobar # reference to real infobar (the one and only)
1424 self["RdsDecoder"] = self.info["RdsDecoder"]
1425 self["RdsActions"] = HelpableActionMap(self, "InfobarRdsActions",
1427 "startRassInteractive": (self.startRassInteractive, _("View Rass interactive..."))
1429 self["RdsActions"].setEnabled(False)
1430 infobar.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
1431 self.onClose.append(self.__onClose)
1433 def __onClose(self):
1434 lastservice=eServiceReference(config.tv.lastservice.value)
1435 self.session.nav.playService(lastservice)
1437 def startRassInteractive(self):
1439 self.infobar.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
1441 def RassInteractiveClosed(self):
1443 self.infobar.rass_interactive = None
1444 self.infobar.RassSlidePicChanged()
1446 def RassInteractivePossibilityChanged(self, state):
1447 self["RdsActions"].setEnabled(state)
1448 ########## RDS Radiotext / Rass Support END
1451 self.infobar.rds_display.onRassInteractivePossibilityChanged.remove(self.RassInteractivePossibilityChanged)
1453 #set previous tv service
1456 def __evServiceStart(self):
1457 service = self.session.nav.getCurrentService()
1459 info = service.info()
1461 refstr = info.getInfoString(iServiceInformation.sServiceref)
1462 self.servicelist.setPlayableIgnoreService(eServiceReference(refstr))
1464 def __evServiceEnd(self):
1465 self.servicelist.setPlayableIgnoreService(eServiceReference())
1469 for i in self.servicePathRadio:
1470 path += i.toString()
1472 if path and path != config.radio.lastroot.value:
1473 config.radio.lastroot.value = path
1474 config.radio.lastroot.save()
1476 def restoreRoot(self):
1477 tmp = [x for x in config.radio.lastroot.value.split(';') if x != '']
1478 current = [x.toString() for x in self.servicePath]
1479 if tmp != current or self.rootChanged:
1482 self.servicePathRadio.append(eServiceReference(i))
1485 path = self.servicePathRadio.pop()
1486 self.enterPath(path)
1488 self.showFavourites()
1490 self.rootChanged = False
1492 def preEnterPath(self, refstr):
1493 if self.servicePathRadio and self.servicePathRadio[0] != eServiceReference(refstr):
1494 pathstr = config.radio.lastroot.value
1495 if pathstr is not None and pathstr.find(refstr) == 0:
1497 lastservice=eServiceReference(config.radio.lastservice.value)
1498 if lastservice.valid():
1499 self.setCurrentSelection(lastservice)
1506 lastservice=eServiceReference(config.radio.lastservice.value)
1507 if lastservice.valid():
1508 self.servicelist.setCurrent(lastservice)
1509 self.session.nav.playService(lastservice)
1511 self.session.nav.stopService()
1514 def channelSelected(self): # just return selected service
1515 ref = self.getCurrentSelection()
1517 self.toggleMoveMarked()
1518 elif (ref.flags & 7) == 7:
1520 elif self.bouquet_mark_edit != OFF:
1521 if not (self.bouquet_mark_edit == EDIT_ALTERNATIVES and ref.flags & eServiceReference.isGroup):
1523 elif not (ref.flags & eServiceReference.isMarker): # no marker
1524 cur_root = self.getRoot()
1525 if not cur_root or not (cur_root.flags & eServiceReference.isGroup):
1526 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1527 if playingref is None or playingref != ref:
1528 self.session.nav.playService(ref)
1529 config.radio.lastservice.value = ref.toString()
1530 config.radio.lastservice.save()
1533 class SimpleChannelSelection(ChannelSelectionBase):
1534 def __init__(self, session, title):
1535 ChannelSelectionBase.__init__(self, session)
1536 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1538 "cancel": self.close,
1539 "ok": self.channelSelected,
1540 "keyRadio": self.setModeRadio,
1541 "keyTV": self.setModeTv,
1544 self.onLayoutFinish.append(self.layoutFinished)
1546 def layoutFinished(self):
1549 def channelSelected(self): # just return selected service
1550 ref = self.getCurrentSelection()
1551 if (ref.flags & 7) == 7:
1553 elif not (ref.flags & eServiceReference.isMarker):
1554 ref = self.getCurrentSelection()
1557 def setModeTv(self):
1559 self.showFavourites()
1561 def setModeRadio(self):
1563 self.showFavourites()