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, enableWrapAround=False):
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, enableWrapAround)
40 cur = self["menu"].getCurrent()
43 def okbuttonClick(self):
44 self.selectedFunc(self.getCurrent())
52 def cancelClick(self):
55 class ChannelContextMenu(Screen):
56 def __init__(self, session, csel):
57 Screen.__init__(self, session)
61 self["actions"] = ActionMap(["OkCancelActions"],
63 "ok": self.okbuttonClick,
64 "cancel": self.cancelClick
68 current_root = csel.getRoot()
69 inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
70 inBouquet = csel.getMutableList() is not None
71 haveBouquets = csel.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1
73 if not csel.bouquet_mark_edit and not csel.movemode:
74 if not inBouquetRootList:
75 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
77 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
79 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
81 if not inBouquet and csel.getCurrentSelection().getPath().find("PROVIDERS") == -1:
82 menu.append((_("copy to favourites"), self.copyCurrentToBouquetList))
84 menu.append((_("remove service"), self.removeCurrentService))
86 menu.append((_("remove bouquet"), self.removeBouquet))
88 if inBouquet: # current list is editable?
89 if not csel.bouquet_mark_edit:
91 menu.append((_("enable move mode"), self.toggleMoveMode))
92 menu.append((_("add bouquet..."), self.showBouquetInputBox))
93 if not inBouquetRootList:
95 menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
97 menu.append((_("enable favourite edit"), self.bouquetMarkStart))
99 menu.append((_("disable move mode"), self.toggleMoveMode))
100 elif not inBouquetRootList:
102 menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
103 menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
105 menu.append((_("end favourites edit"), self.bouquetMarkEnd))
106 menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
108 menu.append((_("back"), self.cancelClick))
109 self["menu"] = MenuList(menu)
111 def okbuttonClick(self):
112 self["menu"].getCurrent()[1]()
114 def cancelClick(self):
117 def showBouquetInputBox(self):
118 self.session.openWithCallback(self.bouquetInputCallback, InputBox, title=_("Please enter a name for the new bouquet"), text="bouquetname", maxSize=False, type=Input.TEXT)
120 def bouquetInputCallback(self, bouquet):
121 if bouquet is not None:
122 self.csel.addBouquet(bouquet)
124 def addServiceToBouquetSelected(self):
125 bouquets = self.csel.getBouquetList()
130 if cnt > 1: # show bouquet list
131 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
132 elif cnt == 1: # add to only one existing bouquet
133 self.addCurrentServiceToBouquet(bouquets[0][1])
134 else: #no bouquets in root.. so assume only one favourite list is used
135 self.addCurrentServiceToBouquet(self.csel.bouquet_root)
137 def bouquetSelClosed(self, recursive):
142 def copyCurrentToBouquetList(self):
143 self.csel.copyCurrentToBouquetList()
146 def removeBouquet(self):
147 self.csel.removeBouquet()
150 def addCurrentServiceToBouquet(self, dest):
151 self.csel.addCurrentServiceToBouquet(dest)
152 if self.bsel is not None:
153 self.bsel.close(True)
155 self.close(True) # close bouquet selection
157 def removeCurrentService(self):
158 self.csel.removeCurrentService()
161 def toggleMoveMode(self):
162 self.csel.toggleMoveMode()
165 def bouquetMarkStart(self):
166 self.csel.startMarkedEdit()
169 def bouquetMarkEnd(self):
170 self.csel.endMarkedEdit(abort=False)
173 def bouquetMarkAbort(self):
174 self.csel.endMarkedEdit(abort=True)
177 class ChannelSelectionEPG:
179 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
181 "showEPGList": self.showEPGList,
184 def showEPGList(self):
185 ref=self.getCurrentSelection()
186 ptr=eEPGCache.getInstance()
187 if ptr.startTimeQuery(ref) != -1:
188 self.session.open(EPGSelection, ref)
190 print 'no epg for service', ref.toString()
192 class ChannelSelectionEdit:
194 self.entry_marked = False
195 self.movemode = False
196 self.bouquet_mark_edit = False
197 self.mutableList = None
199 self.saved_title = None
200 self.saved_root = None
202 class ChannelSelectionEditActionMap(ActionMap):
203 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
204 ActionMap.__init__(self, contexts, actions, prio)
207 def action(self, contexts, action):
208 if action == "cancel":
209 self.csel.handleEditCancel()
210 return 0 # fall-trough
212 return 0 # fall-trough
214 return ActionMap.action(self, contexts, action)
216 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
218 "contextMenu": self.doContext,
221 def getMutableList(self, root=eServiceReference()):
222 if not self.mutableList is None:
223 return self.mutableList
224 serviceHandler = eServiceCenter.getInstance()
227 list = root and serviceHandler.list(root)
229 return list.startEdit()
232 def buildBouquetID(self, str):
236 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
242 def addBouquet(self, providerName):
243 serviceHandler = eServiceCenter.getInstance()
244 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
245 if mutableBouquetList:
246 if self.mode == MODE_TV:
247 providerName += " (TV)"
248 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
250 providerName += " (Radio)"
251 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
252 new_bouquet_ref = eServiceReference(str)
253 if not mutableBouquetList.addService(new_bouquet_ref):
254 self.bouquetNumOffsetCache = { }
255 mutableBouquetList.flushChanges()
256 eDVBDB.getInstance().reloadBouquets()
257 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
259 mutableBouquet.setListName(providerName)
260 mutableBouquet.flushChanges()
261 self.setRoot(self.getRoot())
263 print "get mutable list for new created bouquet failed"
265 print "add", str, "to bouquets failed"
267 print "bouquetlist is not editable"
269 def copyCurrentToBouquetList(self):
270 provider = ServiceReference(self.getCurrentSelection())
271 serviceHandler = eServiceCenter.getInstance()
272 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
273 if mutableBouquetList:
274 providerName = provider.getServiceName()
275 if self.mode == MODE_TV:
276 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
278 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(providerName))
279 new_bouquet_ref = eServiceReference(str)
280 if not mutableBouquetList.addService(new_bouquet_ref):
281 self.bouquetNumOffsetCache = { }
282 mutableBouquetList.flushChanges()
283 eDVBDB.getInstance().reloadBouquets()
284 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
286 mutableBouquet.setListName(providerName)
288 services = serviceHandler.list(provider.ref)
289 if not services is None:
290 if not services.getContent(list, True):
292 if mutableBouquet.addService(service):
293 print "add", service.toString(), "to new bouquet failed"
294 mutableBouquet.flushChanges()
296 print "getContent failed"
298 print "list provider", providerName, "failed"
300 print "get mutable list for new created bouquet failed"
302 print "add", str, "to bouquets failed"
304 print "bouquetlist is not editable"
306 def removeBouquet(self):
307 refstr = self.getCurrentSelection().toString()
308 self.bouquetNumOffsetCache = { }
309 pos = refstr.find('FROM BOUQUET "')
311 refstr = refstr[pos+14:]
312 pos = refstr.find('"')
314 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
315 self.removeCurrentService()
319 print "error during remove of", filename
320 eDVBDB.getInstance().reloadBouquets()
322 # multiple marked entry stuff ( edit mode, later multiepg selection )
323 def startMarkedEdit(self):
324 self.mutableList = self.getMutableList()
325 # add all services from the current list to internal marked set in listboxservicecontent
326 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
327 self.saved_title = self.instance.getTitle()
328 pos = self.saved_title.find(')')
329 new_title = self.saved_title[:pos+1]
330 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
331 new_title += ' ' + _("[bouquet edit]")
333 new_title += ' ' + _("[favourite edit]")
334 self.setTitle(new_title)
335 self.bouquet_mark_edit = True
336 self.__marked = self.servicelist.getRootServices()
337 for x in self.__marked:
338 self.servicelist.addMarked(eServiceReference(x))
339 self.savedPath = self.servicePath[:]
340 self.showAllServices()
342 def endMarkedEdit(self, abort):
343 if not abort and self.mutableList is not None:
344 self.bouquetNumOffsetCache = { }
345 new_marked = set(self.servicelist.getMarked())
346 old_marked = set(self.__marked)
347 removed = old_marked - new_marked
348 added = new_marked - old_marked
352 self.mutableList.removeService(eServiceReference(x))
355 self.mutableList.addService(eServiceReference(x))
357 self.mutableList.flushChanges()
360 self.bouquet_mark_edit = False
361 self.mutableList = None
362 self.setTitle(self.saved_title)
363 self.saved_title = None
364 # self.servicePath is just a reference to servicePathTv or Radio...
365 # so we never ever do use the asignment operator in self.servicePath
366 del self.servicePath[:] # remove all elements
367 self.servicePath += self.savedPath # add saved elements
369 self.setRoot(self.servicePath[len(self.servicePath)-1])
371 def clearMarks(self):
372 self.servicelist.clearMarks()
375 ref = self.servicelist.getCurrent()
376 if self.servicelist.isMarked(ref):
377 self.servicelist.removeMarked(ref)
379 self.servicelist.addMarked(ref)
381 def removeCurrentService(self):
382 ref = self.servicelist.getCurrent()
383 mutableList = self.getMutableList()
384 if ref.valid() and mutableList is not None:
385 if not mutableList.removeService(ref):
386 self.bouquetNumOffsetCache = { }
387 mutableList.flushChanges() #FIXME dont flush on each single removed service
388 self.setRoot(self.getRoot())
390 def addCurrentServiceToBouquet(self, dest):
391 mutableList = self.getMutableList(dest)
392 if not mutableList is None:
393 if not mutableList.addService(self.servicelist.getCurrent()):
394 self.bouquetNumOffsetCache = { }
395 mutableList.flushChanges()
397 def toggleMoveMode(self):
399 if self.entry_marked:
400 self.toggleMoveMarked() # unmark current entry
401 self.movemode = False
402 self.pathChangedDisabled = False # re-enable path change
403 self.mutableList.flushChanges() # FIXME add check if changes was made
404 self.mutableList = None
405 self.setTitle(self.saved_title)
406 self.saved_title = None
407 if self.getRoot() == self.bouquet_root:
408 self.bouquetNumOffsetCache = { }
410 self.mutableList = self.getMutableList()
412 self.pathChangedDisabled = True # no path change allowed in movemode
413 self.saved_title = self.instance.getTitle()
414 new_title = self.saved_title
415 pos = self.saved_title.find(')')
416 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
417 self.setTitle(new_title);
419 def handleEditCancel(self):
420 if self.movemode: #movemode active?
421 self.channelSelected() # unmark
422 self.toggleMoveMode() # disable move mode
423 elif self.bouquet_mark_edit:
424 self.endMarkedEdit(True) # abort edit mode
426 def toggleMoveMarked(self):
427 if self.entry_marked:
428 self.servicelist.setCurrentMarked(False)
429 self.entry_marked = False
431 self.servicelist.setCurrentMarked(True)
432 self.entry_marked = True
435 self.session.open(ChannelContextMenu, self)
440 class ChannelSelectionBase(Screen):
441 def __init__(self, session):
442 Screen.__init__(self, session)
444 # this makes it much simple to implement a selectable radio or tv mode :)
445 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195)'
446 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
448 self["key_red"] = Button(_("All"))
449 self["key_green"] = Button(_("Satellites"))
450 self["key_yellow"] = Button(_("Provider"))
451 self["key_blue"] = Button(_("Favourites"))
453 self["list"] = ServiceList()
454 self.servicelist = self["list"]
456 self.numericalTextInput = NumericalTextInput()
458 self.servicePathTV = [ ]
459 self.servicePathRadio = [ ]
460 self.servicePath = [ ]
464 self.pathChangedDisabled = False
466 self.bouquetNumOffsetCache = { }
468 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
470 "showFavourites": self.showFavourites,
471 "showAllServices": self.showAllServices,
472 "showProviders": self.showProviders,
473 "showSatellites": self.showSatellites,
474 "nextBouquet": self.nextBouquet,
475 "prevBouquet": self.prevBouquet,
476 "1": self.keyNumberGlobal,
477 "2": self.keyNumberGlobal,
478 "3": self.keyNumberGlobal,
479 "4": self.keyNumberGlobal,
480 "5": self.keyNumberGlobal,
481 "6": self.keyNumberGlobal,
482 "7": self.keyNumberGlobal,
483 "8": self.keyNumberGlobal,
484 "9": self.keyNumberGlobal,
488 def appendDVBTypes(self, ref):
490 pos = path.find(' FROM BOUQUET')
492 return eServiceReference(self.service_types + path[pos:])
495 def getBouquetNumOffset(self, bouquet):
496 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
498 bouquet = self.appendDVBTypes(bouquet)
500 return self.bouquetNumOffsetCache[bouquet.toString()]
503 serviceHandler = eServiceCenter.getInstance()
504 bouquetlist = serviceHandler.list(self.bouquet_root)
505 if not bouquetlist is None:
507 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
508 if not bouquetIterator.valid(): #end of list
510 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
511 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
513 servicelist = serviceHandler.list(bouquetIterator)
514 if not servicelist is None:
516 serviceIterator = servicelist.getNext()
517 if not serviceIterator.valid(): #check if end of list
519 if serviceIterator.flags: #playable services have no flags
522 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
524 def recallBouquetMode(self):
525 if self.mode == MODE_TV:
526 self.service_types = self.service_types_tv
527 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
528 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
530 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
532 self.service_types = self.service_types_radio
533 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
534 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
536 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
537 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
541 self.servicePath = self.servicePathTV
542 self.recallBouquetMode()
543 title = self.instance.getTitle()
544 pos = title.find(" (")
550 def setRadioMode(self):
551 self.mode = MODE_RADIO
552 self.servicePath = self.servicePathRadio
553 self.recallBouquetMode()
554 title = self.instance.getTitle()
555 pos = title.find(" (")
561 def setRoot(self, root, justSet=False):
562 path = root.getPath()
563 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
564 pos = path.find(' FROM BOUQUET')
565 isBouquet = pos != -1
566 if not inBouquetRootList and isBouquet:
567 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
568 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
569 refstr = self.service_types + path[pos:]
570 root = eServiceReference(refstr)
572 self.servicelist.setMode(ServiceList.MODE_NORMAL)
573 self.servicelist.setRoot(root, justSet)
574 self.buildTitleString()
576 def removeModeStr(self, str):
577 if self.mode == MODE_TV:
578 pos = str.find(' (TV)')
580 pos = str.find(' (Radio)')
585 def getServiceName(self, ref):
586 str = self.removeModeStr(ServiceReference(ref).getServiceName())
588 pathstr = ref.getPath()
589 if pathstr.find('FROM PROVIDERS') != -1:
591 if pathstr.find('FROM SATELLITES') != -1:
592 return _("Satellites")
593 if pathstr.find(') ORDER BY name') != -1:
597 def buildTitleString(self):
598 titleStr = self.instance.getTitle()
599 pos = titleStr.find(']')
601 pos = titleStr.find(')')
603 titleStr = titleStr[:pos+1]
604 Len = len(self.servicePath)
606 base_ref = self.servicePath[0]
608 end_ref = self.servicePath[Len-1]
611 nameStr = self.getServiceName(base_ref)
612 titleStr += ' ' + nameStr
613 if end_ref is not None:
618 nameStr = self.getServiceName(end_ref)
620 self.setTitle(titleStr)
623 self.servicelist.moveUp()
626 self.servicelist.moveDown()
629 del self.servicePath[:]
631 def enterPath(self, ref, justSet=False):
632 self.servicePath.append(ref)
633 self.setRoot(ref, justSet)
635 def pathUp(self, justSet=False):
636 prev = self.servicePath.pop()
637 length = len(self.servicePath)
639 current = self.servicePath[length-1]
640 self.setRoot(current, justSet)
642 self.setCurrentSelection(prev)
645 def isBasePathEqual(self, ref):
646 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
650 def isPrevPathEqual(self, ref):
651 length = len(self.servicePath)
652 if length > 1 and self.servicePath[length-2] == ref:
656 def preEnterPath(self, refstr):
659 def showAllServices(self):
660 if not self.pathChangedDisabled:
661 refstr = '%s ORDER BY name'%(self.service_types)
662 if not self.preEnterPath(refstr):
663 ref = eServiceReference(refstr)
664 currentRoot = self.getRoot()
665 if currentRoot is None or currentRoot != ref:
669 def showSatellites(self):
670 if not self.pathChangedDisabled:
671 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
672 if not self.preEnterPath(refstr):
673 ref = eServiceReference(refstr)
677 if self.isBasePathEqual(ref):
678 if self.isPrevPathEqual(ref):
680 prev = self.pathUp(justSet)
682 currentRoot = self.getRoot()
683 if currentRoot is None or currentRoot != ref:
686 self.enterPath(ref, True)
688 serviceHandler = eServiceCenter.getInstance()
689 servicelist = serviceHandler.list(ref)
690 if not servicelist is None:
692 service = servicelist.getNext()
693 if not service.valid(): #check if end of list
695 orbpos = service.getData(4) >> 16
696 if service.getPath().find("FROM PROVIDER") != -1:
697 service_name = _("Providers")
699 service_name = _("Services")
701 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
702 service.setName(service_name) # why we need this cast?
704 if orbpos == 0xFFFF0000: #Cable
705 n = ("%s (%s)") % (service_name, _("Cable"))
706 elif orbpos == 0xEEEE0000: #Terrestrial
707 n = ("%s (%s)") % (service_name, _("Terrestrial"))
709 if orbpos > 1800: # west
710 orbpos = 3600 - orbpos
714 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
716 self.servicelist.addService(service)
717 self.servicelist.finishFill()
719 self.setCurrentSelection(prev)
721 def showProviders(self):
722 if not self.pathChangedDisabled:
723 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
724 if not self.preEnterPath(refstr):
725 ref = eServiceReference(refstr)
726 if self.isBasePathEqual(ref):
729 currentRoot = self.getRoot()
730 if currentRoot is None or currentRoot != ref:
734 def changeBouquet(self, direction):
735 if not self.pathChangedDisabled:
736 if self.isBasePathEqual(self.bouquet_root):
742 ref = self.getCurrentSelection()
746 return self.isBasePathEqual(self.bouquet_root)
749 return self.servicelist.atBegin()
752 return self.servicelist.atEnd()
754 def nextBouquet(self):
755 self.changeBouquet(+1)
757 def prevBouquet(self):
758 self.changeBouquet(-1)
760 def showFavourites(self):
761 if not self.pathChangedDisabled:
762 if not self.preEnterPath(self.bouquet_rootstr):
763 if self.isBasePathEqual(self.bouquet_root):
766 currentRoot = self.getRoot()
767 if currentRoot is None or currentRoot != self.bouquet_root:
769 self.enterPath(self.bouquet_root)
771 def keyNumberGlobal(self, number):
772 char = self.numericalTextInput.getKey(number)
773 self.servicelist.moveToChar(char)
776 return self.servicelist.getRoot()
778 def getCurrentSelection(self):
779 return self.servicelist.getCurrent()
781 def setCurrentSelection(self, service):
782 servicepath = service.getPath()
783 pos = servicepath.find(" FROM BOUQUET")
785 if self.mode == MODE_TV:
786 servicepath = '(type == 1)' + servicepath[pos:]
788 servicepath = '(type == 2)' + servicepath[pos:]
789 service.setPath(servicepath)
790 self.servicelist.setCurrent(service)
792 def getBouquetList(self):
795 serviceHandler = eServiceCenter.getInstance()
796 list = serviceHandler.list(self.bouquet_root)
802 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
803 info = serviceHandler.info(s)
805 bouquets.append((info.getName(s), s))
808 if len(bouquets) == 0 and serviceCount > 0:
809 info = serviceHandler.info(self.bouquet_root)
811 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
815 def keyNumber0(self, num):
816 if len(self.servicePath) > 1:
819 self.keyNumberGlobal(num)
822 if len(self.servicePath) > 1:
823 if self.isBasePathEqual(self.bouquet_root):
824 self.showFavourites()
826 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
827 if self.isBasePathEqual(ref):
828 self.showSatellites()
830 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
831 if self.isBasePathEqual(ref):
834 self.showAllServices()
838 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
839 def __init__(self, session):
840 ChannelSelectionBase.__init__(self,session)
841 ChannelSelectionEdit.__init__(self)
842 ChannelSelectionEPG.__init__(self)
844 #config for lastservice
845 config.tv = ConfigSubsection();
846 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
847 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
849 self["actions"] = ActionMap(["OkCancelActions"],
851 "cancel": self.cancel,
852 "ok": self.channelSelected,
854 self.onShown.append(self.__onShown)
856 self.lastChannelRootTimer = eTimer()
857 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
858 self.lastChannelRootTimer.start(100,True)
863 def __onCreate(self):
866 lastservice=eServiceReference(config.tv.lastservice.value)
867 if lastservice.valid():
868 self.setCurrentSelection(lastservice)
872 self.recallBouquetMode()
873 ref = self.session.nav.getCurrentlyPlayingServiceReference()
874 if ref is not None and ref.valid() and ref.getPath() == "":
875 self.servicelist.setPlayableIgnoreService(ref)
877 self.servicelist.setPlayableIgnoreService(eServiceReference())
879 def channelSelected(self):
880 ref = self.getCurrentSelection()
882 self.toggleMoveMarked()
883 elif (ref.flags & 7) == 7:
885 elif self.bouquet_mark_edit:
891 #called from infoBar and channelSelected
893 ref = self.session.nav.getCurrentlyPlayingServiceReference()
894 nref = self.getCurrentSelection()
895 if ref is None or ref != nref:
896 self.session.nav.playService(nref)
899 if self.servicePath is not None:
900 tmp=self.servicePath[:]
903 del self.history[self.history_pos+1:]
906 self.history.append(tmp)
907 hlen = len(self.history)
908 if hlen > HISTORYSIZE:
911 self.history_pos = hlen-1
913 def historyBack(self):
914 hlen = len(self.history)
915 if hlen > 1 and self.history_pos > 0:
916 self.history_pos -= 1
917 self.setHistoryPath()
919 def historyNext(self):
920 hlen = len(self.history)
921 if hlen > 1 and self.history_pos < (hlen-1):
922 self.history_pos += 1
923 self.setHistoryPath()
925 def setHistoryPath(self):
926 path = self.history[self.history_pos][:]
928 del self.servicePath[:]
929 self.servicePath += path
933 if self.getRoot() != root:
935 self.session.nav.playService(ref)
936 self.setCurrentSelection(ref)
941 for i in self.servicePathTV:
944 if len(path) and path != config.tv.lastroot.value:
945 config.tv.lastroot.value = path
946 config.tv.lastroot.save()
948 def restoreRoot(self):
951 tmp = re.findall(config.tv.lastroot.value)
954 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
957 path = self.servicePathTV.pop()
960 self.showFavourites()
963 def preEnterPath(self, refstr):
964 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
965 pathstr = config.tv.lastroot.value
966 if pathstr is not None and pathstr.find(refstr) == 0:
968 lastservice=eServiceReference(config.tv.lastservice.value)
969 if lastservice.valid():
970 self.setCurrentSelection(lastservice)
974 def saveChannel(self):
975 ref = self.session.nav.getCurrentlyPlayingServiceReference()
977 refstr = ref.toString()
980 if refstr != config.tv.lastservice.value:
981 config.tv.lastservice.value = refstr
982 config.tv.lastservice.save()
984 def recallPrevService(self):
985 hlen = len(self.history)
987 if self.history_pos == hlen-1:
988 tmp = self.history[self.history_pos]
989 self.history[self.history_pos] = self.history[self.history_pos-1]
990 self.history[self.history_pos-1] = tmp
992 tmp = self.history[self.history_pos+1]
993 self.history[self.history_pos+1] = self.history[self.history_pos]
994 self.history[self.history_pos] = tmp
995 self.setHistoryPath()
1000 lastservice=eServiceReference(config.tv.lastservice.value)
1001 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1002 self.setCurrentSelection(lastservice)
1004 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
1006 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
1007 def __init__(self, session):
1008 Screen.__init__(self, session)
1009 InfoBarEvent.__init__(self)
1010 InfoBarServiceName.__init__(self)
1011 InfoBarInstantRecord.__init__(self)
1012 self["Clock"] = Clock()
1014 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
1015 def __init__(self, session):
1016 ChannelSelectionBase.__init__(self, session)
1017 ChannelSelectionEdit.__init__(self)
1018 ChannelSelectionEPG.__init__(self)
1020 config.radio = ConfigSubsection();
1021 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
1022 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
1023 self.onLayoutFinish.append(self.onCreate)
1025 self.info = session.instantiateDialog(RadioInfoBar)
1027 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1029 "keyTV": self.closeRadio,
1030 "keyRadio": self.closeRadio,
1031 "cancel": self.closeRadio,
1032 "ok": self.channelSelected,
1037 for i in self.servicePathRadio:
1038 path += i.toString()
1040 if len(path) and path != config.radio.lastroot.value:
1041 config.radio.lastroot.value = path
1042 config.radio.lastroot.save()
1044 def restoreRoot(self):
1046 re = compile('.+?;')
1047 tmp = re.findall(config.radio.lastroot.value)
1050 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1053 path = self.servicePathRadio.pop()
1054 self.enterPath(path)
1056 self.showFavourites()
1059 def preEnterPath(self, refstr):
1060 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1061 pathstr = config.radio.lastroot.value
1062 if pathstr is not None and pathstr.find(refstr) == 0:
1064 lastservice=eServiceReference(config.radio.lastservice.value)
1065 if lastservice.valid():
1066 self.setCurrentSelection(lastservice)
1073 lastservice=eServiceReference(config.radio.lastservice.value)
1074 if lastservice.valid():
1075 self.servicelist.setCurrent(lastservice)
1076 self.session.nav.playService(lastservice)
1077 self.servicelist.setPlayableIgnoreService(lastservice)
1080 def channelSelected(self): # just return selected service
1081 ref = self.getCurrentSelection()
1083 self.toggleMoveMarked()
1084 elif (ref.flags & 7) == 7:
1086 elif self.bouquet_mark_edit:
1089 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1090 if playingref is None or playingref != ref:
1091 self.session.nav.playService(ref)
1092 self.servicelist.setPlayableIgnoreService(ref)
1093 config.radio.lastservice.value = ref.toString()
1094 config.radio.lastservice.save()
1097 def closeRadio(self):
1099 #set previous tv service
1100 lastservice=eServiceReference(config.tv.lastservice.value)
1101 self.session.nav.playService(lastservice)
1104 class SimpleChannelSelection(ChannelSelectionBase):
1105 def __init__(self, session, title):
1106 ChannelSelectionBase.__init__(self, session)
1108 self.onShown.append(self.__onExecCallback)
1110 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1112 "cancel": self.close,
1113 "ok": self.channelSelected,
1114 "keyRadio": self.setModeRadio,
1115 "keyTV": self.setModeTv,
1118 def __onExecCallback(self):
1119 self.setTitle(self.title)
1122 def channelSelected(self): # just return selected service
1123 ref = self.getCurrentSelection()
1124 if (ref.flags & 7) == 7:
1127 ref = self.getCurrentSelection()
1130 def setModeTv(self):
1132 self.showFavourites()
1134 def setModeRadio(self):
1136 self.showFavourites()