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)
287 services = serviceHandler.list(provider.ref)
288 if not services is None:
289 list = services.getContent('R', True)
291 if mutableBouquet.addService(service):
292 print "add", service.toString(), "to new bouquet failed"
293 mutableBouquet.flushChanges()
295 print "list provider", providerName, "failed"
297 print "get mutable list for new created bouquet failed"
299 print "add", str, "to bouquets failed"
301 print "bouquetlist is not editable"
303 def removeBouquet(self):
304 refstr = self.getCurrentSelection().toString()
305 self.bouquetNumOffsetCache = { }
306 pos = refstr.find('FROM BOUQUET "')
308 refstr = refstr[pos+14:]
309 pos = refstr.find('"')
311 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
312 self.removeCurrentService()
316 print "error during remove of", filename
317 eDVBDB.getInstance().reloadBouquets()
319 # multiple marked entry stuff ( edit mode, later multiepg selection )
320 def startMarkedEdit(self):
321 self.mutableList = self.getMutableList()
322 # add all services from the current list to internal marked set in listboxservicecontent
323 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
324 self.saved_title = self.instance.getTitle()
325 pos = self.saved_title.find(')')
326 new_title = self.saved_title[:pos+1]
327 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
328 new_title += ' ' + _("[bouquet edit]")
330 new_title += ' ' + _("[favourite edit]")
331 self.setTitle(new_title)
332 self.bouquet_mark_edit = True
333 self.__marked = self.servicelist.getRootServices()
334 for x in self.__marked:
335 self.servicelist.addMarked(eServiceReference(x))
336 self.savedPath = self.servicePath[:]
337 self.showAllServices()
339 def endMarkedEdit(self, abort):
340 if not abort and self.mutableList is not None:
341 self.bouquetNumOffsetCache = { }
342 new_marked = set(self.servicelist.getMarked())
343 old_marked = set(self.__marked)
344 removed = old_marked - new_marked
345 added = new_marked - old_marked
349 self.mutableList.removeService(eServiceReference(x))
352 self.mutableList.addService(eServiceReference(x))
354 self.mutableList.flushChanges()
357 self.bouquet_mark_edit = False
358 self.mutableList = None
359 self.setTitle(self.saved_title)
360 self.saved_title = None
361 # self.servicePath is just a reference to servicePathTv or Radio...
362 # so we never ever do use the asignment operator in self.servicePath
363 del self.servicePath[:] # remove all elements
364 self.servicePath += self.savedPath # add saved elements
366 self.setRoot(self.servicePath[len(self.servicePath)-1])
368 def clearMarks(self):
369 self.servicelist.clearMarks()
372 ref = self.servicelist.getCurrent()
373 if self.servicelist.isMarked(ref):
374 self.servicelist.removeMarked(ref)
376 self.servicelist.addMarked(ref)
378 def removeCurrentService(self):
379 ref = self.servicelist.getCurrent()
380 mutableList = self.getMutableList()
381 if ref.valid() and mutableList is not None:
382 if not mutableList.removeService(ref):
383 self.bouquetNumOffsetCache = { }
384 mutableList.flushChanges() #FIXME dont flush on each single removed service
385 self.setRoot(self.getRoot())
387 def addCurrentServiceToBouquet(self, dest):
388 mutableList = self.getMutableList(dest)
389 if not mutableList is None:
390 if not mutableList.addService(self.servicelist.getCurrent()):
391 self.bouquetNumOffsetCache = { }
392 mutableList.flushChanges()
394 def toggleMoveMode(self):
396 if self.entry_marked:
397 self.toggleMoveMarked() # unmark current entry
398 self.movemode = False
399 self.pathChangedDisabled = False # re-enable path change
400 self.mutableList.flushChanges() # FIXME add check if changes was made
401 self.mutableList = None
402 self.setTitle(self.saved_title)
403 self.saved_title = None
404 if self.getRoot() == self.bouquet_root:
405 self.bouquetNumOffsetCache = { }
407 self.mutableList = self.getMutableList()
409 self.pathChangedDisabled = True # no path change allowed in movemode
410 self.saved_title = self.instance.getTitle()
411 new_title = self.saved_title
412 pos = self.saved_title.find(')')
413 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
414 self.setTitle(new_title);
416 def handleEditCancel(self):
417 if self.movemode: #movemode active?
418 self.channelSelected() # unmark
419 self.toggleMoveMode() # disable move mode
420 elif self.bouquet_mark_edit:
421 self.endMarkedEdit(True) # abort edit mode
423 def toggleMoveMarked(self):
424 if self.entry_marked:
425 self.servicelist.setCurrentMarked(False)
426 self.entry_marked = False
428 self.servicelist.setCurrentMarked(True)
429 self.entry_marked = True
432 self.session.open(ChannelContextMenu, self)
437 class ChannelSelectionBase(Screen):
438 def __init__(self, session):
439 Screen.__init__(self, session)
441 # this makes it much simple to implement a selectable radio or tv mode :)
442 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195)'
443 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
445 self["key_red"] = Button(_("All"))
446 self["key_green"] = Button(_("Satellites"))
447 self["key_yellow"] = Button(_("Provider"))
448 self["key_blue"] = Button(_("Favourites"))
450 self["list"] = ServiceList()
451 self.servicelist = self["list"]
453 self.numericalTextInput = NumericalTextInput()
455 self.servicePathTV = [ ]
456 self.servicePathRadio = [ ]
457 self.servicePath = [ ]
461 self.pathChangedDisabled = False
463 self.bouquetNumOffsetCache = { }
465 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
467 "showFavourites": self.showFavourites,
468 "showAllServices": self.showAllServices,
469 "showProviders": self.showProviders,
470 "showSatellites": self.showSatellites,
471 "nextBouquet": self.nextBouquet,
472 "prevBouquet": self.prevBouquet,
473 "1": self.keyNumberGlobal,
474 "2": self.keyNumberGlobal,
475 "3": self.keyNumberGlobal,
476 "4": self.keyNumberGlobal,
477 "5": self.keyNumberGlobal,
478 "6": self.keyNumberGlobal,
479 "7": self.keyNumberGlobal,
480 "8": self.keyNumberGlobal,
481 "9": self.keyNumberGlobal,
485 def appendDVBTypes(self, ref):
487 pos = path.find(' FROM BOUQUET')
489 return eServiceReference(self.service_types + path[pos:])
492 def getBouquetNumOffset(self, bouquet):
493 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
495 bouquet = self.appendDVBTypes(bouquet)
497 return self.bouquetNumOffsetCache[bouquet.toString()]
500 serviceHandler = eServiceCenter.getInstance()
501 bouquetlist = serviceHandler.list(self.bouquet_root)
502 if not bouquetlist is None:
504 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
505 if not bouquetIterator.valid(): #end of list
507 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
508 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
510 servicelist = serviceHandler.list(bouquetIterator)
511 if not servicelist is None:
513 serviceIterator = servicelist.getNext()
514 if not serviceIterator.valid(): #check if end of list
516 if serviceIterator.flags: #playable services have no flags
519 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
521 def recallBouquetMode(self):
522 if self.mode == MODE_TV:
523 self.service_types = self.service_types_tv
524 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
525 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
527 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
529 self.service_types = self.service_types_radio
530 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
531 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
533 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
534 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
538 self.servicePath = self.servicePathTV
539 self.recallBouquetMode()
540 title = self.instance.getTitle()
541 pos = title.find(" (")
547 def setRadioMode(self):
548 self.mode = MODE_RADIO
549 self.servicePath = self.servicePathRadio
550 self.recallBouquetMode()
551 title = self.instance.getTitle()
552 pos = title.find(" (")
558 def setRoot(self, root, justSet=False):
559 path = root.getPath()
560 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
561 pos = path.find(' FROM BOUQUET')
562 isBouquet = pos != -1
563 if not inBouquetRootList and isBouquet:
564 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
565 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
566 refstr = self.service_types + path[pos:]
567 root = eServiceReference(refstr)
569 self.servicelist.setMode(ServiceList.MODE_NORMAL)
570 self.servicelist.setRoot(root, justSet)
571 self.buildTitleString()
573 def removeModeStr(self, str):
574 if self.mode == MODE_TV:
575 pos = str.find(' (TV)')
577 pos = str.find(' (Radio)')
582 def getServiceName(self, ref):
583 str = self.removeModeStr(ServiceReference(ref).getServiceName())
585 pathstr = ref.getPath()
586 if pathstr.find('FROM PROVIDERS') != -1:
588 if pathstr.find('FROM SATELLITES') != -1:
589 return _("Satellites")
590 if pathstr.find(') ORDER BY name') != -1:
594 def buildTitleString(self):
595 titleStr = self.instance.getTitle()
596 pos = titleStr.find(']')
598 pos = titleStr.find(')')
600 titleStr = titleStr[:pos+1]
601 Len = len(self.servicePath)
603 base_ref = self.servicePath[0]
605 end_ref = self.servicePath[Len-1]
608 nameStr = self.getServiceName(base_ref)
609 titleStr += ' ' + nameStr
610 if end_ref is not None:
615 nameStr = self.getServiceName(end_ref)
617 self.setTitle(titleStr)
620 self.servicelist.moveUp()
623 self.servicelist.moveDown()
626 del self.servicePath[:]
628 def enterPath(self, ref, justSet=False):
629 self.servicePath.append(ref)
630 self.setRoot(ref, justSet)
632 def pathUp(self, justSet=False):
633 prev = self.servicePath.pop()
634 length = len(self.servicePath)
636 current = self.servicePath[length-1]
637 self.setRoot(current, justSet)
639 self.setCurrentSelection(prev)
642 def isBasePathEqual(self, ref):
643 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
647 def isPrevPathEqual(self, ref):
648 length = len(self.servicePath)
649 if length > 1 and self.servicePath[length-2] == ref:
653 def preEnterPath(self, refstr):
656 def showAllServices(self):
657 if not self.pathChangedDisabled:
658 refstr = '%s ORDER BY name'%(self.service_types)
659 if not self.preEnterPath(refstr):
660 ref = eServiceReference(refstr)
661 currentRoot = self.getRoot()
662 if currentRoot is None or currentRoot != ref:
666 def showSatellites(self):
667 if not self.pathChangedDisabled:
668 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
669 if not self.preEnterPath(refstr):
670 ref = eServiceReference(refstr)
674 if self.isBasePathEqual(ref):
675 if self.isPrevPathEqual(ref):
677 prev = self.pathUp(justSet)
679 currentRoot = self.getRoot()
680 if currentRoot is None or currentRoot != ref:
683 self.enterPath(ref, True)
685 serviceHandler = eServiceCenter.getInstance()
686 servicelist = serviceHandler.list(ref)
687 if not servicelist is None:
689 service = servicelist.getNext()
690 if not service.valid(): #check if end of list
692 orbpos = service.getUnsignedData(4) >> 16
693 if service.getPath().find("FROM PROVIDER") != -1:
694 service_name = _("Providers")
696 service_name = _("Services")
698 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
699 service.setName(service_name) # why we need this cast?
701 if orbpos == 0xFFFF: #Cable
702 n = ("%s (%s)") % (service_name, _("Cable"))
703 elif orbpos == 0xEEEE: #Terrestrial
704 n = ("%s (%s)") % (service_name, _("Terrestrial"))
706 if orbpos > 1800: # west
707 orbpos = 3600 - orbpos
711 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
713 self.servicelist.addService(service)
714 self.servicelist.finishFill()
716 self.setCurrentSelection(prev)
718 def showProviders(self):
719 if not self.pathChangedDisabled:
720 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
721 if not self.preEnterPath(refstr):
722 ref = eServiceReference(refstr)
723 if self.isBasePathEqual(ref):
726 currentRoot = self.getRoot()
727 if currentRoot is None or currentRoot != ref:
731 def changeBouquet(self, direction):
732 if not self.pathChangedDisabled:
733 if self.isBasePathEqual(self.bouquet_root):
739 ref = self.getCurrentSelection()
743 return self.isBasePathEqual(self.bouquet_root)
746 return self.servicelist.atBegin()
749 return self.servicelist.atEnd()
751 def nextBouquet(self):
752 self.changeBouquet(+1)
754 def prevBouquet(self):
755 self.changeBouquet(-1)
757 def showFavourites(self):
758 if not self.pathChangedDisabled:
759 if not self.preEnterPath(self.bouquet_rootstr):
760 if self.isBasePathEqual(self.bouquet_root):
763 currentRoot = self.getRoot()
764 if currentRoot is None or currentRoot != self.bouquet_root:
766 self.enterPath(self.bouquet_root)
768 def keyNumberGlobal(self, number):
769 char = self.numericalTextInput.getKey(number)
770 self.servicelist.moveToChar(char)
773 return self.servicelist.getRoot()
775 def getCurrentSelection(self):
776 return self.servicelist.getCurrent()
778 def setCurrentSelection(self, service):
779 servicepath = service.getPath()
780 pos = servicepath.find(" FROM BOUQUET")
782 if self.mode == MODE_TV:
783 servicepath = '(type == 1)' + servicepath[pos:]
785 servicepath = '(type == 2)' + servicepath[pos:]
786 service.setPath(servicepath)
787 self.servicelist.setCurrent(service)
789 def getBouquetList(self):
792 serviceHandler = eServiceCenter.getInstance()
793 list = serviceHandler.list(self.bouquet_root)
799 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
800 info = serviceHandler.info(s)
802 bouquets.append((info.getName(s), s))
805 if len(bouquets) == 0 and serviceCount > 0:
806 info = serviceHandler.info(self.bouquet_root)
808 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
812 def keyNumber0(self, num):
813 if len(self.servicePath) > 1:
816 self.keyNumberGlobal(num)
819 if len(self.servicePath) > 1:
820 if self.isBasePathEqual(self.bouquet_root):
821 self.showFavourites()
823 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
824 if self.isBasePathEqual(ref):
825 self.showSatellites()
827 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
828 if self.isBasePathEqual(ref):
831 self.showAllServices()
835 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
836 def __init__(self, session):
837 ChannelSelectionBase.__init__(self,session)
838 ChannelSelectionEdit.__init__(self)
839 ChannelSelectionEPG.__init__(self)
841 #config for lastservice
842 config.tv = ConfigSubsection();
843 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
844 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
846 self["actions"] = ActionMap(["OkCancelActions"],
848 "cancel": self.cancel,
849 "ok": self.channelSelected,
851 self.onShown.append(self.__onShown)
853 self.lastChannelRootTimer = eTimer()
854 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
855 self.lastChannelRootTimer.start(100,True)
860 def __onCreate(self):
863 lastservice=eServiceReference(config.tv.lastservice.value)
864 if lastservice.valid():
865 self.setCurrentSelection(lastservice)
869 self.recallBouquetMode()
870 ref = self.session.nav.getCurrentlyPlayingServiceReference()
871 if ref is not None and ref.valid() and ref.getPath() == "":
872 self.servicelist.setPlayableIgnoreService(ref)
874 self.servicelist.setPlayableIgnoreService(eServiceReference())
876 def channelSelected(self):
877 ref = self.getCurrentSelection()
879 self.toggleMoveMarked()
880 elif (ref.flags & 7) == 7:
882 elif self.bouquet_mark_edit:
888 #called from infoBar and channelSelected
890 ref = self.session.nav.getCurrentlyPlayingServiceReference()
891 nref = self.getCurrentSelection()
892 if ref is None or ref != nref:
893 self.session.nav.playService(nref)
896 if self.servicePath is not None:
897 tmp=self.servicePath[:]
900 del self.history[self.history_pos+1:]
903 self.history.append(tmp)
904 hlen = len(self.history)
905 if hlen > HISTORYSIZE:
908 self.history_pos = hlen-1
910 def historyBack(self):
911 hlen = len(self.history)
912 if hlen > 1 and self.history_pos > 0:
913 self.history_pos -= 1
914 self.setHistoryPath()
916 def historyNext(self):
917 hlen = len(self.history)
918 if hlen > 1 and self.history_pos < (hlen-1):
919 self.history_pos += 1
920 self.setHistoryPath()
922 def setHistoryPath(self):
923 path = self.history[self.history_pos][:]
925 del self.servicePath[:]
926 self.servicePath += path
930 if self.getRoot() != root:
932 self.session.nav.playService(ref)
933 self.setCurrentSelection(ref)
938 for i in self.servicePathTV:
941 if len(path) and path != config.tv.lastroot.value:
942 config.tv.lastroot.value = path
943 config.tv.lastroot.save()
945 def restoreRoot(self):
948 tmp = re.findall(config.tv.lastroot.value)
951 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
954 path = self.servicePathTV.pop()
957 self.showFavourites()
960 def preEnterPath(self, refstr):
961 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
962 pathstr = config.tv.lastroot.value
963 if pathstr is not None and pathstr.find(refstr) == 0:
965 lastservice=eServiceReference(config.tv.lastservice.value)
966 if lastservice.valid():
967 self.setCurrentSelection(lastservice)
971 def saveChannel(self):
972 ref = self.session.nav.getCurrentlyPlayingServiceReference()
974 refstr = ref.toString()
977 if refstr != config.tv.lastservice.value:
978 config.tv.lastservice.value = refstr
979 config.tv.lastservice.save()
981 def recallPrevService(self):
982 hlen = len(self.history)
984 if self.history_pos == hlen-1:
985 tmp = self.history[self.history_pos]
986 self.history[self.history_pos] = self.history[self.history_pos-1]
987 self.history[self.history_pos-1] = tmp
989 tmp = self.history[self.history_pos+1]
990 self.history[self.history_pos+1] = self.history[self.history_pos]
991 self.history[self.history_pos] = tmp
992 self.setHistoryPath()
997 lastservice=eServiceReference(config.tv.lastservice.value)
998 if lastservice.valid() and self.getCurrentSelection() != lastservice:
999 self.setCurrentSelection(lastservice)
1001 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
1003 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
1004 def __init__(self, session):
1005 Screen.__init__(self, session)
1006 InfoBarEvent.__init__(self)
1007 InfoBarServiceName.__init__(self)
1008 InfoBarInstantRecord.__init__(self)
1009 self["Clock"] = Clock()
1011 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
1012 def __init__(self, session):
1013 ChannelSelectionBase.__init__(self, session)
1014 ChannelSelectionEdit.__init__(self)
1015 ChannelSelectionEPG.__init__(self)
1017 config.radio = ConfigSubsection();
1018 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
1019 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
1020 self.onLayoutFinish.append(self.onCreate)
1022 self.info = session.instantiateDialog(RadioInfoBar)
1024 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1026 "keyTV": self.closeRadio,
1027 "keyRadio": self.closeRadio,
1028 "cancel": self.closeRadio,
1029 "ok": self.channelSelected,
1034 for i in self.servicePathRadio:
1035 path += i.toString()
1037 if len(path) and path != config.radio.lastroot.value:
1038 config.radio.lastroot.value = path
1039 config.radio.lastroot.save()
1041 def restoreRoot(self):
1043 re = compile('.+?;')
1044 tmp = re.findall(config.radio.lastroot.value)
1047 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1050 path = self.servicePathRadio.pop()
1051 self.enterPath(path)
1053 self.showFavourites()
1056 def preEnterPath(self, refstr):
1057 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1058 pathstr = config.radio.lastroot.value
1059 if pathstr is not None and pathstr.find(refstr) == 0:
1061 lastservice=eServiceReference(config.radio.lastservice.value)
1062 if lastservice.valid():
1063 self.setCurrentSelection(lastservice)
1070 lastservice=eServiceReference(config.radio.lastservice.value)
1071 if lastservice.valid():
1072 self.servicelist.setCurrent(lastservice)
1073 self.session.nav.playService(lastservice)
1074 self.servicelist.setPlayableIgnoreService(lastservice)
1077 def channelSelected(self): # just return selected service
1078 ref = self.getCurrentSelection()
1080 self.toggleMoveMarked()
1081 elif (ref.flags & 7) == 7:
1083 elif self.bouquet_mark_edit:
1086 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1087 if playingref is None or playingref != ref:
1088 self.session.nav.playService(ref)
1089 self.servicelist.setPlayableIgnoreService(ref)
1090 config.radio.lastservice.value = ref.toString()
1091 config.radio.lastservice.save()
1094 def closeRadio(self):
1096 #set previous tv service
1097 lastservice=eServiceReference(config.tv.lastservice.value)
1098 self.session.nav.playService(lastservice)
1101 class SimpleChannelSelection(ChannelSelectionBase):
1102 def __init__(self, session, title):
1103 ChannelSelectionBase.__init__(self, session)
1105 self.onShown.append(self.__onExecCallback)
1107 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1109 "cancel": self.close,
1110 "ok": self.channelSelected,
1111 "keyRadio": self.setModeRadio,
1112 "keyTV": self.setModeTv,
1115 def __onExecCallback(self):
1116 self.setTitle(self.title)
1119 def channelSelected(self): # just return selected service
1120 ref = self.getCurrentSelection()
1121 if (ref.flags & 7) == 7:
1124 ref = self.getCurrentSelection()
1127 def setModeTv(self):
1129 self.showFavourites()
1131 def setModeRadio(self):
1133 self.showFavourites()