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 Components.Input import Input
16 from Screens.InputBox import InputBox
17 from ServiceReference import ServiceReference
21 import xml.dom.minidom
23 class BouquetSelector(Screen):
24 def __init__(self, session, bouquets, selectedFunc):
25 Screen.__init__(self, session)
27 self.selectedFunc=selectedFunc
29 self["actions"] = ActionMap(["OkCancelActions"],
31 "ok": self.okbuttonClick,
32 "cancel": self.cancelClick
36 entrys.append((x[0], x[1]))
37 self["menu"] = MenuList(entrys)
39 def okbuttonClick(self):
40 self.selectedFunc(self["menu"].getCurrent()[1])
42 def cancelClick(self):
45 class ChannelContextMenu(Screen):
46 def __init__(self, session, csel):
47 Screen.__init__(self, session)
50 self["actions"] = ActionMap(["OkCancelActions"],
52 "ok": self.okbuttonClick,
53 "cancel": self.cancelClick
57 inBouquetRootList = csel.getRoot().getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
58 inBouquet = csel.getMutableList() is not None
59 haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
61 if not csel.bouquet_mark_edit and not csel.movemode:
62 if not inBouquetRootList:
63 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
65 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
67 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
69 if not inBouquet and csel.getCurrentSelection().getPath().find("PROVIDERS") == -1:
70 menu.append((_("copy to favourites"), csel.copyCurrentToBouquetList))
72 menu.append((_("remove service"), self.removeCurrentService))
74 menu.append((_("remove bouquet"), csel.removeBouquet))
76 if inBouquet: # current list is editable?
77 if not csel.bouquet_mark_edit:
79 menu.append((_("enable move mode"), self.toggleMoveMode))
80 menu.append((_("add bouquet..."), self.showBouquetInputBox))
81 if not inBouquetRootList:
83 menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
85 menu.append((_("enable favourite edit"), self.bouquetMarkStart))
87 menu.append((_("disable move mode"), self.toggleMoveMode))
88 elif not inBouquetRootList:
90 menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
91 menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
93 menu.append((_("end favourites edit"), self.bouquetMarkEnd))
94 menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
96 menu.append((_("back"), self.cancelClick))
97 self["menu"] = MenuList(menu)
99 def okbuttonClick(self):
100 self["menu"].getCurrent()[1]()
102 def cancelClick(self):
105 def showBouquetInputBox(self):
106 self.session.openWithCallback(self.bouquetInputCallback, InputBox, title=_("Please enter a name for the new bouquet"), text="bouquetname", maxSize=False, type=Input.TEXT)
108 def bouquetInputCallback(self, bouquet):
109 if bouquet is not None:
110 self.csel.addBouquet(bouquet)
112 def addServiceToBouquetSelected(self):
113 bouquets = self.csel.getBouquetList()
118 if cnt > 1: # show bouquet list
119 self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
120 elif cnt == 1: # add to only one existing bouquet
121 self.addCurrentServiceToBouquet(bouquets[0][1])
122 else: #no bouquets in root.. so assume only one favourite list is used
123 self.addCurrentServiceToBouquet(self.csel.bouquet_root)
125 def bouquetSelClosed(self, recursive):
129 def copyCurrentToBouquetList(self):
130 self.csel.copyCurrentToBouquetList()
133 def removeBouquet(self):
134 self.csel.removeBouquet()
137 def addCurrentServiceToBouquet(self, dest):
138 self.csel.addCurrentServiceToBouquet(dest)
139 self.close(True) # close bouquet selection
141 def removeCurrentService(self):
142 self.csel.removeCurrentService()
145 def toggleMoveMode(self):
146 self.csel.toggleMoveMode()
149 def bouquetMarkStart(self):
150 self.csel.startMarkedEdit()
153 def bouquetMarkEnd(self):
154 self.csel.endMarkedEdit(abort=False)
157 def bouquetMarkAbort(self):
158 self.csel.endMarkedEdit(abort=True)
161 class ChannelSelectionEPG:
163 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
165 "showEPGList": self.showEPGList,
168 def showEPGList(self):
169 ref=self.getCurrentSelection()
170 ptr=eEPGCache.getInstance()
171 if ptr.startTimeQuery(ref) != -1:
172 self.session.open(EPGSelection, ref)
174 print 'no epg for service', ref.toString()
176 class ChannelSelectionEdit:
178 self.entry_marked = False
179 self.movemode = False
180 self.bouquet_mark_edit = False
181 self.mutableList = None
183 self.saved_title = None
184 self.saved_root = None
186 class ChannelSelectionEditActionMap(ActionMap):
187 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
188 ActionMap.__init__(self, contexts, actions, prio)
190 def action(self, contexts, action):
191 if action == "cancel":
192 self.csel.handleEditCancel()
194 pass # avoid typo warning...
196 ActionMap.action(self, contexts, action)
197 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
199 "contextMenu": self.doContext,
202 def getMutableList(self, root=eServiceReference()):
203 if not self.mutableList is None:
204 return self.mutableList
205 serviceHandler = eServiceCenter.getInstance()
208 list = serviceHandler.list(root)
210 return list.startEdit()
213 def buildBouquetID(self, str):
217 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
223 def addBouquet(self, providerName):
224 serviceHandler = eServiceCenter.getInstance()
225 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
226 if mutableBouquetList:
227 if self.mode == MODE_TV:
228 providerName += " (TV)"
229 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
231 providerName += " (Radio)"
232 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
233 new_bouquet_ref = eServiceReference(str)
234 if not mutableBouquetList.addService(new_bouquet_ref):
235 self.bouquetNumOffsetCache = { }
236 mutableBouquetList.flushChanges()
237 eDVBDB.getInstance().reloadBouquets()
238 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
240 mutableBouquet.setListName(providerName)
241 mutableBouquet.flushChanges()
242 self.setRoot(self.getRoot())
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 copyCurrentToBouquetList(self):
251 provider = ServiceReference(self.getCurrentSelection())
252 serviceHandler = eServiceCenter.getInstance()
253 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
254 if mutableBouquetList:
255 providerName = provider.getServiceName()
256 if self.mode == MODE_TV:
257 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
259 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
260 new_bouquet_ref = eServiceReference(str)
261 if not mutableBouquetList.addService(new_bouquet_ref):
262 self.bouquetNumOffsetCache = { }
263 mutableBouquetList.flushChanges()
264 eDVBDB.getInstance().reloadBouquets()
265 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
267 mutableBouquet.setListName(providerName)
269 services = serviceHandler.list(provider.ref)
270 if not services is None:
271 if not services.getContent(list, True):
273 if mutableBouquet.addService(service):
274 print "add", service.toString(), "to new bouquet failed"
275 mutableBouquet.flushChanges()
277 print "getContent failed"
279 print "list provider", providerName, "failed"
281 print "get mutable list for new created bouquet failed"
283 print "add", str, "to bouquets failed"
285 print "bouquetlist is not editable"
287 def removeBouquet(self):
288 refstr = self.getCurrentSelection().toString()
289 self.bouquetNumOffsetCache = { }
290 pos = refstr.find('FROM BOUQUET "')
292 refstr = refstr[pos+14:]
293 pos = refstr.find('"')
295 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
296 self.removeCurrentService()
298 eDVBDB.getInstance().reloadBouquets()
300 # multiple marked entry stuff ( edit mode, later multiepg selection )
301 def startMarkedEdit(self):
302 self.mutableList = self.getMutableList()
303 # add all services from the current list to internal marked set in listboxservicecontent
304 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
305 self.saved_title = self.instance.getTitle()
306 pos = self.saved_title.find(')')
307 new_title = self.saved_title[:pos+1]
308 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
309 new_title += ' ' + _("[bouquet edit]")
311 new_title += ' ' + _("[favourite edit]")
312 self.setTitle(new_title)
313 self.bouquet_mark_edit = True
314 self.__marked = self.servicelist.getRootServices()
315 for x in self.__marked:
316 self.servicelist.addMarked(eServiceReference(x))
317 self.savedPath = self.servicePath[:]
318 self.showAllServices()
320 def endMarkedEdit(self, abort):
321 if not abort and self.mutableList is not None:
322 self.bouquetNumOffsetCache = { }
323 new_marked = set(self.servicelist.getMarked())
324 old_marked = set(self.__marked)
325 removed = old_marked - new_marked
326 added = new_marked - old_marked
330 self.mutableList.removeService(eServiceReference(x))
333 self.mutableList.addService(eServiceReference(x))
335 self.mutableList.flushChanges()
338 self.bouquet_mark_edit = False
339 self.mutableList = None
340 self.setTitle(self.saved_title)
341 self.saved_title = None
342 self.servicePath = self.savedPath[:]
344 self.setRoot(self.servicePath[len(self.servicePath)-1])
346 def clearMarks(self):
347 self.servicelist.clearMarks()
350 ref = self.servicelist.getCurrent()
351 if self.servicelist.isMarked(ref):
352 self.servicelist.removeMarked(ref)
354 self.servicelist.addMarked(ref)
356 def removeCurrentService(self):
357 ref = self.servicelist.getCurrent()
358 mutableList = self.getMutableList()
359 if ref.valid() and mutableList is not None:
360 if not mutableList.removeService(ref):
361 self.bouquetNumOffsetCache = { }
362 mutableList.flushChanges() #FIXME dont flush on each single removed service
363 self.setRoot(self.getRoot())
365 def addCurrentServiceToBouquet(self, dest):
366 mutableList = self.getMutableList(dest)
367 if not mutableList is None:
368 if not mutableList.addService(self.servicelist.getCurrent()):
369 self.bouquetNumOffsetCache = { }
370 mutableList.flushChanges()
373 def toggleMoveMode(self):
375 if self.entry_marked:
376 self.toggleMoveMarked() # unmark current entry
377 self.movemode = False
378 self.pathChangedDisabled = False # re-enable path change
379 self.mutableList.flushChanges() # FIXME add check if changes was made
380 self.mutableList = None
381 self.setTitle(self.saved_title)
382 self.saved_title = None
383 if self.getRoot() == self.bouquet_root:
384 self.bouquetNumOffsetCache = { }
386 self.mutableList = self.getMutableList()
388 self.pathChangedDisabled = True # no path change allowed in movemode
389 self.saved_title = self.instance.getTitle()
390 new_title = self.saved_title
391 pos = self.saved_title.find(')')
392 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
393 self.setTitle(new_title);
395 def handleEditCancel(self):
396 if self.movemode: #movemode active?
397 self.channelSelected() # unmark
398 self.toggleMoveMode() # disable move mode
399 elif self.bouquet_mark_edit:
400 self.endMarkedEdit(True) # abort edit mode
402 def toggleMoveMarked(self):
403 if self.entry_marked:
404 self.servicelist.setCurrentMarked(False)
405 self.entry_marked = False
407 self.servicelist.setCurrentMarked(True)
408 self.entry_marked = True
411 self.session.open(ChannelContextMenu, self)
416 class ChannelSelectionBase(Screen):
417 def __init__(self, session):
418 Screen.__init__(self, session)
420 # this makes it much simple to implement a selectable radio or tv mode :)
421 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
422 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
424 self["key_red"] = Button(_("All"))
425 self["key_green"] = Button(_("Satellites"))
426 self["key_yellow"] = Button(_("Provider"))
427 self["key_blue"] = Button(_("Favourites"))
429 self["list"] = ServiceList()
430 self.servicelist = self["list"]
432 self.numericalTextInput = NumericalTextInput()
434 self.servicePathTV = [ ]
435 self.servicePathRadio = [ ]
436 self.servicePath = None
438 self.pathChangedDisabled = False
440 self.bouquetNumOffsetCache = { }
442 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
444 "showFavourites": self.showFavourites,
445 "showAllServices": self.showAllServices,
446 "showProviders": self.showProviders,
447 "showSatellites": self.showSatellites,
448 "nextBouquet": self.nextBouquet,
449 "prevBouquet": self.prevBouquet,
450 "1": self.keyNumberGlobal,
451 "2": self.keyNumberGlobal,
452 "3": self.keyNumberGlobal,
453 "4": self.keyNumberGlobal,
454 "5": self.keyNumberGlobal,
455 "6": self.keyNumberGlobal,
456 "7": self.keyNumberGlobal,
457 "8": self.keyNumberGlobal,
458 "9": self.keyNumberGlobal,
459 "0": self.keyNumberGlobal
462 def appendDVBTypes(self, ref):
464 pos = path.find(' FROM BOUQUET')
466 return eServiceReference(self.service_types + path[pos:])
469 def getBouquetNumOffset(self, bouquet):
470 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
472 bouquet = self.appendDVBTypes(bouquet)
474 return self.bouquetNumOffsetCache[bouquet.toString()]
477 serviceHandler = eServiceCenter.getInstance()
478 bouquetlist = serviceHandler.list(self.bouquet_root)
479 if not bouquetlist is None:
481 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
482 if not bouquetIterator.valid(): #end of list
484 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
485 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
487 servicelist = serviceHandler.list(bouquetIterator)
488 if not servicelist is None:
490 serviceIterator = servicelist.getNext()
491 if not serviceIterator.valid(): #check if end of list
493 if serviceIterator.flags: #playable services have no flags
496 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
498 def recallBouquetMode(self):
499 if self.mode == MODE_TV:
500 self.service_types = self.service_types_tv
501 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
502 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
504 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
506 self.service_types = self.service_types_radio
507 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
508 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
510 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
511 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
515 self.servicePath = self.servicePathTV
516 self.recallBouquetMode()
517 title = self.instance.getTitle()
518 pos = title.find(" (")
524 def setRadioMode(self):
525 self.mode = MODE_RADIO
526 self.servicePath = self.servicePathRadio
527 self.recallBouquetMode()
528 title = self.instance.getTitle()
529 pos = title.find(" (")
535 def setRoot(self, root, justSet=False):
536 path = root.getPath()
537 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
538 pos = path.find(' FROM BOUQUET')
539 isBouquet = pos != -1
540 if not inBouquetRootList and isBouquet:
541 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
542 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
543 refstr = self.service_types + path[pos:]
544 root = eServiceReference(refstr)
546 self.servicelist.setMode(ServiceList.MODE_NORMAL)
547 self.servicelist.setRoot(root, justSet)
548 self.buildTitleString()
550 def removeModeStr(self, str):
551 if self.mode == MODE_TV:
552 pos = str.find(' (TV)')
554 pos = str.find(' (Radio)')
559 def getServiceName(self, ref):
560 str = self.removeModeStr(ServiceReference(ref).getServiceName())
562 pathstr = ref.getPath()
563 if pathstr.find('FROM PROVIDERS') != -1:
565 if pathstr.find('FROM SATELLITES') != -1:
566 return _("Satellites")
567 if pathstr.find(') ORDER BY name') != -1:
571 def buildTitleString(self):
572 titleStr = self.instance.getTitle()
573 pos = titleStr.find(']')
575 pos = titleStr.find(')')
577 titleStr = titleStr[:pos+1]
578 Len = len(self.servicePath)
580 base_ref = self.servicePath[0]
582 end_ref = self.servicePath[Len-1]
585 nameStr = self.getServiceName(base_ref)
586 titleStr += ' ' + nameStr
587 if end_ref is not None:
592 nameStr = self.getServiceName(end_ref)
594 self.setTitle(titleStr)
597 self.servicelist.moveUp()
600 self.servicelist.moveDown()
603 del self.servicePath[:]
605 def enterPath(self, ref, justSet=False):
606 self.servicePath.append(ref)
607 self.setRoot(ref, justSet)
609 def pathUp(self, justSet=False):
610 prev = self.servicePath.pop()
611 length = len(self.servicePath)
613 current = self.servicePath[length-1]
614 self.setRoot(current, justSet)
616 self.setCurrentSelection(prev)
619 def isBasePathEqual(self, ref):
620 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
624 def isPrevPathEqual(self, ref):
625 length = len(self.servicePath)
626 if length > 1 and self.servicePath[length-2] == ref:
630 def preEnterPath(self, refstr):
633 def showAllServices(self):
634 if not self.pathChangedDisabled:
635 refstr = '%s ORDER BY name'%(self.service_types)
636 if not self.preEnterPath(refstr):
637 ref = eServiceReference(refstr)
638 currentRoot = self.getRoot()
639 if currentRoot is None or currentRoot != ref:
643 def showSatellites(self):
644 if not self.pathChangedDisabled:
645 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
646 if not self.preEnterPath(refstr):
647 ref = eServiceReference(refstr)
651 if self.isBasePathEqual(ref):
652 if self.isPrevPathEqual(ref):
654 prev = self.pathUp(justSet)
656 currentRoot = self.getRoot()
657 if currentRoot is None or currentRoot != ref:
660 self.enterPath(ref, True)
662 serviceHandler = eServiceCenter.getInstance()
663 servicelist = serviceHandler.list(ref)
664 if not servicelist is None:
666 service = servicelist.getNext()
667 if not service.valid(): #check if end of list
669 orbpos = service.getData(4) >> 16
670 if service.getPath().find("FROM PROVIDER") != -1:
671 service_name = _("Providers")
673 service_name = _("Services")
675 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
676 service.setName(service_name) # why we need this cast?
678 if orbpos > 1800: # west
679 orbpos = 3600 - orbpos
683 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
685 self.servicelist.addService(service)
686 self.servicelist.finishFill()
688 self.setCurrentSelection(prev)
690 def showProviders(self):
691 if not self.pathChangedDisabled:
692 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
693 if not self.preEnterPath(refstr):
694 ref = eServiceReference(refstr)
695 if self.isBasePathEqual(ref):
698 currentRoot = self.getRoot()
699 if currentRoot is None or currentRoot != ref:
703 def changeBouquet(self, direction):
704 if not self.pathChangedDisabled:
705 if self.isBasePathEqual(self.bouquet_root):
711 ref = self.getCurrentSelection()
715 return self.isBasePathEqual(self.bouquet_root)
718 return self.servicelist.atBegin()
721 return self.servicelist.atEnd()
723 def nextBouquet(self):
724 self.changeBouquet(+1)
726 def prevBouquet(self):
727 self.changeBouquet(-1)
729 def showFavourites(self):
730 if not self.pathChangedDisabled:
731 if not self.preEnterPath(self.bouquet_rootstr):
732 if self.isBasePathEqual(self.bouquet_root):
735 currentRoot = self.getRoot()
736 if currentRoot is None or currentRoot != self.bouquet_root:
738 self.enterPath(self.bouquet_root)
740 def keyNumberGlobal(self, number):
741 char = self.numericalTextInput.getKey(number)
742 self.servicelist.moveToChar(char)
745 return self.servicelist.getRoot()
747 def getCurrentSelection(self):
748 return self.servicelist.getCurrent()
750 def setCurrentSelection(self, service):
751 servicepath = service.getPath()
752 pos = servicepath.find(" FROM BOUQUET")
754 if self.mode == MODE_TV:
755 servicepath = '(type == 1)' + servicepath[pos:]
757 servicepath = '(type == 2)' + servicepath[pos:]
758 service.setPath(servicepath)
759 self.servicelist.setCurrent(service)
761 def getBouquetList(self):
764 serviceHandler = eServiceCenter.getInstance()
765 list = serviceHandler.list(self.bouquet_root)
771 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
772 info = serviceHandler.info(s)
774 bouquets.append((info.getName(s), s))
777 if len(bouquets) == 0 and serviceCount > 0:
778 info = serviceHandler.info(self.bouquet_root)
780 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
786 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
787 def __init__(self, session):
788 ChannelSelectionBase.__init__(self,session)
789 ChannelSelectionEdit.__init__(self)
790 ChannelSelectionEPG.__init__(self)
792 #config for lastservice
793 config.tv = ConfigSubsection();
794 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
795 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
796 config.tv.prevservice = configElement("config.tv.prevservice", configText, "", 0);
797 config.tv.prevroot = configElement("config.tv.prevroot", configText, "", 0);
799 self["actions"] = ActionMap(["OkCancelActions"],
801 "cancel": self.cancel,
802 "ok": self.channelSelected,
804 self.onShown.append(self.__onShown)
806 self.lastChannelRootTimer = eTimer()
807 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
808 self.lastChannelRootTimer.start(100,True)
813 def __onCreate(self):
816 lastservice=eServiceReference(config.tv.lastservice.value)
817 if lastservice.valid():
818 self.setCurrentSelection(lastservice)
822 self.recallBouquetMode()
823 ref = self.session.nav.getCurrentlyPlayingServiceReference()
824 if ref is not None and ref.valid() and ref.getPath() == "":
825 self.servicelist.setPlayableIgnoreService(ref)
827 self.servicelist.setPlayableIgnoreService(eServiceReference())
829 def channelSelected(self):
830 ref = self.getCurrentSelection()
832 self.toggleMoveMarked()
833 elif (ref.flags & 7) == 7:
835 elif self.bouquet_mark_edit:
841 #called from infoBar and channelSelected
843 ref = self.session.nav.getCurrentlyPlayingServiceReference()
844 nref = self.getCurrentSelection()
845 if ref is None or ref != nref:
846 self.session.nav.playService(nref)
849 tmp=self.servicePath[:]
852 del self.history[self.history_pos+1:]
855 self.history.append(tmp)
856 hlen = len(self.history)
857 if hlen > HISTORYSIZE:
860 self.history_pos = hlen-1
862 def historyBack(self):
863 hlen = len(self.history)
864 if hlen > 1 and self.history_pos > 0:
865 self.history_pos -= 1
866 self.setHistoryPath()
868 def historyNext(self):
869 hlen = len(self.history)
870 if hlen > 1 and self.history_pos < (hlen-1):
871 self.history_pos += 1
872 self.setHistoryPath()
874 def setHistoryPath(self):
875 path = self.history[self.history_pos][:]
877 self.servicePath = path
881 if self.getRoot() != root:
883 self.session.nav.playService(ref)
884 self.setCurrentSelection(ref)
889 for i in self.servicePathTV:
892 if config.tv.prevroot.value != config.tv.lastroot.value:
893 config.tv.prevroot.value = config.tv.lastroot.value
894 config.tv.prevroot.save()
895 if len(path) and path != config.tv.lastroot.value:
896 config.tv.lastroot.value = path
897 config.tv.lastroot.save()
899 def restoreRoot(self):
902 tmp = re.findall(config.tv.lastroot.value)
905 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
908 path = self.servicePathTV.pop()
911 self.showFavourites()
914 def preEnterPath(self, refstr):
915 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
916 pathstr = config.tv.lastroot.value
917 if pathstr is not None and pathstr.find(refstr) == 0:
919 lastservice=eServiceReference(config.tv.lastservice.value)
920 if lastservice.valid():
921 self.setCurrentSelection(lastservice)
925 def saveChannel(self):
926 ref = self.session.nav.getCurrentlyPlayingServiceReference()
928 refstr = ref.toString()
931 if refstr != config.tv.lastservice.value:
932 config.tv.prevservice.value = config.tv.lastservice.value
933 config.tv.prevservice.save()
934 config.tv.lastservice.value = refstr
935 config.tv.lastservice.save()
937 def recallPrevService(self):
938 if len(config.tv.prevservice.value) and len(config.tv.prevroot.value):
939 if config.tv.lastroot.value != config.tv.prevroot.value:
940 tmp = config.tv.lastroot.value
941 config.tv.lastroot.value = config.tv.prevroot.value
942 config.tv.lastroot.save()
943 config.tv.prevroot.value = tmp
944 config.tv.prevroot.save()
946 if config.tv.lastservice.value != config.tv.prevservice.value:
947 tmp = config.tv.lastservice.value
948 config.tv.lastservice.value = config.tv.prevservice.value
949 config.tv.lastservice.save()
950 config.tv.prevservice.value = tmp
951 config.tv.prevservice.save()
952 lastservice=eServiceReference(config.tv.lastservice.value)
953 self.session.nav.playService(lastservice)
954 self.setCurrentSelection(lastservice)
959 lastservice=eServiceReference(config.tv.lastservice.value)
960 if lastservice.valid() and self.getCurrentSelection() != lastservice:
961 self.setCurrentSelection(lastservice)
963 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
965 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
966 def __init__(self, session):
967 Screen.__init__(self, session)
968 InfoBarEvent.__init__(self)
969 InfoBarServiceName.__init__(self)
970 InfoBarInstantRecord.__init__(self)
971 self["Clock"] = Clock()
973 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
974 def __init__(self, session):
975 ChannelSelectionBase.__init__(self, session)
976 ChannelSelectionEdit.__init__(self)
977 ChannelSelectionEPG.__init__(self)
979 config.radio = ConfigSubsection();
980 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
981 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
982 self.onLayoutFinish.append(self.onCreate)
984 self.info = session.instantiateDialog(RadioInfoBar)
986 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
988 "keyTV": self.closeRadio,
989 "keyRadio": self.closeRadio,
990 "cancel": self.closeRadio,
991 "ok": self.channelSelected,
996 for i in self.servicePathRadio:
999 if len(path) and path != config.radio.lastroot.value:
1000 config.radio.lastroot.value = path
1001 config.radio.lastroot.save()
1003 def restoreRoot(self):
1005 re = compile('.+?;')
1006 tmp = re.findall(config.radio.lastroot.value)
1009 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1012 path = self.servicePathRadio.pop()
1013 self.enterPath(path)
1015 self.showFavourites()
1018 def preEnterPath(self, refstr):
1019 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1020 pathstr = config.radio.lastroot.value
1021 if pathstr is not None and pathstr.find(refstr) == 0:
1023 lastservice=eServiceReference(config.radio.lastservice.value)
1024 if lastservice.valid():
1025 self.setCurrentSelection(lastservice)
1032 lastservice=eServiceReference(config.radio.lastservice.value)
1033 if lastservice.valid():
1034 self.servicelist.setCurrent(lastservice)
1035 self.session.nav.playService(lastservice)
1036 self.servicelist.setPlayableIgnoreService(lastservice)
1039 def channelSelected(self): # just return selected service
1040 ref = self.getCurrentSelection()
1042 self.toggleMoveMarked()
1043 elif (ref.flags & 7) == 7:
1045 elif self.bouquet_mark_edit:
1048 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1049 if playingref is None or playingref != ref:
1050 self.session.nav.playService(ref)
1051 self.servicelist.setPlayableIgnoreService(ref)
1052 config.radio.lastservice.value = ref.toString()
1053 config.radio.lastservice.save()
1056 def closeRadio(self):
1058 #set previous tv service
1059 lastservice=eServiceReference(config.tv.lastservice.value)
1060 self.session.nav.playService(lastservice)
1063 class SimpleChannelSelection(ChannelSelectionBase):
1064 def __init__(self, session, title):
1065 ChannelSelectionBase.__init__(self, session)
1067 self.onShown.append(self.__onExecCallback)
1069 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1071 "cancel": self.close,
1072 "ok": self.channelSelected,
1073 "keyRadio": self.setModeRadio,
1074 "keyTV": self.setModeTv,
1077 def __onExecCallback(self):
1078 self.setTitle(self.title)
1081 def channelSelected(self): # just return selected service
1082 ref = self.getCurrentSelection()
1083 if (ref.flags & 7) == 7:
1086 ref = self.getCurrentSelection()
1089 def setModeTv(self):
1091 self.showFavourites()
1093 def setModeRadio(self):
1095 self.showFavourites()