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 is just a reference to servicePathTv or Radio...
346 # so we never ever do use the asignment operator in self.servicePath
347 del self.servicePath[:] # remove all elements
348 self.servicePath += self.savedPath # add saved elements
350 self.setRoot(self.servicePath[len(self.servicePath)-1])
352 def clearMarks(self):
353 self.servicelist.clearMarks()
356 ref = self.servicelist.getCurrent()
357 if self.servicelist.isMarked(ref):
358 self.servicelist.removeMarked(ref)
360 self.servicelist.addMarked(ref)
362 def removeCurrentService(self):
363 ref = self.servicelist.getCurrent()
364 mutableList = self.getMutableList()
365 if ref.valid() and mutableList is not None:
366 if not mutableList.removeService(ref):
367 self.bouquetNumOffsetCache = { }
368 mutableList.flushChanges() #FIXME dont flush on each single removed service
369 self.setRoot(self.getRoot())
371 def addCurrentServiceToBouquet(self, dest):
372 mutableList = self.getMutableList(dest)
373 if not mutableList is None:
374 if not mutableList.addService(self.servicelist.getCurrent()):
375 self.bouquetNumOffsetCache = { }
376 mutableList.flushChanges()
379 def toggleMoveMode(self):
381 if self.entry_marked:
382 self.toggleMoveMarked() # unmark current entry
383 self.movemode = False
384 self.pathChangedDisabled = False # re-enable path change
385 self.mutableList.flushChanges() # FIXME add check if changes was made
386 self.mutableList = None
387 self.setTitle(self.saved_title)
388 self.saved_title = None
389 if self.getRoot() == self.bouquet_root:
390 self.bouquetNumOffsetCache = { }
392 self.mutableList = self.getMutableList()
394 self.pathChangedDisabled = True # no path change allowed in movemode
395 self.saved_title = self.instance.getTitle()
396 new_title = self.saved_title
397 pos = self.saved_title.find(')')
398 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
399 self.setTitle(new_title);
401 def handleEditCancel(self):
402 if self.movemode: #movemode active?
403 self.channelSelected() # unmark
404 self.toggleMoveMode() # disable move mode
405 elif self.bouquet_mark_edit:
406 self.endMarkedEdit(True) # abort edit mode
408 def toggleMoveMarked(self):
409 if self.entry_marked:
410 self.servicelist.setCurrentMarked(False)
411 self.entry_marked = False
413 self.servicelist.setCurrentMarked(True)
414 self.entry_marked = True
417 self.session.open(ChannelContextMenu, self)
422 class ChannelSelectionBase(Screen):
423 def __init__(self, session):
424 Screen.__init__(self, session)
426 # this makes it much simple to implement a selectable radio or tv mode :)
427 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
428 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
430 self["key_red"] = Button(_("All"))
431 self["key_green"] = Button(_("Satellites"))
432 self["key_yellow"] = Button(_("Provider"))
433 self["key_blue"] = Button(_("Favourites"))
435 self["list"] = ServiceList()
436 self.servicelist = self["list"]
438 self.numericalTextInput = NumericalTextInput()
440 self.servicePathTV = [ ]
441 self.servicePathRadio = [ ]
442 self.servicePath = None
446 self.pathChangedDisabled = False
448 self.bouquetNumOffsetCache = { }
450 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
452 "showFavourites": self.showFavourites,
453 "showAllServices": self.showAllServices,
454 "showProviders": self.showProviders,
455 "showSatellites": self.showSatellites,
456 "nextBouquet": self.nextBouquet,
457 "prevBouquet": self.prevBouquet,
458 "1": self.keyNumberGlobal,
459 "2": self.keyNumberGlobal,
460 "3": self.keyNumberGlobal,
461 "4": self.keyNumberGlobal,
462 "5": self.keyNumberGlobal,
463 "6": self.keyNumberGlobal,
464 "7": self.keyNumberGlobal,
465 "8": self.keyNumberGlobal,
466 "9": self.keyNumberGlobal,
467 "0": self.keyNumberGlobal
470 def appendDVBTypes(self, ref):
472 pos = path.find(' FROM BOUQUET')
474 return eServiceReference(self.service_types + path[pos:])
477 def getBouquetNumOffset(self, bouquet):
478 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
480 bouquet = self.appendDVBTypes(bouquet)
482 return self.bouquetNumOffsetCache[bouquet.toString()]
485 serviceHandler = eServiceCenter.getInstance()
486 bouquetlist = serviceHandler.list(self.bouquet_root)
487 if not bouquetlist is None:
489 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
490 if not bouquetIterator.valid(): #end of list
492 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
493 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
495 servicelist = serviceHandler.list(bouquetIterator)
496 if not servicelist is None:
498 serviceIterator = servicelist.getNext()
499 if not serviceIterator.valid(): #check if end of list
501 if serviceIterator.flags: #playable services have no flags
504 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
506 def recallBouquetMode(self):
507 if self.mode == MODE_TV:
508 self.service_types = self.service_types_tv
509 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
510 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
512 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
514 self.service_types = self.service_types_radio
515 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
516 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
518 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
519 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
523 self.servicePath = self.servicePathTV
524 self.recallBouquetMode()
525 title = self.instance.getTitle()
526 pos = title.find(" (")
532 def setRadioMode(self):
533 self.mode = MODE_RADIO
534 self.servicePath = self.servicePathRadio
535 self.recallBouquetMode()
536 title = self.instance.getTitle()
537 pos = title.find(" (")
543 def setRoot(self, root, justSet=False):
544 path = root.getPath()
545 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
546 pos = path.find(' FROM BOUQUET')
547 isBouquet = pos != -1
548 if not inBouquetRootList and isBouquet:
549 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
550 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
551 refstr = self.service_types + path[pos:]
552 root = eServiceReference(refstr)
554 self.servicelist.setMode(ServiceList.MODE_NORMAL)
555 self.servicelist.setRoot(root, justSet)
556 self.buildTitleString()
558 def removeModeStr(self, str):
559 if self.mode == MODE_TV:
560 pos = str.find(' (TV)')
562 pos = str.find(' (Radio)')
567 def getServiceName(self, ref):
568 str = self.removeModeStr(ServiceReference(ref).getServiceName())
570 pathstr = ref.getPath()
571 if pathstr.find('FROM PROVIDERS') != -1:
573 if pathstr.find('FROM SATELLITES') != -1:
574 return _("Satellites")
575 if pathstr.find(') ORDER BY name') != -1:
579 def buildTitleString(self):
580 titleStr = self.instance.getTitle()
581 pos = titleStr.find(']')
583 pos = titleStr.find(')')
585 titleStr = titleStr[:pos+1]
586 Len = len(self.servicePath)
588 base_ref = self.servicePath[0]
590 end_ref = self.servicePath[Len-1]
593 nameStr = self.getServiceName(base_ref)
594 titleStr += ' ' + nameStr
595 if end_ref is not None:
600 nameStr = self.getServiceName(end_ref)
602 self.setTitle(titleStr)
605 self.servicelist.moveUp()
608 self.servicelist.moveDown()
611 del self.servicePath[:]
613 def enterPath(self, ref, justSet=False):
614 self.servicePath.append(ref)
615 self.setRoot(ref, justSet)
617 def pathUp(self, justSet=False):
618 prev = self.servicePath.pop()
619 length = len(self.servicePath)
621 current = self.servicePath[length-1]
622 self.setRoot(current, justSet)
624 self.setCurrentSelection(prev)
627 def isBasePathEqual(self, ref):
628 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
632 def isPrevPathEqual(self, ref):
633 length = len(self.servicePath)
634 if length > 1 and self.servicePath[length-2] == ref:
638 def preEnterPath(self, refstr):
641 def showAllServices(self):
642 if not self.pathChangedDisabled:
643 refstr = '%s ORDER BY name'%(self.service_types)
644 if not self.preEnterPath(refstr):
645 ref = eServiceReference(refstr)
646 currentRoot = self.getRoot()
647 if currentRoot is None or currentRoot != ref:
651 def showSatellites(self):
652 if not self.pathChangedDisabled:
653 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
654 if not self.preEnterPath(refstr):
655 ref = eServiceReference(refstr)
659 if self.isBasePathEqual(ref):
660 if self.isPrevPathEqual(ref):
662 prev = self.pathUp(justSet)
664 currentRoot = self.getRoot()
665 if currentRoot is None or currentRoot != ref:
668 self.enterPath(ref, True)
670 serviceHandler = eServiceCenter.getInstance()
671 servicelist = serviceHandler.list(ref)
672 if not servicelist is None:
674 service = servicelist.getNext()
675 if not service.valid(): #check if end of list
677 orbpos = service.getData(4) >> 16
678 if service.getPath().find("FROM PROVIDER") != -1:
679 service_name = _("Providers")
681 service_name = _("Services")
683 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
684 service.setName(service_name) # why we need this cast?
686 if orbpos > 1800: # west
687 orbpos = 3600 - orbpos
691 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
693 self.servicelist.addService(service)
694 self.servicelist.finishFill()
696 self.setCurrentSelection(prev)
698 def showProviders(self):
699 if not self.pathChangedDisabled:
700 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
701 if not self.preEnterPath(refstr):
702 ref = eServiceReference(refstr)
703 if self.isBasePathEqual(ref):
706 currentRoot = self.getRoot()
707 if currentRoot is None or currentRoot != ref:
711 def changeBouquet(self, direction):
712 if not self.pathChangedDisabled:
713 if self.isBasePathEqual(self.bouquet_root):
719 ref = self.getCurrentSelection()
723 return self.isBasePathEqual(self.bouquet_root)
726 return self.servicelist.atBegin()
729 return self.servicelist.atEnd()
731 def nextBouquet(self):
732 self.changeBouquet(+1)
734 def prevBouquet(self):
735 self.changeBouquet(-1)
737 def showFavourites(self):
738 if not self.pathChangedDisabled:
739 if not self.preEnterPath(self.bouquet_rootstr):
740 if self.isBasePathEqual(self.bouquet_root):
743 currentRoot = self.getRoot()
744 if currentRoot is None or currentRoot != self.bouquet_root:
746 self.enterPath(self.bouquet_root)
748 def keyNumberGlobal(self, number):
749 char = self.numericalTextInput.getKey(number)
750 self.servicelist.moveToChar(char)
753 return self.servicelist.getRoot()
755 def getCurrentSelection(self):
756 return self.servicelist.getCurrent()
758 def setCurrentSelection(self, service):
759 servicepath = service.getPath()
760 pos = servicepath.find(" FROM BOUQUET")
762 if self.mode == MODE_TV:
763 servicepath = '(type == 1)' + servicepath[pos:]
765 servicepath = '(type == 2)' + servicepath[pos:]
766 service.setPath(servicepath)
767 self.servicelist.setCurrent(service)
769 def getBouquetList(self):
772 serviceHandler = eServiceCenter.getInstance()
773 list = serviceHandler.list(self.bouquet_root)
779 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
780 info = serviceHandler.info(s)
782 bouquets.append((info.getName(s), s))
785 if len(bouquets) == 0 and serviceCount > 0:
786 info = serviceHandler.info(self.bouquet_root)
788 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
794 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
795 def __init__(self, session):
796 ChannelSelectionBase.__init__(self,session)
797 ChannelSelectionEdit.__init__(self)
798 ChannelSelectionEPG.__init__(self)
800 #config for lastservice
801 config.tv = ConfigSubsection();
802 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
803 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
805 self["actions"] = ActionMap(["OkCancelActions"],
807 "cancel": self.cancel,
808 "ok": self.channelSelected,
810 self.onShown.append(self.__onShown)
812 self.lastChannelRootTimer = eTimer()
813 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
814 self.lastChannelRootTimer.start(100,True)
819 def __onCreate(self):
822 lastservice=eServiceReference(config.tv.lastservice.value)
823 if lastservice.valid():
824 self.setCurrentSelection(lastservice)
828 self.recallBouquetMode()
829 ref = self.session.nav.getCurrentlyPlayingServiceReference()
830 if ref is not None and ref.valid() and ref.getPath() == "":
831 self.servicelist.setPlayableIgnoreService(ref)
833 self.servicelist.setPlayableIgnoreService(eServiceReference())
835 def channelSelected(self):
836 ref = self.getCurrentSelection()
838 self.toggleMoveMarked()
839 elif (ref.flags & 7) == 7:
841 elif self.bouquet_mark_edit:
847 #called from infoBar and channelSelected
849 ref = self.session.nav.getCurrentlyPlayingServiceReference()
850 nref = self.getCurrentSelection()
851 if ref is None or ref != nref:
852 self.session.nav.playService(nref)
855 tmp=self.servicePath[:]
858 del self.history[self.history_pos+1:]
861 self.history.append(tmp)
862 hlen = len(self.history)
863 if hlen > HISTORYSIZE:
866 self.history_pos = hlen-1
868 def historyBack(self):
869 hlen = len(self.history)
870 if hlen > 1 and self.history_pos > 0:
871 self.history_pos -= 1
872 self.setHistoryPath()
874 def historyNext(self):
875 hlen = len(self.history)
876 if hlen > 1 and self.history_pos < (hlen-1):
877 self.history_pos += 1
878 self.setHistoryPath()
880 def setHistoryPath(self):
881 path = self.history[self.history_pos][:]
883 del self.servicePath[:]
884 self.servicePath += path
888 if self.getRoot() != root:
890 self.session.nav.playService(ref)
891 self.setCurrentSelection(ref)
896 for i in self.servicePathTV:
899 if len(path) and path != config.tv.lastroot.value:
900 config.tv.lastroot.value = path
901 config.tv.lastroot.save()
903 def restoreRoot(self):
906 tmp = re.findall(config.tv.lastroot.value)
909 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
912 path = self.servicePathTV.pop()
915 self.showFavourites()
918 def preEnterPath(self, refstr):
919 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
920 pathstr = config.tv.lastroot.value
921 if pathstr is not None and pathstr.find(refstr) == 0:
923 lastservice=eServiceReference(config.tv.lastservice.value)
924 if lastservice.valid():
925 self.setCurrentSelection(lastservice)
929 def saveChannel(self):
930 ref = self.session.nav.getCurrentlyPlayingServiceReference()
932 refstr = ref.toString()
935 if refstr != config.tv.lastservice.value:
936 config.tv.lastservice.value = refstr
937 config.tv.lastservice.save()
939 def recallPrevService(self):
940 hlen = len(self.history)
942 if self.history_pos == hlen-1:
943 tmp = self.history[self.history_pos]
944 self.history[self.history_pos] = self.history[self.history_pos-1]
945 self.history[self.history_pos-1] = tmp
947 tmp = self.history[self.history_pos+1]
948 self.history[self.history_pos+1] = self.history[self.history_pos]
949 self.history[self.history_pos] = tmp
950 self.setHistoryPath()
955 lastservice=eServiceReference(config.tv.lastservice.value)
956 if lastservice.valid() and self.getCurrentSelection() != lastservice:
957 self.setCurrentSelection(lastservice)
959 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
961 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
962 def __init__(self, session):
963 Screen.__init__(self, session)
964 InfoBarEvent.__init__(self)
965 InfoBarServiceName.__init__(self)
966 InfoBarInstantRecord.__init__(self)
967 self["Clock"] = Clock()
969 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
970 def __init__(self, session):
971 ChannelSelectionBase.__init__(self, session)
972 ChannelSelectionEdit.__init__(self)
973 ChannelSelectionEPG.__init__(self)
975 config.radio = ConfigSubsection();
976 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
977 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
978 self.onLayoutFinish.append(self.onCreate)
980 self.info = session.instantiateDialog(RadioInfoBar)
982 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
984 "keyTV": self.closeRadio,
985 "keyRadio": self.closeRadio,
986 "cancel": self.closeRadio,
987 "ok": self.channelSelected,
992 for i in self.servicePathRadio:
995 if len(path) and path != config.radio.lastroot.value:
996 config.radio.lastroot.value = path
997 config.radio.lastroot.save()
999 def restoreRoot(self):
1001 re = compile('.+?;')
1002 tmp = re.findall(config.radio.lastroot.value)
1005 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1008 path = self.servicePathRadio.pop()
1009 self.enterPath(path)
1011 self.showFavourites()
1014 def preEnterPath(self, refstr):
1015 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1016 pathstr = config.radio.lastroot.value
1017 if pathstr is not None and pathstr.find(refstr) == 0:
1019 lastservice=eServiceReference(config.radio.lastservice.value)
1020 if lastservice.valid():
1021 self.setCurrentSelection(lastservice)
1028 lastservice=eServiceReference(config.radio.lastservice.value)
1029 if lastservice.valid():
1030 self.servicelist.setCurrent(lastservice)
1031 self.session.nav.playService(lastservice)
1032 self.servicelist.setPlayableIgnoreService(lastservice)
1035 def channelSelected(self): # just return selected service
1036 ref = self.getCurrentSelection()
1038 self.toggleMoveMarked()
1039 elif (ref.flags & 7) == 7:
1041 elif self.bouquet_mark_edit:
1044 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1045 if playingref is None or playingref != ref:
1046 self.session.nav.playService(ref)
1047 self.servicelist.setPlayableIgnoreService(ref)
1048 config.radio.lastservice.value = ref.toString()
1049 config.radio.lastservice.save()
1052 def closeRadio(self):
1054 #set previous tv service
1055 lastservice=eServiceReference(config.tv.lastservice.value)
1056 self.session.nav.playService(lastservice)
1059 class SimpleChannelSelection(ChannelSelectionBase):
1060 def __init__(self, session, title):
1061 ChannelSelectionBase.__init__(self, session)
1063 self.onShown.append(self.__onExecCallback)
1065 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1067 "cancel": self.close,
1068 "ok": self.channelSelected,
1069 "keyRadio": self.setModeRadio,
1070 "keyTV": self.setModeTv,
1073 def __onExecCallback(self):
1074 self.setTitle(self.title)
1077 def channelSelected(self): # just return selected service
1078 ref = self.getCurrentSelection()
1079 if (ref.flags & 7) == 7:
1082 ref = self.getCurrentSelection()
1085 def setModeTv(self):
1087 self.showFavourites()
1089 def setModeRadio(self):
1091 self.showFavourites()