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)
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
441 self.pathChangedDisabled = False
443 self.bouquetNumOffsetCache = { }
445 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
447 "showFavourites": self.showFavourites,
448 "showAllServices": self.showAllServices,
449 "showProviders": self.showProviders,
450 "showSatellites": self.showSatellites,
451 "nextBouquet": self.nextBouquet,
452 "prevBouquet": self.prevBouquet,
453 "1": self.keyNumberGlobal,
454 "2": self.keyNumberGlobal,
455 "3": self.keyNumberGlobal,
456 "4": self.keyNumberGlobal,
457 "5": self.keyNumberGlobal,
458 "6": self.keyNumberGlobal,
459 "7": self.keyNumberGlobal,
460 "8": self.keyNumberGlobal,
461 "9": self.keyNumberGlobal,
462 "0": self.keyNumberGlobal
465 def appendDVBTypes(self, ref):
467 pos = path.find(' FROM BOUQUET')
469 return eServiceReference(self.service_types + path[pos:])
472 def getBouquetNumOffset(self, bouquet):
473 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
475 bouquet = self.appendDVBTypes(bouquet)
477 return self.bouquetNumOffsetCache[bouquet.toString()]
480 serviceHandler = eServiceCenter.getInstance()
481 bouquetlist = serviceHandler.list(self.bouquet_root)
482 if not bouquetlist is None:
484 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
485 if not bouquetIterator.valid(): #end of list
487 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
488 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
490 servicelist = serviceHandler.list(bouquetIterator)
491 if not servicelist is None:
493 serviceIterator = servicelist.getNext()
494 if not serviceIterator.valid(): #check if end of list
496 if serviceIterator.flags: #playable services have no flags
499 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
501 def recallBouquetMode(self):
502 if self.mode == MODE_TV:
503 self.service_types = self.service_types_tv
504 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
505 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
507 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
509 self.service_types = self.service_types_radio
510 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
511 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
513 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
514 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
518 self.servicePath = self.servicePathTV
519 self.recallBouquetMode()
520 title = self.instance.getTitle()
521 pos = title.find(" (")
527 def setRadioMode(self):
528 self.mode = MODE_RADIO
529 self.servicePath = self.servicePathRadio
530 self.recallBouquetMode()
531 title = self.instance.getTitle()
532 pos = title.find(" (")
538 def setRoot(self, root, justSet=False):
539 path = root.getPath()
540 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
541 pos = path.find(' FROM BOUQUET')
542 isBouquet = pos != -1
543 if not inBouquetRootList and isBouquet:
544 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
545 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
546 refstr = self.service_types + path[pos:]
547 root = eServiceReference(refstr)
549 self.servicelist.setMode(ServiceList.MODE_NORMAL)
550 self.servicelist.setRoot(root, justSet)
551 self.buildTitleString()
553 def removeModeStr(self, str):
554 if self.mode == MODE_TV:
555 pos = str.find(' (TV)')
557 pos = str.find(' (Radio)')
562 def getServiceName(self, ref):
563 str = self.removeModeStr(ServiceReference(ref).getServiceName())
565 pathstr = ref.getPath()
566 if pathstr.find('FROM PROVIDERS') != -1:
568 if pathstr.find('FROM SATELLITES') != -1:
569 return _("Satellites")
570 if pathstr.find(') ORDER BY name') != -1:
574 def buildTitleString(self):
575 titleStr = self.instance.getTitle()
576 pos = titleStr.find(']')
578 pos = titleStr.find(')')
580 titleStr = titleStr[:pos+1]
581 Len = len(self.servicePath)
583 base_ref = self.servicePath[0]
585 end_ref = self.servicePath[Len-1]
588 nameStr = self.getServiceName(base_ref)
589 titleStr += ' ' + nameStr
590 if end_ref is not None:
595 nameStr = self.getServiceName(end_ref)
597 self.setTitle(titleStr)
600 self.servicelist.moveUp()
603 self.servicelist.moveDown()
606 del self.servicePath[:]
608 def enterPath(self, ref, justSet=False):
609 self.servicePath.append(ref)
610 self.setRoot(ref, justSet)
612 def pathUp(self, justSet=False):
613 prev = self.servicePath.pop()
614 length = len(self.servicePath)
616 current = self.servicePath[length-1]
617 self.setRoot(current, justSet)
619 self.setCurrentSelection(prev)
622 def isBasePathEqual(self, ref):
623 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
627 def isPrevPathEqual(self, ref):
628 length = len(self.servicePath)
629 if length > 1 and self.servicePath[length-2] == ref:
633 def preEnterPath(self, refstr):
636 def showAllServices(self):
637 if not self.pathChangedDisabled:
638 refstr = '%s ORDER BY name'%(self.service_types)
639 if not self.preEnterPath(refstr):
640 ref = eServiceReference(refstr)
641 currentRoot = self.getRoot()
642 if currentRoot is None or currentRoot != ref:
646 def showSatellites(self):
647 if not self.pathChangedDisabled:
648 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
649 if not self.preEnterPath(refstr):
650 ref = eServiceReference(refstr)
654 if self.isBasePathEqual(ref):
655 if self.isPrevPathEqual(ref):
657 prev = self.pathUp(justSet)
659 currentRoot = self.getRoot()
660 if currentRoot is None or currentRoot != ref:
663 self.enterPath(ref, True)
665 serviceHandler = eServiceCenter.getInstance()
666 servicelist = serviceHandler.list(ref)
667 if not servicelist is None:
669 service = servicelist.getNext()
670 if not service.valid(): #check if end of list
672 orbpos = service.getData(4) >> 16
673 if service.getPath().find("FROM PROVIDER") != -1:
674 service_name = _("Providers")
676 service_name = _("Services")
678 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
679 service.setName(service_name) # why we need this cast?
681 if orbpos > 1800: # west
682 orbpos = 3600 - orbpos
686 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
688 self.servicelist.addService(service)
689 self.servicelist.finishFill()
691 self.setCurrentSelection(prev)
693 def showProviders(self):
694 if not self.pathChangedDisabled:
695 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
696 if not self.preEnterPath(refstr):
697 ref = eServiceReference(refstr)
698 if self.isBasePathEqual(ref):
701 currentRoot = self.getRoot()
702 if currentRoot is None or currentRoot != ref:
706 def changeBouquet(self, direction):
707 if not self.pathChangedDisabled:
708 if self.isBasePathEqual(self.bouquet_root):
714 ref = self.getCurrentSelection()
718 return self.isBasePathEqual(self.bouquet_root)
721 return self.servicelist.atBegin()
724 return self.servicelist.atEnd()
726 def nextBouquet(self):
727 self.changeBouquet(+1)
729 def prevBouquet(self):
730 self.changeBouquet(-1)
732 def showFavourites(self):
733 if not self.pathChangedDisabled:
734 if not self.preEnterPath(self.bouquet_rootstr):
735 if self.isBasePathEqual(self.bouquet_root):
738 currentRoot = self.getRoot()
739 if currentRoot is None or currentRoot != self.bouquet_root:
741 self.enterPath(self.bouquet_root)
743 def keyNumberGlobal(self, number):
744 char = self.numericalTextInput.getKey(number)
745 self.servicelist.moveToChar(char)
748 return self.servicelist.getRoot()
750 def getCurrentSelection(self):
751 return self.servicelist.getCurrent()
753 def setCurrentSelection(self, service):
754 servicepath = service.getPath()
755 pos = servicepath.find(" FROM BOUQUET")
757 if self.mode == MODE_TV:
758 servicepath = '(type == 1)' + servicepath[pos:]
760 servicepath = '(type == 2)' + servicepath[pos:]
761 service.setPath(servicepath)
762 self.servicelist.setCurrent(service)
764 def getBouquetList(self):
767 serviceHandler = eServiceCenter.getInstance()
768 list = serviceHandler.list(self.bouquet_root)
774 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
775 info = serviceHandler.info(s)
777 bouquets.append((info.getName(s), s))
780 if len(bouquets) == 0 and serviceCount > 0:
781 info = serviceHandler.info(self.bouquet_root)
783 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
789 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
790 def __init__(self, session):
791 ChannelSelectionBase.__init__(self,session)
792 ChannelSelectionEdit.__init__(self)
793 ChannelSelectionEPG.__init__(self)
795 #config for lastservice
796 config.tv = ConfigSubsection();
797 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
798 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
800 self["actions"] = ActionMap(["OkCancelActions"],
802 "cancel": self.cancel,
803 "ok": self.channelSelected,
805 self.onShown.append(self.__onShown)
807 self.lastChannelRootTimer = eTimer()
808 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
809 self.lastChannelRootTimer.start(100,True)
814 def __onCreate(self):
817 lastservice=eServiceReference(config.tv.lastservice.value)
818 if lastservice.valid():
819 self.setCurrentSelection(lastservice)
823 self.recallBouquetMode()
824 ref = self.session.nav.getCurrentlyPlayingServiceReference()
825 if ref is not None and ref.valid() and ref.getPath() == "":
826 self.servicelist.setPlayableIgnoreService(ref)
828 self.servicelist.setPlayableIgnoreService(eServiceReference())
830 def channelSelected(self):
831 ref = self.getCurrentSelection()
833 self.toggleMoveMarked()
834 elif (ref.flags & 7) == 7:
836 elif self.bouquet_mark_edit:
842 #called from infoBar and channelSelected
844 ref = self.session.nav.getCurrentlyPlayingServiceReference()
845 nref = self.getCurrentSelection()
846 if ref is None or ref != nref:
847 self.session.nav.playService(nref)
850 tmp=self.servicePath[:]
853 del self.history[self.history_pos+1:]
856 self.history.append(tmp)
857 hlen = len(self.history)
858 if hlen > HISTORYSIZE:
861 self.history_pos = hlen-1
863 def historyBack(self):
864 hlen = len(self.history)
865 if hlen > 1 and self.history_pos > 0:
866 self.history_pos -= 1
867 self.setHistoryPath()
869 def historyNext(self):
870 hlen = len(self.history)
871 if hlen > 1 and self.history_pos < (hlen-1):
872 self.history_pos += 1
873 self.setHistoryPath()
875 def setHistoryPath(self):
876 path = self.history[self.history_pos][:]
878 self.servicePath = path
882 if self.getRoot() != root:
884 self.session.nav.playService(ref)
885 self.setCurrentSelection(ref)
890 for i in self.servicePathTV:
893 if len(path) and path != config.tv.lastroot.value:
894 config.tv.lastroot.value = path
895 config.tv.lastroot.save()
897 def restoreRoot(self):
900 tmp = re.findall(config.tv.lastroot.value)
903 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
906 path = self.servicePathTV.pop()
909 self.showFavourites()
912 def preEnterPath(self, refstr):
913 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
914 pathstr = config.tv.lastroot.value
915 if pathstr is not None and pathstr.find(refstr) == 0:
917 lastservice=eServiceReference(config.tv.lastservice.value)
918 if lastservice.valid():
919 self.setCurrentSelection(lastservice)
923 def saveChannel(self):
924 ref = self.session.nav.getCurrentlyPlayingServiceReference()
926 refstr = ref.toString()
929 if refstr != config.tv.lastservice.value:
930 config.tv.lastservice.value = refstr
931 config.tv.lastservice.save()
933 def recallPrevService(self):
934 hlen = len(self.history)
936 if self.history_pos == hlen-1:
937 tmp = self.history[self.history_pos]
938 self.history[self.history_pos] = self.history[self.history_pos-1]
939 self.history[self.history_pos-1] = tmp
941 tmp = self.history[self.history_pos+1]
942 self.history[self.history_pos+1] = self.history[self.history_pos]
943 self.history[self.history_pos] = tmp
944 self.setHistoryPath()
949 lastservice=eServiceReference(config.tv.lastservice.value)
950 if lastservice.valid() and self.getCurrentSelection() != lastservice:
951 self.setCurrentSelection(lastservice)
953 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
955 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
956 def __init__(self, session):
957 Screen.__init__(self, session)
958 InfoBarEvent.__init__(self)
959 InfoBarServiceName.__init__(self)
960 InfoBarInstantRecord.__init__(self)
961 self["Clock"] = Clock()
963 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
964 def __init__(self, session):
965 ChannelSelectionBase.__init__(self, session)
966 ChannelSelectionEdit.__init__(self)
967 ChannelSelectionEPG.__init__(self)
969 config.radio = ConfigSubsection();
970 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
971 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
972 self.onLayoutFinish.append(self.onCreate)
974 self.info = session.instantiateDialog(RadioInfoBar)
976 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
978 "keyTV": self.closeRadio,
979 "keyRadio": self.closeRadio,
980 "cancel": self.closeRadio,
981 "ok": self.channelSelected,
986 for i in self.servicePathRadio:
989 if len(path) and path != config.radio.lastroot.value:
990 config.radio.lastroot.value = path
991 config.radio.lastroot.save()
993 def restoreRoot(self):
996 tmp = re.findall(config.radio.lastroot.value)
999 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1002 path = self.servicePathRadio.pop()
1003 self.enterPath(path)
1005 self.showFavourites()
1008 def preEnterPath(self, refstr):
1009 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1010 pathstr = config.radio.lastroot.value
1011 if pathstr is not None and pathstr.find(refstr) == 0:
1013 lastservice=eServiceReference(config.radio.lastservice.value)
1014 if lastservice.valid():
1015 self.setCurrentSelection(lastservice)
1022 lastservice=eServiceReference(config.radio.lastservice.value)
1023 if lastservice.valid():
1024 self.servicelist.setCurrent(lastservice)
1025 self.session.nav.playService(lastservice)
1026 self.servicelist.setPlayableIgnoreService(lastservice)
1029 def channelSelected(self): # just return selected service
1030 ref = self.getCurrentSelection()
1032 self.toggleMoveMarked()
1033 elif (ref.flags & 7) == 7:
1035 elif self.bouquet_mark_edit:
1038 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1039 if playingref is None or playingref != ref:
1040 self.session.nav.playService(ref)
1041 self.servicelist.setPlayableIgnoreService(ref)
1042 config.radio.lastservice.value = ref.toString()
1043 config.radio.lastservice.save()
1046 def closeRadio(self):
1048 #set previous tv service
1049 lastservice=eServiceReference(config.tv.lastservice.value)
1050 self.session.nav.playService(lastservice)
1053 class SimpleChannelSelection(ChannelSelectionBase):
1054 def __init__(self, session, title):
1055 ChannelSelectionBase.__init__(self, session)
1057 self.onShown.append(self.__onExecCallback)
1059 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1061 "cancel": self.close,
1062 "ok": self.channelSelected,
1063 "keyRadio": self.setModeRadio,
1064 "keyTV": self.setModeTv,
1067 def __onExecCallback(self):
1068 self.setTitle(self.title)
1071 def channelSelected(self): # just return selected service
1072 ref = self.getCurrentSelection()
1073 if (ref.flags & 7) == 7:
1076 ref = self.getCurrentSelection()
1079 def setModeTv(self):
1081 self.showFavourites()
1083 def setModeRadio(self):
1085 self.showFavourites()