1 from Screen import Screen
2 from Components.Button import Button
3 from Components.ServiceList import ServiceList
4 from Components.ActionMap import NumberActionMap, ActionMap
5 from Components.MenuList import MenuList
6 from EpgSelection import EPGSelection
7 from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
8 from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
9 from Screens.FixedMenu import FixedMenu
10 from Tools.NumericalTextInput import NumericalTextInput
11 from Components.NimManager import nimmanager
12 from Components.ServiceName import ServiceName
13 from Components.Clock import Clock
14 from Components.EventInfo import EventInfo
15 from ServiceReference import ServiceReference
19 import xml.dom.minidom
21 class BouquetSelector(Screen):
22 def __init__(self, session, bouquets, selectedFunc):
23 Screen.__init__(self, session)
25 self.selectedFunc=selectedFunc
27 self["actions"] = ActionMap(["OkCancelActions"],
29 "ok": self.okbuttonClick,
30 "cancel": self.cancelClick
34 entrys.append((x[0], x[1]))
35 self["menu"] = MenuList(entrys)
37 def okbuttonClick(self):
38 self.selectedFunc(self["menu"].getCurrent()[1])
40 def cancelClick(self):
43 class ChannelContextMenu(Screen):
44 def __init__(self, session, csel):
45 Screen.__init__(self, session)
48 self["actions"] = ActionMap(["OkCancelActions"],
50 "ok": self.okbuttonClick,
51 "cancel": self.cancelClick
55 inBouquetRootList = csel.getRoot().getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
56 inBouquet = csel.getMutableList() is not None
57 haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
59 if not csel.bouquet_mark_edit and not csel.movemode:
60 if not inBouquetRootList:
61 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
63 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
65 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
67 if not inBouquet and csel.getCurrentSelection().getPath().find("PROVIDERS") == -1:
68 menu.append((_("copy to favourites"), csel.copyCurrentToBouquetList))
70 menu.append((_("remove service"), self.removeCurrentService))
72 menu.append((_("remove bouquet"), csel.removeBouquet))
74 if inBouquet: # current list is editable?
75 if not csel.bouquet_mark_edit:
77 menu.append((_("enable move mode"), self.toggleMoveMode))
78 if not inBouquetRootList:
80 menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
82 menu.append((_("enable favourite edit"), self.bouquetMarkStart))
84 menu.append((_("disable move mode"), self.toggleMoveMode))
85 elif not inBouquetRootList:
87 menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
88 menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
90 menu.append((_("end favourites edit"), self.bouquetMarkEnd))
91 menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
93 menu.append((_("back"), self.cancelClick))
94 self["menu"] = MenuList(menu)
96 def okbuttonClick(self):
97 self["menu"].getCurrent()[1]()
99 def cancelClick(self):
102 def addServiceToBouquetSelected(self):
103 bouquets = self.csel.getBouquetList()
108 if cnt > 1: # show bouquet list
109 self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
110 elif cnt == 1: # add to only one existing bouquet
111 self.addCurrentServiceToBouquet(bouquets[0][1])
112 else: #no bouquets in root.. so assume only one favourite list is used
113 self.addCurrentServiceToBouquet(self.csel.bouquet_root)
115 def bouquetSelClosed(self, recursive):
119 def copyCurrentToBouquetList(self):
120 self.csel.copyCurrentToBouquetList()
123 def removeBouquet(self):
124 self.csel.removeBouquet()
127 def addCurrentServiceToBouquet(self, dest):
128 self.csel.addCurrentServiceToBouquet(dest)
129 self.close(True) # close bouquet selection
131 def removeCurrentService(self):
132 self.csel.removeCurrentService()
135 def toggleMoveMode(self):
136 self.csel.toggleMoveMode()
139 def bouquetMarkStart(self):
140 self.csel.startMarkedEdit()
143 def bouquetMarkEnd(self):
144 self.csel.endMarkedEdit(abort=False)
147 def bouquetMarkAbort(self):
148 self.csel.endMarkedEdit(abort=True)
151 class ChannelSelectionEPG:
153 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
155 "showEPGList": self.showEPGList,
158 def showEPGList(self):
159 ref=self.getCurrentSelection()
160 ptr=eEPGCache.getInstance()
161 if ptr.startTimeQuery(ref) != -1:
162 self.session.open(EPGSelection, ref)
164 print 'no epg for service', ref.toString()
166 class ChannelSelectionEdit:
168 self.entry_marked = False
169 self.movemode = False
170 self.bouquet_mark_edit = False
171 self.mutableList = None
173 self.saved_title = None
174 self.saved_root = None
176 class ChannelSelectionEditActionMap(ActionMap):
177 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
178 ActionMap.__init__(self, contexts, actions, prio)
180 def action(self, contexts, action):
181 if action == "cancel":
182 self.csel.handleEditCancel()
184 pass # avoid typo warning...
186 ActionMap.action(self, contexts, action)
187 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
189 "contextMenu": self.doContext,
192 def getMutableList(self, root=eServiceReference()):
193 if not self.mutableList is None:
194 return self.mutableList
195 serviceHandler = eServiceCenter.getInstance()
198 list = serviceHandler.list(root)
200 return list.startEdit()
203 def buildBouquetID(self, str):
207 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
213 def copyCurrentToBouquetList(self):
214 provider = ServiceReference(self.getCurrentSelection())
215 serviceHandler = eServiceCenter.getInstance()
216 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
217 if mutableBouquetList:
218 providerName = provider.getServiceName()
219 if self.mode == MODE_TV:
220 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
222 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
223 new_bouquet_ref = eServiceReference(str)
224 if not mutableBouquetList.addService(new_bouquet_ref):
225 self.bouquetNumOffsetCache = { }
226 mutableBouquetList.flushChanges()
227 eDVBDB.getInstance().reloadBouquets()
228 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
230 mutableBouquet.setListName(providerName)
232 services = serviceHandler.list(provider.ref)
233 if not services is None:
234 if not services.getContent(list, True):
236 if mutableBouquet.addService(service):
237 print "add", service.toString(), "to new bouquet failed"
238 mutableBouquet.flushChanges()
240 print "getContent failed"
242 print "list provider", providerName, "failed"
244 print "get mutable list for new created bouquet failed"
246 print "add", str, "to bouquets failed"
248 print "bouquetlist is not editable"
250 def removeBouquet(self):
251 refstr = self.getCurrentSelection().toString()
252 self.bouquetNumOffsetCache = { }
253 pos = refstr.find('FROM BOUQUET "')
255 refstr = refstr[pos+14:]
256 pos = refstr.find('"')
258 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
259 self.removeCurrentService()
261 eDVBDB.getInstance().reloadBouquets()
263 # multiple marked entry stuff ( edit mode, later multiepg selection )
264 def startMarkedEdit(self):
265 self.mutableList = self.getMutableList()
266 # add all services from the current list to internal marked set in listboxservicecontent
267 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
268 self.saved_title = self.instance.getTitle()
269 pos = self.saved_title.find(')')
270 new_title = self.saved_title[:pos+1]
271 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
272 new_title += ' ' + _("[bouquet edit]")
274 new_title += ' ' + _("[favourite edit]")
275 self.instance.setTitle(new_title)
276 self.bouquet_mark_edit = True
277 self.__marked = self.servicelist.getRootServices()
278 for x in self.__marked:
279 self.servicelist.addMarked(eServiceReference(x))
280 self.savedPath = self.servicePath[:]
281 self.showAllServices()
283 def endMarkedEdit(self, abort):
284 if not abort and self.mutableList is not None:
285 self.bouquetNumOffsetCache = { }
286 new_marked = set(self.servicelist.getMarked())
287 old_marked = set(self.__marked)
288 removed = old_marked - new_marked
289 added = new_marked - old_marked
293 self.mutableList.removeService(eServiceReference(x))
296 self.mutableList.addService(eServiceReference(x))
298 self.mutableList.flushChanges()
301 self.bouquet_mark_edit = False
302 self.mutableList = None
303 self.instance.setTitle(self.saved_title)
304 self.saved_title = None
305 self.servicePath = self.savedPath[:]
307 self.setRoot(self.servicePath[len(self.servicePath)-1])
309 def clearMarks(self):
310 self.servicelist.clearMarks()
313 ref = self.servicelist.getCurrent()
314 if self.servicelist.isMarked(ref):
315 self.servicelist.removeMarked(ref)
317 self.servicelist.addMarked(ref)
319 def removeCurrentService(self):
320 ref = self.servicelist.getCurrent()
321 mutableList = self.getMutableList()
322 if ref.valid() and mutableList is not None:
323 if not mutableList.removeService(ref):
324 self.bouquetNumOffsetCache = { }
325 currentIndex = self.servicelist.getCurrentIndex()
326 self.servicelist.moveDown()
327 if self.servicelist.getCurrentIndex() == currentIndex:
329 mutableList.flushChanges() #FIXME dont flush on each single removed service
330 self.setRoot(self.getRoot())
331 self.servicelist.moveToIndex(currentIndex)
333 def addCurrentServiceToBouquet(self, dest):
334 mutableList = self.getMutableList(dest)
335 if not mutableList is None:
336 if not mutableList.addService(self.servicelist.getCurrent()):
337 self.bouquetNumOffsetCache = { }
338 mutableList.flushChanges()
341 def toggleMoveMode(self):
343 if self.entry_marked:
344 self.toggleMoveMarked() # unmark current entry
345 self.movemode = False
346 self.pathChangedDisabled = False # re-enable path change
347 self.mutableList.flushChanges() # FIXME add check if changes was made
348 self.mutableList = None
349 self.instance.setTitle(self.saved_title)
350 self.saved_title = None
351 if self.getRoot() == self.bouquet_root:
352 self.bouquetNumOffsetCache = { }
354 self.mutableList = self.getMutableList()
356 self.pathChangedDisabled = True # no path change allowed in movemode
357 self.saved_title = self.instance.getTitle()
358 new_title = self.saved_title
359 pos = self.saved_title.find(')')
360 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
361 self.instance.setTitle(new_title);
363 def handleEditCancel(self):
364 if self.movemode: #movemode active?
365 self.channelSelected() # unmark
366 self.toggleMoveMode() # disable move mode
367 elif self.bouquet_mark_edit:
368 self.endMarkedEdit(True) # abort edit mode
370 def toggleMoveMarked(self):
371 if self.entry_marked:
372 self.servicelist.setCurrentMarked(False)
373 self.entry_marked = False
375 self.servicelist.setCurrentMarked(True)
376 self.entry_marked = True
379 self.session.open(ChannelContextMenu, self)
384 class ChannelSelectionBase(Screen):
385 def __init__(self, session):
386 Screen.__init__(self, session)
388 # this makes it much simple to implement a selectable radio or tv mode :)
389 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
390 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
392 self["key_red"] = Button(_("All"))
393 self["key_green"] = Button(_("Satellites"))
394 self["key_yellow"] = Button(_("Provider"))
395 self["key_blue"] = Button(_("Favourites"))
397 self["list"] = ServiceList()
398 self.servicelist = self["list"]
400 self.numericalTextInput = NumericalTextInput()
402 self.servicePathTV = [ ]
403 self.servicePathRadio = [ ]
404 self.servicePath = None
406 self.pathChangedDisabled = False
408 self.bouquetNumOffsetCache = { }
410 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
412 "showFavourites": self.showFavourites,
413 "showAllServices": self.showAllServices,
414 "showProviders": self.showProviders,
415 "showSatellites": self.showSatellites,
416 "nextBouquet": self.nextBouquet,
417 "prevBouquet": self.prevBouquet,
418 "1": self.keyNumberGlobal,
419 "2": self.keyNumberGlobal,
420 "3": self.keyNumberGlobal,
421 "4": self.keyNumberGlobal,
422 "5": self.keyNumberGlobal,
423 "6": self.keyNumberGlobal,
424 "7": self.keyNumberGlobal,
425 "8": self.keyNumberGlobal,
426 "9": self.keyNumberGlobal,
427 "0": self.keyNumberGlobal
430 def appendDVBTypes(self, ref):
432 pos = path.find(' FROM BOUQUET')
434 return eServiceReference(self.service_types + path[pos:])
437 def getBouquetNumOffset(self, bouquet):
438 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
440 bouquet = self.appendDVBTypes(bouquet)
442 return self.bouquetNumOffsetCache[bouquet.toString()]
445 serviceHandler = eServiceCenter.getInstance()
446 bouquetlist = serviceHandler.list(self.bouquet_root)
447 if not bouquetlist is None:
449 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
450 if not bouquetIterator.valid(): #end of list
452 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
453 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
455 servicelist = serviceHandler.list(bouquetIterator)
456 if not servicelist is None:
458 serviceIterator = servicelist.getNext()
459 if not serviceIterator.valid(): #check if end of list
461 if serviceIterator.flags: #playable services have no flags
464 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
466 def recallBouquetMode(self):
467 if self.mode == MODE_TV:
468 self.service_types = self.service_types_tv
469 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
470 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
472 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
474 self.service_types = self.service_types_radio
475 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
476 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
478 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
479 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
483 self.servicePath = self.servicePathTV
484 self.recallBouquetMode()
485 title = self.instance.getTitle()
486 pos = title.find(" (")
490 self.instance.setTitle(title)
492 def setRadioMode(self):
493 self.mode = MODE_RADIO
494 self.servicePath = self.servicePathRadio
495 self.recallBouquetMode()
496 title = self.instance.getTitle()
497 pos = title.find(" (")
501 self.instance.setTitle(title)
503 def setRoot(self, root, justSet=False):
504 path = root.getPath()
505 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
506 pos = path.find(' FROM BOUQUET')
507 isBouquet = pos != -1
508 if not inBouquetRootList and isBouquet:
509 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
510 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
511 refstr = self.service_types + path[pos:]
512 root = eServiceReference(refstr)
514 self.servicelist.setMode(ServiceList.MODE_NORMAL)
515 self.servicelist.setRoot(root, justSet)
516 self.buildTitleString()
518 def removeModeStr(self, str):
519 if self.mode == MODE_TV:
520 pos = str.find(' (TV)')
522 pos = str.find(' (Radio)')
527 def getServiceName(self, ref):
528 str = self.removeModeStr(ServiceReference(ref).getServiceName())
530 pathstr = ref.getPath()
531 if pathstr.find('FROM PROVIDERS') != -1:
533 if pathstr.find('FROM SATELLITES') != -1:
534 return _("Satellites")
535 if pathstr.find(') ORDER BY name') != -1:
539 def buildTitleString(self):
540 titleStr = self.instance.getTitle()
541 pos = titleStr.find(']')
543 pos = titleStr.find(')')
545 titleStr = titleStr[:pos+1]
546 Len = len(self.servicePath)
548 base_ref = self.servicePath[0]
550 end_ref = self.servicePath[Len-1]
553 nameStr = self.getServiceName(base_ref)
554 titleStr += ' ' + nameStr
555 if end_ref is not None:
560 nameStr = self.getServiceName(end_ref)
562 self.instance.setTitle(titleStr)
565 self.servicelist.moveUp()
568 self.servicelist.moveDown()
571 del self.servicePath[:]
573 def enterPath(self, ref, justSet=False):
574 self.servicePath.append(ref)
575 self.setRoot(ref, justSet)
577 def pathUp(self, justSet=False):
578 prev = self.servicePath.pop()
579 length = len(self.servicePath)
581 current = self.servicePath[length-1]
582 self.setRoot(current, justSet)
584 self.setCurrentSelection(prev)
587 def isBasePathEqual(self, ref):
588 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
592 def isPrevPathEqual(self, ref):
593 length = len(self.servicePath)
594 if length > 1 and self.servicePath[length-2] == ref:
598 def preEnterPath(self, refstr):
601 def showAllServices(self):
602 if not self.pathChangedDisabled:
603 refstr = '%s ORDER BY name'%(self.service_types)
604 if not self.preEnterPath(refstr):
605 ref = eServiceReference(refstr)
606 currentRoot = self.getRoot()
607 if currentRoot is None or currentRoot != ref:
611 def showSatellites(self):
612 if not self.pathChangedDisabled:
613 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
614 if not self.preEnterPath(refstr):
615 ref = eServiceReference(refstr)
619 if self.isBasePathEqual(ref):
620 if self.isPrevPathEqual(ref):
622 prev = self.pathUp(justSet)
624 currentRoot = self.getRoot()
625 if currentRoot is None or currentRoot != ref:
628 self.enterPath(ref, True)
630 serviceHandler = eServiceCenter.getInstance()
631 servicelist = serviceHandler.list(ref)
632 if not servicelist is None:
634 service = servicelist.getNext()
635 if not service.valid(): #check if end of list
637 orbpos = service.getData(4) >> 16
638 if service.getPath().find("FROM PROVIDER") != -1:
639 service_name = _("Providers")
641 service_name = _("Services")
643 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
644 service.setName(service_name) # why we need this cast?
646 if orbpos > 1800: # west
647 service.setName("%s (%3.1f" + _("W") + ")" %(str, (0 - (orbpos - 3600)) / 10.0))
649 service.setName("%s (%3.1f" + _("E") + ")" % (str, orbpos / 10.0))
650 self.servicelist.addService(service)
651 self.servicelist.finishFill()
653 self.setCurrentSelection(prev)
655 def showProviders(self):
656 if not self.pathChangedDisabled:
657 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
658 if not self.preEnterPath(refstr):
659 ref = eServiceReference(refstr)
660 if self.isBasePathEqual(ref):
663 currentRoot = self.getRoot()
664 if currentRoot is None or currentRoot != ref:
668 def changeBouquet(self, direction):
669 if not self.pathChangedDisabled:
670 if self.isBasePathEqual(self.bouquet_root):
676 ref = self.getCurrentSelection()
680 return self.isBasePathEqual(self.bouquet_root)
683 return self.servicelist.atBegin()
686 return self.servicelist.atEnd()
688 def nextBouquet(self):
689 self.changeBouquet(+1)
691 def prevBouquet(self):
692 self.changeBouquet(-1)
694 def showFavourites(self):
695 if not self.pathChangedDisabled:
696 if not self.preEnterPath(self.bouquet_rootstr):
697 if self.isBasePathEqual(self.bouquet_root):
700 currentRoot = self.getRoot()
701 if currentRoot is None or currentRoot != self.bouquet_root:
703 self.enterPath(self.bouquet_root)
705 def keyNumberGlobal(self, number):
706 char = self.numericalTextInput.getKey(number)
707 self.servicelist.moveToChar(char)
710 return self.servicelist.getRoot()
712 def getCurrentSelection(self):
713 return self.servicelist.getCurrent()
715 def setCurrentSelection(self, service):
716 servicepath = service.getPath()
717 pos = servicepath.find(" FROM BOUQUET")
719 if self.mode == MODE_TV:
720 servicepath = '(type == 1)' + servicepath[pos:]
722 servicepath = '(type == 2)' + servicepath[pos:]
723 service.setPath(servicepath)
724 self.servicelist.setCurrent(service)
726 def getBouquetList(self):
729 serviceHandler = eServiceCenter.getInstance()
730 list = serviceHandler.list(self.bouquet_root)
736 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
737 info = serviceHandler.info(s)
739 bouquets.append((info.getName(s), s))
742 if len(bouquets) == 0 and serviceCount > 0:
743 info = serviceHandler.info(self.bouquet_root)
745 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
751 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
752 def __init__(self, session):
753 ChannelSelectionBase.__init__(self,session)
754 ChannelSelectionEdit.__init__(self)
755 ChannelSelectionEPG.__init__(self)
757 #config for lastservice
758 config.tv = ConfigSubsection();
759 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
760 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
761 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
762 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
764 self["actions"] = ActionMap(["OkCancelActions"],
766 "cancel": self.cancel,
767 "ok": self.channelSelected,
769 self.onShown.append(self.__onShown)
771 self.lastChannelRootTimer = eTimer()
772 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
773 self.lastChannelRootTimer.start(100,True)
778 def __onCreate(self):
781 lastservice=eServiceReference(config.tv.lastservice.value)
782 if lastservice.valid():
783 self.setCurrentSelection(lastservice)
787 self.recallBouquetMode()
788 ref = self.session.nav.getCurrentlyPlayingServiceReference()
789 if ref is not None and ref.valid() and ref.getPath() == "":
790 self.servicelist.setPlayableIgnoreService(ref)
792 self.servicelist.setPlayableIgnoreService(eServiceReference())
794 def channelSelected(self):
795 ref = self.getCurrentSelection()
797 self.toggleMoveMarked()
798 elif (ref.flags & 7) == 7:
800 elif self.bouquet_mark_edit:
806 #called from infoBar and channelSelected
808 ref = self.session.nav.getCurrentlyPlayingServiceReference()
809 nref = self.getCurrentSelection()
810 if ref is None or ref != nref:
811 self.session.nav.playService(nref)
814 tmp=self.servicePath[:]
817 del self.history[self.history_pos+1:]
820 self.history.append(tmp)
821 hlen = len(self.history)
822 if hlen > HISTORYSIZE:
825 self.history_pos = hlen-1
827 def historyBack(self):
828 hlen = len(self.history)
829 if hlen > 1 and self.history_pos > 0:
830 self.history_pos -= 1
831 self.setHistoryPath()
833 def historyNext(self):
834 hlen = len(self.history)
835 if hlen > 1 and self.history_pos < (hlen-1):
836 self.history_pos += 1
837 self.setHistoryPath()
839 def setHistoryPath(self):
840 path = self.history[self.history_pos][:]
842 self.servicePath = path
846 if self.getRoot() != root:
848 self.session.nav.playService(ref)
849 self.setCurrentSelection(ref)
854 for i in self.servicePathTV:
857 if config.tv.prevroot.value != config.tv.lastroot.value:
858 config.tv.prevroot.value = config.tv.lastroot.value
859 config.tv.prevroot.save()
860 if len(path) and path != config.tv.lastroot.value:
861 config.tv.lastroot.value = path
862 config.tv.lastroot.save()
864 def restoreRoot(self):
867 tmp = re.findall(config.tv.lastroot.value)
870 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
873 path = self.servicePathTV.pop()
876 self.showFavourites()
879 def preEnterPath(self, refstr):
880 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
881 pathstr = config.tv.lastroot.value
882 if pathstr is not None and pathstr.find(refstr) == 0:
884 lastservice=eServiceReference(config.tv.lastservice.value)
885 if lastservice is not None:
886 self.setCurrentSelection(lastservice)
890 def saveChannel(self):
891 ref = self.session.nav.getCurrentlyPlayingServiceReference()
893 refstr = ref.toString()
896 if refstr != config.tv.lastservice.value:
897 config.tv.prevservice.value = config.tv.lastservice.value
898 config.tv.prevservice.save()
899 config.tv.lastservice.value = refstr
900 config.tv.lastservice.save()
902 def recallPrevService(self):
903 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
904 if config.tv.lastroot.value != config.tv.prevroot.value:
905 tmp = config.tv.lastroot.value
906 config.tv.lastroot.value = config.tv.prevroot.value
907 config.tv.lastroot.save()
908 config.tv.prevroot.value = tmp
909 config.tv.prevroot.save()
911 if config.tv.lastservice.value != config.tv.prevservice.value:
912 tmp = config.tv.lastservice.value
913 config.tv.lastservice.value = config.tv.prevservice.value
914 config.tv.lastservice.save()
915 config.tv.prevservice.value = tmp
916 config.tv.prevservice.save()
917 lastservice=eServiceReference(config.tv.lastservice.value)
918 self.session.nav.playService(lastservice)
919 self.setCurrentSelection(lastservice)
924 lastservice=eServiceReference(config.tv.lastservice.value)
925 if lastservice.valid() and self.getCurrentSelection() != lastservice:
926 self.setCurrentSelection(lastservice)
928 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
930 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
931 def __init__(self, session):
932 Screen.__init__(self, session)
933 InfoBarEvent.__init__(self)
934 InfoBarServiceName.__init__(self)
935 InfoBarInstantRecord.__init__(self)
936 self["Clock"] = Clock()
938 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
939 def __init__(self, session):
940 ChannelSelectionBase.__init__(self, session)
941 ChannelSelectionEdit.__init__(self)
942 ChannelSelectionEPG.__init__(self)
944 config.radio = ConfigSubsection();
945 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
946 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
947 self.onLayoutFinish.append(self.onCreate)
949 self.info = session.instantiateDialog(RadioInfoBar)
951 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
953 "keyTV": self.closeRadio,
954 "keyRadio": self.closeRadio,
955 "cancel": self.closeRadio,
956 "ok": self.channelSelected,
961 for i in self.servicePathRadio:
964 if len(path) and path != config.radio.lastroot.value:
965 config.radio.lastroot.value = path
966 config.radio.lastroot.save()
968 def restoreRoot(self):
971 tmp = re.findall(config.radio.lastroot.value)
974 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
977 path = self.servicePathRadio.pop()
980 self.showFavourites()
983 def preEnterPath(self, refstr):
984 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
985 pathstr = config.radio.lastroot.value
986 if pathstr is not None and pathstr.find(refstr) == 0:
988 lastservice=eServiceReference(config.radio.lastservice.value)
989 if lastservice is not None:
990 self.setCurrentSelection(lastservice)
997 lastservice=eServiceReference(config.radio.lastservice.value)
998 if lastservice.valid():
999 self.servicelist.setCurrent(lastservice)
1000 self.session.nav.playService(lastservice)
1001 self.servicelist.setPlayableIgnoreService(lastservice)
1004 def channelSelected(self): # just return selected service
1005 ref = self.getCurrentSelection()
1007 self.toggleMoveMarked()
1008 elif (ref.flags & 7) == 7:
1010 elif self.bouquet_mark_edit:
1013 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1014 if playingref is None or playingref != ref:
1015 self.session.nav.playService(ref)
1016 self.servicelist.setPlayableIgnoreService(ref)
1017 config.radio.lastservice.value = ref.toString()
1018 config.radio.lastservice.save()
1021 def closeRadio(self):
1023 #set previous tv service
1024 lastservice=eServiceReference(config.tv.lastservice.value)
1025 self.session.nav.playService(lastservice)
1028 class SimpleChannelSelection(ChannelSelectionBase):
1029 def __init__(self, session, title):
1030 ChannelSelectionBase.__init__(self, session)
1032 self.onShown.append(self.__onExecCallback)
1034 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1036 "cancel": self.close,
1037 "ok": self.channelSelected,
1038 "keyRadio": self.setModeRadio,
1039 "keyTV": self.setModeTv,
1042 def __onExecCallback(self):
1043 self.session.currentDialog.instance.setTitle(self.title)
1046 def channelSelected(self): # just return selected service
1047 ref = self.getCurrentSelection()
1048 if (ref.flags & 7) == 7:
1051 ref = self.getCurrentSelection()
1054 def setModeTv(self):
1056 self.showFavourites()
1058 def setModeRadio(self):
1060 self.showFavourites()