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"), self.copyCurrentToBouquetList))
72 menu.append((_("remove service"), self.removeCurrentService))
74 menu.append((_("remove bouquet"), self.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)
191 def action(self, contexts, action):
192 if action == "cancel":
193 self.csel.handleEditCancel()
194 return 0 # fall-trough
196 return 0 # fall-trough
198 return ActionMap.action(self, contexts, action)
200 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
202 "contextMenu": self.doContext,
205 def getMutableList(self, root=eServiceReference()):
206 if not self.mutableList is None:
207 return self.mutableList
208 serviceHandler = eServiceCenter.getInstance()
211 list = serviceHandler.list(root)
213 return list.startEdit()
216 def buildBouquetID(self, str):
220 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
226 def addBouquet(self, providerName):
227 serviceHandler = eServiceCenter.getInstance()
228 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
229 if mutableBouquetList:
230 if self.mode == MODE_TV:
231 providerName += " (TV)"
232 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
234 providerName += " (Radio)"
235 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
236 new_bouquet_ref = eServiceReference(str)
237 if not mutableBouquetList.addService(new_bouquet_ref):
238 self.bouquetNumOffsetCache = { }
239 mutableBouquetList.flushChanges()
240 eDVBDB.getInstance().reloadBouquets()
241 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
243 mutableBouquet.setListName(providerName)
244 mutableBouquet.flushChanges()
245 self.setRoot(self.getRoot())
247 print "get mutable list for new created bouquet failed"
249 print "add", str, "to bouquets failed"
251 print "bouquetlist is not editable"
253 def copyCurrentToBouquetList(self):
254 provider = ServiceReference(self.getCurrentSelection())
255 serviceHandler = eServiceCenter.getInstance()
256 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
257 if mutableBouquetList:
258 providerName = provider.getServiceName()
259 if self.mode == MODE_TV:
260 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
262 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
263 new_bouquet_ref = eServiceReference(str)
264 if not mutableBouquetList.addService(new_bouquet_ref):
265 self.bouquetNumOffsetCache = { }
266 mutableBouquetList.flushChanges()
267 eDVBDB.getInstance().reloadBouquets()
268 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
270 mutableBouquet.setListName(providerName)
272 services = serviceHandler.list(provider.ref)
273 if not services is None:
274 if not services.getContent(list, True):
276 if mutableBouquet.addService(service):
277 print "add", service.toString(), "to new bouquet failed"
278 mutableBouquet.flushChanges()
280 print "getContent failed"
282 print "list provider", providerName, "failed"
284 print "get mutable list for new created bouquet failed"
286 print "add", str, "to bouquets failed"
288 print "bouquetlist is not editable"
290 def removeBouquet(self):
291 refstr = self.getCurrentSelection().toString()
292 self.bouquetNumOffsetCache = { }
293 pos = refstr.find('FROM BOUQUET "')
295 refstr = refstr[pos+14:]
296 pos = refstr.find('"')
298 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
299 self.removeCurrentService()
301 eDVBDB.getInstance().reloadBouquets()
303 # multiple marked entry stuff ( edit mode, later multiepg selection )
304 def startMarkedEdit(self):
305 self.mutableList = self.getMutableList()
306 # add all services from the current list to internal marked set in listboxservicecontent
307 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
308 self.saved_title = self.instance.getTitle()
309 pos = self.saved_title.find(')')
310 new_title = self.saved_title[:pos+1]
311 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
312 new_title += ' ' + _("[bouquet edit]")
314 new_title += ' ' + _("[favourite edit]")
315 self.setTitle(new_title)
316 self.bouquet_mark_edit = True
317 self.__marked = self.servicelist.getRootServices()
318 for x in self.__marked:
319 self.servicelist.addMarked(eServiceReference(x))
320 self.savedPath = self.servicePath[:]
321 self.showAllServices()
323 def endMarkedEdit(self, abort):
324 if not abort and self.mutableList is not None:
325 self.bouquetNumOffsetCache = { }
326 new_marked = set(self.servicelist.getMarked())
327 old_marked = set(self.__marked)
328 removed = old_marked - new_marked
329 added = new_marked - old_marked
333 self.mutableList.removeService(eServiceReference(x))
336 self.mutableList.addService(eServiceReference(x))
338 self.mutableList.flushChanges()
341 self.bouquet_mark_edit = False
342 self.mutableList = None
343 self.setTitle(self.saved_title)
344 self.saved_title = None
345 self.servicePath = self.savedPath[:]
347 self.setRoot(self.servicePath[len(self.servicePath)-1])
349 def clearMarks(self):
350 self.servicelist.clearMarks()
353 ref = self.servicelist.getCurrent()
354 if self.servicelist.isMarked(ref):
355 self.servicelist.removeMarked(ref)
357 self.servicelist.addMarked(ref)
359 def removeCurrentService(self):
360 ref = self.servicelist.getCurrent()
361 mutableList = self.getMutableList()
362 if ref.valid() and mutableList is not None:
363 if not mutableList.removeService(ref):
364 self.bouquetNumOffsetCache = { }
365 mutableList.flushChanges() #FIXME dont flush on each single removed service
366 self.setRoot(self.getRoot())
368 def addCurrentServiceToBouquet(self, dest):
369 mutableList = self.getMutableList(dest)
370 if not mutableList is None:
371 if not mutableList.addService(self.servicelist.getCurrent()):
372 self.bouquetNumOffsetCache = { }
373 mutableList.flushChanges()
376 def toggleMoveMode(self):
378 if self.entry_marked:
379 self.toggleMoveMarked() # unmark current entry
380 self.movemode = False
381 self.pathChangedDisabled = False # re-enable path change
382 self.mutableList.flushChanges() # FIXME add check if changes was made
383 self.mutableList = None
384 self.setTitle(self.saved_title)
385 self.saved_title = None
386 if self.getRoot() == self.bouquet_root:
387 self.bouquetNumOffsetCache = { }
389 self.mutableList = self.getMutableList()
391 self.pathChangedDisabled = True # no path change allowed in movemode
392 self.saved_title = self.instance.getTitle()
393 new_title = self.saved_title
394 pos = self.saved_title.find(')')
395 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
396 self.setTitle(new_title);
398 def handleEditCancel(self):
399 if self.movemode: #movemode active?
400 self.channelSelected() # unmark
401 self.toggleMoveMode() # disable move mode
402 elif self.bouquet_mark_edit:
403 self.endMarkedEdit(True) # abort edit mode
405 def toggleMoveMarked(self):
406 if self.entry_marked:
407 self.servicelist.setCurrentMarked(False)
408 self.entry_marked = False
410 self.servicelist.setCurrentMarked(True)
411 self.entry_marked = True
414 self.session.open(ChannelContextMenu, self)
419 class ChannelSelectionBase(Screen):
420 def __init__(self, session):
421 Screen.__init__(self, session)
423 # this makes it much simple to implement a selectable radio or tv mode :)
424 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
425 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
427 self["key_red"] = Button(_("All"))
428 self["key_green"] = Button(_("Satellites"))
429 self["key_yellow"] = Button(_("Provider"))
430 self["key_blue"] = Button(_("Favourites"))
432 self["list"] = ServiceList()
433 self.servicelist = self["list"]
435 self.numericalTextInput = NumericalTextInput()
437 self.servicePathTV = [ ]
438 self.servicePathRadio = [ ]
439 self.servicePath = None
443 self.pathChangedDisabled = False
445 self.bouquetNumOffsetCache = { }
447 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
449 "showFavourites": self.showFavourites,
450 "showAllServices": self.showAllServices,
451 "showProviders": self.showProviders,
452 "showSatellites": self.showSatellites,
453 "nextBouquet": self.nextBouquet,
454 "prevBouquet": self.prevBouquet,
455 "1": self.keyNumberGlobal,
456 "2": self.keyNumberGlobal,
457 "3": self.keyNumberGlobal,
458 "4": self.keyNumberGlobal,
459 "5": self.keyNumberGlobal,
460 "6": self.keyNumberGlobal,
461 "7": self.keyNumberGlobal,
462 "8": self.keyNumberGlobal,
463 "9": self.keyNumberGlobal,
464 "0": self.keyNumberGlobal
467 def appendDVBTypes(self, ref):
469 pos = path.find(' FROM BOUQUET')
471 return eServiceReference(self.service_types + path[pos:])
474 def getBouquetNumOffset(self, bouquet):
475 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
477 bouquet = self.appendDVBTypes(bouquet)
479 return self.bouquetNumOffsetCache[bouquet.toString()]
482 serviceHandler = eServiceCenter.getInstance()
483 bouquetlist = serviceHandler.list(self.bouquet_root)
484 if not bouquetlist is None:
486 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
487 if not bouquetIterator.valid(): #end of list
489 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
490 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
492 servicelist = serviceHandler.list(bouquetIterator)
493 if not servicelist is None:
495 serviceIterator = servicelist.getNext()
496 if not serviceIterator.valid(): #check if end of list
498 if serviceIterator.flags: #playable services have no flags
501 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
503 def recallBouquetMode(self):
504 if self.mode == MODE_TV:
505 self.service_types = self.service_types_tv
506 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
507 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
509 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
511 self.service_types = self.service_types_radio
512 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
513 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
515 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
516 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
520 self.servicePath = self.servicePathTV
521 self.recallBouquetMode()
522 title = self.instance.getTitle()
523 pos = title.find(" (")
529 def setRadioMode(self):
530 self.mode = MODE_RADIO
531 self.servicePath = self.servicePathRadio
532 self.recallBouquetMode()
533 title = self.instance.getTitle()
534 pos = title.find(" (")
540 def setRoot(self, root, justSet=False):
541 path = root.getPath()
542 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
543 pos = path.find(' FROM BOUQUET')
544 isBouquet = pos != -1
545 if not inBouquetRootList and isBouquet:
546 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
547 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
548 refstr = self.service_types + path[pos:]
549 root = eServiceReference(refstr)
551 self.servicelist.setMode(ServiceList.MODE_NORMAL)
552 self.servicelist.setRoot(root, justSet)
553 self.buildTitleString()
555 def removeModeStr(self, str):
556 if self.mode == MODE_TV:
557 pos = str.find(' (TV)')
559 pos = str.find(' (Radio)')
564 def getServiceName(self, ref):
565 str = self.removeModeStr(ServiceReference(ref).getServiceName())
567 pathstr = ref.getPath()
568 if pathstr.find('FROM PROVIDERS') != -1:
570 if pathstr.find('FROM SATELLITES') != -1:
571 return _("Satellites")
572 if pathstr.find(') ORDER BY name') != -1:
576 def buildTitleString(self):
577 titleStr = self.instance.getTitle()
578 pos = titleStr.find(']')
580 pos = titleStr.find(')')
582 titleStr = titleStr[:pos+1]
583 Len = len(self.servicePath)
585 base_ref = self.servicePath[0]
587 end_ref = self.servicePath[Len-1]
590 nameStr = self.getServiceName(base_ref)
591 titleStr += ' ' + nameStr
592 if end_ref is not None:
597 nameStr = self.getServiceName(end_ref)
599 self.setTitle(titleStr)
602 self.servicelist.moveUp()
605 self.servicelist.moveDown()
608 del self.servicePath[:]
610 def enterPath(self, ref, justSet=False):
611 self.servicePath.append(ref)
612 self.setRoot(ref, justSet)
614 def pathUp(self, justSet=False):
615 prev = self.servicePath.pop()
616 length = len(self.servicePath)
618 current = self.servicePath[length-1]
619 self.setRoot(current, justSet)
621 self.setCurrentSelection(prev)
624 def isBasePathEqual(self, ref):
625 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
629 def isPrevPathEqual(self, ref):
630 length = len(self.servicePath)
631 if length > 1 and self.servicePath[length-2] == ref:
635 def preEnterPath(self, refstr):
638 def showAllServices(self):
639 if not self.pathChangedDisabled:
640 refstr = '%s ORDER BY name'%(self.service_types)
641 if not self.preEnterPath(refstr):
642 ref = eServiceReference(refstr)
643 currentRoot = self.getRoot()
644 if currentRoot is None or currentRoot != ref:
648 def showSatellites(self):
649 if not self.pathChangedDisabled:
650 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
651 if not self.preEnterPath(refstr):
652 ref = eServiceReference(refstr)
656 if self.isBasePathEqual(ref):
657 if self.isPrevPathEqual(ref):
659 prev = self.pathUp(justSet)
661 currentRoot = self.getRoot()
662 if currentRoot is None or currentRoot != ref:
665 self.enterPath(ref, True)
667 serviceHandler = eServiceCenter.getInstance()
668 servicelist = serviceHandler.list(ref)
669 if not servicelist is None:
671 service = servicelist.getNext()
672 if not service.valid(): #check if end of list
674 orbpos = service.getData(4) >> 16
675 if service.getPath().find("FROM PROVIDER") != -1:
676 service_name = _("Providers")
678 service_name = _("Services")
680 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
681 service.setName(service_name) # why we need this cast?
683 if orbpos > 1800: # west
684 orbpos = 3600 - orbpos
688 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
690 self.servicelist.addService(service)
691 self.servicelist.finishFill()
693 self.setCurrentSelection(prev)
695 def showProviders(self):
696 if not self.pathChangedDisabled:
697 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
698 if not self.preEnterPath(refstr):
699 ref = eServiceReference(refstr)
700 if self.isBasePathEqual(ref):
703 currentRoot = self.getRoot()
704 if currentRoot is None or currentRoot != ref:
708 def changeBouquet(self, direction):
709 if not self.pathChangedDisabled:
710 if self.isBasePathEqual(self.bouquet_root):
716 ref = self.getCurrentSelection()
720 return self.isBasePathEqual(self.bouquet_root)
723 return self.servicelist.atBegin()
726 return self.servicelist.atEnd()
728 def nextBouquet(self):
729 self.changeBouquet(+1)
731 def prevBouquet(self):
732 self.changeBouquet(-1)
734 def showFavourites(self):
735 if not self.pathChangedDisabled:
736 if not self.preEnterPath(self.bouquet_rootstr):
737 if self.isBasePathEqual(self.bouquet_root):
740 currentRoot = self.getRoot()
741 if currentRoot is None or currentRoot != self.bouquet_root:
743 self.enterPath(self.bouquet_root)
745 def keyNumberGlobal(self, number):
746 char = self.numericalTextInput.getKey(number)
747 self.servicelist.moveToChar(char)
750 return self.servicelist.getRoot()
752 def getCurrentSelection(self):
753 return self.servicelist.getCurrent()
755 def setCurrentSelection(self, service):
756 servicepath = service.getPath()
757 pos = servicepath.find(" FROM BOUQUET")
759 if self.mode == MODE_TV:
760 servicepath = '(type == 1)' + servicepath[pos:]
762 servicepath = '(type == 2)' + servicepath[pos:]
763 service.setPath(servicepath)
764 self.servicelist.setCurrent(service)
766 def getBouquetList(self):
769 serviceHandler = eServiceCenter.getInstance()
770 list = serviceHandler.list(self.bouquet_root)
776 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
777 info = serviceHandler.info(s)
779 bouquets.append((info.getName(s), s))
782 if len(bouquets) == 0 and serviceCount > 0:
783 info = serviceHandler.info(self.bouquet_root)
785 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
791 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
792 def __init__(self, session):
793 ChannelSelectionBase.__init__(self,session)
794 ChannelSelectionEdit.__init__(self)
795 ChannelSelectionEPG.__init__(self)
797 #config for lastservice
798 config.tv = ConfigSubsection();
799 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
800 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
802 self["actions"] = ActionMap(["OkCancelActions"],
804 "cancel": self.cancel,
805 "ok": self.channelSelected,
807 self.onShown.append(self.__onShown)
809 self.lastChannelRootTimer = eTimer()
810 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
811 self.lastChannelRootTimer.start(100,True)
816 def __onCreate(self):
819 lastservice=eServiceReference(config.tv.lastservice.value)
820 if lastservice.valid():
821 self.setCurrentSelection(lastservice)
825 self.recallBouquetMode()
826 ref = self.session.nav.getCurrentlyPlayingServiceReference()
827 if ref is not None and ref.valid() and ref.getPath() == "":
828 self.servicelist.setPlayableIgnoreService(ref)
830 self.servicelist.setPlayableIgnoreService(eServiceReference())
832 def channelSelected(self):
833 ref = self.getCurrentSelection()
835 self.toggleMoveMarked()
836 elif (ref.flags & 7) == 7:
838 elif self.bouquet_mark_edit:
844 #called from infoBar and channelSelected
846 ref = self.session.nav.getCurrentlyPlayingServiceReference()
847 nref = self.getCurrentSelection()
848 if ref is None or ref != nref:
849 self.session.nav.playService(nref)
852 tmp=self.servicePath[:]
855 del self.history[self.history_pos+1:]
858 self.history.append(tmp)
859 hlen = len(self.history)
860 if hlen > HISTORYSIZE:
863 self.history_pos = hlen-1
865 def historyBack(self):
866 hlen = len(self.history)
867 if hlen > 1 and self.history_pos > 0:
868 self.history_pos -= 1
869 self.setHistoryPath()
871 def historyNext(self):
872 hlen = len(self.history)
873 if hlen > 1 and self.history_pos < (hlen-1):
874 self.history_pos += 1
875 self.setHistoryPath()
877 def setHistoryPath(self):
878 path = self.history[self.history_pos][:]
880 self.servicePath = path
884 if self.getRoot() != root:
886 self.session.nav.playService(ref)
887 self.setCurrentSelection(ref)
892 for i in self.servicePathTV:
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.lastservice.value = refstr
933 config.tv.lastservice.save()
935 def recallPrevService(self):
936 hlen = len(self.history)
938 if self.history_pos == hlen-1:
939 tmp = self.history[self.history_pos]
940 self.history[self.history_pos] = self.history[self.history_pos-1]
941 self.history[self.history_pos-1] = tmp
943 tmp = self.history[self.history_pos+1]
944 self.history[self.history_pos+1] = self.history[self.history_pos]
945 self.history[self.history_pos] = tmp
946 self.setHistoryPath()
951 lastservice=eServiceReference(config.tv.lastservice.value)
952 if lastservice.valid() and self.getCurrentSelection() != lastservice:
953 self.setCurrentSelection(lastservice)
955 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
957 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
958 def __init__(self, session):
959 Screen.__init__(self, session)
960 InfoBarEvent.__init__(self)
961 InfoBarServiceName.__init__(self)
962 InfoBarInstantRecord.__init__(self)
963 self["Clock"] = Clock()
965 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
966 def __init__(self, session):
967 ChannelSelectionBase.__init__(self, session)
968 ChannelSelectionEdit.__init__(self)
969 ChannelSelectionEPG.__init__(self)
971 config.radio = ConfigSubsection();
972 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
973 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
974 self.onLayoutFinish.append(self.onCreate)
976 self.info = session.instantiateDialog(RadioInfoBar)
978 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
980 "keyTV": self.closeRadio,
981 "keyRadio": self.closeRadio,
982 "cancel": self.closeRadio,
983 "ok": self.channelSelected,
988 for i in self.servicePathRadio:
991 if len(path) and path != config.radio.lastroot.value:
992 config.radio.lastroot.value = path
993 config.radio.lastroot.save()
995 def restoreRoot(self):
998 tmp = re.findall(config.radio.lastroot.value)
1001 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1004 path = self.servicePathRadio.pop()
1005 self.enterPath(path)
1007 self.showFavourites()
1010 def preEnterPath(self, refstr):
1011 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1012 pathstr = config.radio.lastroot.value
1013 if pathstr is not None and pathstr.find(refstr) == 0:
1015 lastservice=eServiceReference(config.radio.lastservice.value)
1016 if lastservice.valid():
1017 self.setCurrentSelection(lastservice)
1024 lastservice=eServiceReference(config.radio.lastservice.value)
1025 if lastservice.valid():
1026 self.servicelist.setCurrent(lastservice)
1027 self.session.nav.playService(lastservice)
1028 self.servicelist.setPlayableIgnoreService(lastservice)
1031 def channelSelected(self): # just return selected service
1032 ref = self.getCurrentSelection()
1034 self.toggleMoveMarked()
1035 elif (ref.flags & 7) == 7:
1037 elif self.bouquet_mark_edit:
1040 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1041 if playingref is None or playingref != ref:
1042 self.session.nav.playService(ref)
1043 self.servicelist.setPlayableIgnoreService(ref)
1044 config.radio.lastservice.value = ref.toString()
1045 config.radio.lastservice.save()
1048 def closeRadio(self):
1050 #set previous tv service
1051 lastservice=eServiceReference(config.tv.lastservice.value)
1052 self.session.nav.playService(lastservice)
1055 class SimpleChannelSelection(ChannelSelectionBase):
1056 def __init__(self, session, title):
1057 ChannelSelectionBase.__init__(self, session)
1059 self.onShown.append(self.__onExecCallback)
1061 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1063 "cancel": self.close,
1064 "ok": self.channelSelected,
1065 "keyRadio": self.setModeRadio,
1066 "keyTV": self.setModeTv,
1069 def __onExecCallback(self):
1070 self.setTitle(self.title)
1073 def channelSelected(self): # just return selected service
1074 ref = self.getCurrentSelection()
1075 if (ref.flags & 7) == 7:
1078 ref = self.getCurrentSelection()
1081 def setModeTv(self):
1083 self.showFavourites()
1085 def setModeRadio(self):
1087 self.showFavourites()