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, True)
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, bName, services, refresh=False):
243 serviceHandler = eServiceCenter.getInstance()
244 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
245 if mutableBouquetList:
246 if self.mode == MODE_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(bName))
251 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
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(bName)
260 if services is not None:
261 for service in services:
262 if mutableBouquet.addService(service):
263 print "add", service.toString(), "to new bouquet failed"
264 mutableBouquet.flushChanges()
266 self.setRoot(self.getRoot())
268 print "get mutable list for new created bouquet failed"
270 print "add", str, "to bouquets failed"
272 print "bouquetlist is not editable"
274 def copyCurrentToBouquetList(self):
275 provider = ServiceReference(self.getCurrentSelection())
276 providerName = provider.getServiceName()
277 serviceHandler = eServiceCenter.getInstance()
278 services = serviceHandler.list(provider.ref)
279 self.addBouquet(providerName, services and services.getContent('R', True))
281 def removeBouquet(self):
282 refstr = self.getCurrentSelection().toString()
283 self.bouquetNumOffsetCache = { }
284 pos = refstr.find('FROM BOUQUET "')
286 refstr = refstr[pos+14:]
287 pos = refstr.find('"')
289 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
290 self.removeCurrentService()
294 print "error during remove of", filename
295 eDVBDB.getInstance().reloadBouquets()
297 # multiple marked entry stuff ( edit mode, later multiepg selection )
298 def startMarkedEdit(self):
299 self.mutableList = self.getMutableList()
300 # add all services from the current list to internal marked set in listboxservicecontent
301 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
302 self.saved_title = self.instance.getTitle()
303 pos = self.saved_title.find(')')
304 new_title = self.saved_title[:pos+1]
305 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') != -1:
306 new_title += ' ' + _("[bouquet edit]")
308 new_title += ' ' + _("[favourite edit]")
309 self.setTitle(new_title)
310 self.bouquet_mark_edit = True
311 self.__marked = self.servicelist.getRootServices()
312 for x in self.__marked:
313 self.servicelist.addMarked(eServiceReference(x))
314 self.savedPath = self.servicePath[:]
315 self.showAllServices()
317 def endMarkedEdit(self, abort):
318 if not abort and self.mutableList is not None:
319 self.bouquetNumOffsetCache = { }
320 new_marked = set(self.servicelist.getMarked())
321 old_marked = set(self.__marked)
322 removed = old_marked - new_marked
323 added = new_marked - old_marked
327 self.mutableList.removeService(eServiceReference(x))
330 self.mutableList.addService(eServiceReference(x))
332 self.mutableList.flushChanges()
335 self.bouquet_mark_edit = False
336 self.mutableList = None
337 self.setTitle(self.saved_title)
338 self.saved_title = None
339 # self.servicePath is just a reference to servicePathTv or Radio...
340 # so we never ever do use the asignment operator in self.servicePath
341 del self.servicePath[:] # remove all elements
342 self.servicePath += self.savedPath # add saved elements
344 self.setRoot(self.servicePath[len(self.servicePath)-1])
346 def clearMarks(self):
347 self.servicelist.clearMarks()
350 ref = self.servicelist.getCurrent()
351 if self.servicelist.isMarked(ref):
352 self.servicelist.removeMarked(ref)
354 self.servicelist.addMarked(ref)
356 def removeCurrentService(self):
357 ref = self.servicelist.getCurrent()
358 mutableList = self.getMutableList()
359 if ref.valid() and mutableList is not None:
360 if not mutableList.removeService(ref):
361 self.bouquetNumOffsetCache = { }
362 mutableList.flushChanges() #FIXME dont flush on each single removed service
363 self.setRoot(self.getRoot())
365 def addCurrentServiceToBouquet(self, dest):
366 mutableList = self.getMutableList(dest)
367 if not mutableList is None:
368 if not mutableList.addService(self.servicelist.getCurrent()):
369 self.bouquetNumOffsetCache = { }
370 mutableList.flushChanges()
372 def toggleMoveMode(self):
374 if self.entry_marked:
375 self.toggleMoveMarked() # unmark current entry
376 self.movemode = False
377 self.pathChangedDisabled = False # re-enable path change
378 self.mutableList.flushChanges() # FIXME add check if changes was made
379 self.mutableList = None
380 self.setTitle(self.saved_title)
381 self.saved_title = None
382 if self.getRoot() == self.bouquet_root:
383 self.bouquetNumOffsetCache = { }
385 self.mutableList = self.getMutableList()
387 self.pathChangedDisabled = True # no path change allowed in movemode
388 self.saved_title = self.instance.getTitle()
389 new_title = self.saved_title
390 pos = self.saved_title.find(')')
391 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
392 self.setTitle(new_title);
394 def handleEditCancel(self):
395 if self.movemode: #movemode active?
396 self.channelSelected() # unmark
397 self.toggleMoveMode() # disable move mode
398 elif self.bouquet_mark_edit:
399 self.endMarkedEdit(True) # abort edit mode
401 def toggleMoveMarked(self):
402 if self.entry_marked:
403 self.servicelist.setCurrentMarked(False)
404 self.entry_marked = False
406 self.servicelist.setCurrentMarked(True)
407 self.entry_marked = True
410 self.session.open(ChannelContextMenu, self)
415 class ChannelSelectionBase(Screen):
416 def __init__(self, session):
417 Screen.__init__(self, session)
419 # this makes it much simple to implement a selectable radio or tv mode :)
420 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195)'
421 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
423 self["key_red"] = Button(_("All"))
424 self["key_green"] = Button(_("Satellites"))
425 self["key_yellow"] = Button(_("Provider"))
426 self["key_blue"] = Button(_("Favourites"))
428 self["list"] = ServiceList()
429 self.servicelist = self["list"]
431 self.numericalTextInput = NumericalTextInput()
433 self.servicePathTV = [ ]
434 self.servicePathRadio = [ ]
435 self.servicePath = [ ]
439 self.pathChangedDisabled = False
441 self.bouquetNumOffsetCache = { }
443 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
445 "showFavourites": self.showFavourites,
446 "showAllServices": self.showAllServices,
447 "showProviders": self.showProviders,
448 "showSatellites": self.showSatellites,
449 "nextBouquet": self.nextBouquet,
450 "prevBouquet": self.prevBouquet,
451 "1": self.keyNumberGlobal,
452 "2": self.keyNumberGlobal,
453 "3": self.keyNumberGlobal,
454 "4": self.keyNumberGlobal,
455 "5": self.keyNumberGlobal,
456 "6": self.keyNumberGlobal,
457 "7": self.keyNumberGlobal,
458 "8": self.keyNumberGlobal,
459 "9": self.keyNumberGlobal,
463 def appendDVBTypes(self, ref):
465 pos = path.find(' FROM BOUQUET')
467 return eServiceReference(self.service_types + path[pos:])
470 def getBouquetNumOffset(self, bouquet):
471 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
473 bouquet = self.appendDVBTypes(bouquet)
475 return self.bouquetNumOffsetCache[bouquet.toString()]
478 serviceHandler = eServiceCenter.getInstance()
479 bouquetlist = serviceHandler.list(self.bouquet_root)
480 if not bouquetlist is None:
482 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
483 if not bouquetIterator.valid(): #end of list
485 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
486 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
488 servicelist = serviceHandler.list(bouquetIterator)
489 if not servicelist is None:
491 serviceIterator = servicelist.getNext()
492 if not serviceIterator.valid(): #check if end of list
494 if serviceIterator.flags: #playable services have no flags
497 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
499 def recallBouquetMode(self):
500 if self.mode == MODE_TV:
501 self.service_types = self.service_types_tv
502 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
503 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
505 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
507 self.service_types = self.service_types_radio
508 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
509 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
511 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
512 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
516 self.servicePath = self.servicePathTV
517 self.recallBouquetMode()
518 title = self.instance.getTitle()
519 pos = title.find(" (")
525 def setRadioMode(self):
526 self.mode = MODE_RADIO
527 self.servicePath = self.servicePathRadio
528 self.recallBouquetMode()
529 title = self.instance.getTitle()
530 pos = title.find(" (")
536 def setRoot(self, root, justSet=False):
537 path = root.getPath()
538 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
539 pos = path.find(' FROM BOUQUET')
540 isBouquet = pos != -1
541 if not inBouquetRootList and isBouquet:
542 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
543 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
544 refstr = self.service_types + path[pos:]
545 root = eServiceReference(refstr)
547 self.servicelist.setMode(ServiceList.MODE_NORMAL)
548 self.servicelist.setRoot(root, justSet)
549 self.buildTitleString()
551 def removeModeStr(self, str):
552 if self.mode == MODE_TV:
553 pos = str.find(' (TV)')
555 pos = str.find(' (Radio)')
560 def getServiceName(self, ref):
561 str = self.removeModeStr(ServiceReference(ref).getServiceName())
563 pathstr = ref.getPath()
564 if pathstr.find('FROM PROVIDERS') != -1:
566 if pathstr.find('FROM SATELLITES') != -1:
567 return _("Satellites")
568 if pathstr.find(') ORDER BY name') != -1:
572 def buildTitleString(self):
573 titleStr = self.instance.getTitle()
574 pos = titleStr.find(']')
576 pos = titleStr.find(')')
578 titleStr = titleStr[:pos+1]
579 Len = len(self.servicePath)
581 base_ref = self.servicePath[0]
583 end_ref = self.servicePath[Len-1]
586 nameStr = self.getServiceName(base_ref)
587 titleStr += ' ' + nameStr
588 if end_ref is not None:
593 nameStr = self.getServiceName(end_ref)
595 self.setTitle(titleStr)
598 self.servicelist.moveUp()
601 self.servicelist.moveDown()
604 del self.servicePath[:]
606 def enterPath(self, ref, justSet=False):
607 self.servicePath.append(ref)
608 self.setRoot(ref, justSet)
610 def pathUp(self, justSet=False):
611 prev = self.servicePath.pop()
612 length = len(self.servicePath)
614 current = self.servicePath[length-1]
615 self.setRoot(current, justSet)
617 self.setCurrentSelection(prev)
620 def isBasePathEqual(self, ref):
621 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
625 def isPrevPathEqual(self, ref):
626 length = len(self.servicePath)
627 if length > 1 and self.servicePath[length-2] == ref:
631 def preEnterPath(self, refstr):
634 def showAllServices(self):
635 if not self.pathChangedDisabled:
636 refstr = '%s ORDER BY name'%(self.service_types)
637 if not self.preEnterPath(refstr):
638 ref = eServiceReference(refstr)
639 currentRoot = self.getRoot()
640 if currentRoot is None or currentRoot != ref:
644 def showSatellites(self):
645 if not self.pathChangedDisabled:
646 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
647 if not self.preEnterPath(refstr):
648 ref = eServiceReference(refstr)
652 if self.isBasePathEqual(ref):
653 if self.isPrevPathEqual(ref):
655 prev = self.pathUp(justSet)
657 currentRoot = self.getRoot()
658 if currentRoot is None or currentRoot != ref:
661 self.enterPath(ref, True)
663 serviceHandler = eServiceCenter.getInstance()
664 servicelist = serviceHandler.list(ref)
665 if not servicelist is None:
667 service = servicelist.getNext()
668 if not service.valid(): #check if end of list
670 orbpos = service.getUnsignedData(4) >> 16
671 if service.getPath().find("FROM PROVIDER") != -1:
672 service_name = _("Providers")
673 elif service.getPath().find("flags ==") != -1:
674 service_name = _("New")
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 == 0xFFFF: #Cable
682 n = ("%s (%s)") % (service_name, _("Cable"))
683 elif orbpos == 0xEEEE: #Terrestrial
684 n = ("%s (%s)") % (service_name, _("Terrestrial"))
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))
792 def keyNumber0(self, num):
793 if len(self.servicePath) > 1:
796 self.keyNumberGlobal(num)
799 if len(self.servicePath) > 1:
800 if self.isBasePathEqual(self.bouquet_root):
801 self.showFavourites()
803 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
804 if self.isBasePathEqual(ref):
805 self.showSatellites()
807 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
808 if self.isBasePathEqual(ref):
811 self.showAllServices()
815 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
816 def __init__(self, session):
817 ChannelSelectionBase.__init__(self,session)
818 ChannelSelectionEdit.__init__(self)
819 ChannelSelectionEPG.__init__(self)
821 #config for lastservice
822 config.tv = ConfigSubsection();
823 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
824 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
826 self["actions"] = ActionMap(["OkCancelActions"],
828 "cancel": self.cancel,
829 "ok": self.channelSelected,
831 self.onShown.append(self.__onShown)
833 self.lastChannelRootTimer = eTimer()
834 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
835 self.lastChannelRootTimer.start(100,True)
840 def __onCreate(self):
843 lastservice=eServiceReference(config.tv.lastservice.value)
844 if lastservice.valid():
845 self.setCurrentSelection(lastservice)
849 self.recallBouquetMode()
850 ref = self.session.nav.getCurrentlyPlayingServiceReference()
851 if ref is not None and ref.valid() and ref.getPath() == "":
852 self.servicelist.setPlayableIgnoreService(ref)
854 self.servicelist.setPlayableIgnoreService(eServiceReference())
856 def channelSelected(self):
857 ref = self.getCurrentSelection()
859 self.toggleMoveMarked()
860 elif (ref.flags & 7) == 7:
862 elif self.bouquet_mark_edit:
868 #called from infoBar and channelSelected
870 ref = self.session.nav.getCurrentlyPlayingServiceReference()
871 nref = self.getCurrentSelection()
872 if ref is None or ref != nref:
873 self.session.nav.playService(nref)
876 if self.servicePath is not None:
877 tmp=self.servicePath[:]
880 del self.history[self.history_pos+1:]
883 self.history.append(tmp)
884 hlen = len(self.history)
885 if hlen > HISTORYSIZE:
888 self.history_pos = hlen-1
890 def historyBack(self):
891 hlen = len(self.history)
892 if hlen > 1 and self.history_pos > 0:
893 self.history_pos -= 1
894 self.setHistoryPath()
896 def historyNext(self):
897 hlen = len(self.history)
898 if hlen > 1 and self.history_pos < (hlen-1):
899 self.history_pos += 1
900 self.setHistoryPath()
902 def setHistoryPath(self):
903 path = self.history[self.history_pos][:]
905 del self.servicePath[:]
906 self.servicePath += path
910 if self.getRoot() != root:
912 self.session.nav.playService(ref)
913 self.setCurrentSelection(ref)
918 for i in self.servicePathTV:
921 if len(path) and path != config.tv.lastroot.value:
922 config.tv.lastroot.value = path
923 config.tv.lastroot.save()
925 def restoreRoot(self):
928 tmp = re.findall(config.tv.lastroot.value)
931 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
934 path = self.servicePathTV.pop()
937 self.showFavourites()
940 def preEnterPath(self, refstr):
941 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
942 pathstr = config.tv.lastroot.value
943 if pathstr is not None and pathstr.find(refstr) == 0:
945 lastservice=eServiceReference(config.tv.lastservice.value)
946 if lastservice.valid():
947 self.setCurrentSelection(lastservice)
951 def saveChannel(self):
952 ref = self.session.nav.getCurrentlyPlayingServiceReference()
954 refstr = ref.toString()
957 if refstr != config.tv.lastservice.value:
958 config.tv.lastservice.value = refstr
959 config.tv.lastservice.save()
961 def recallPrevService(self):
962 hlen = len(self.history)
964 if self.history_pos == hlen-1:
965 tmp = self.history[self.history_pos]
966 self.history[self.history_pos] = self.history[self.history_pos-1]
967 self.history[self.history_pos-1] = tmp
969 tmp = self.history[self.history_pos+1]
970 self.history[self.history_pos+1] = self.history[self.history_pos]
971 self.history[self.history_pos] = tmp
972 self.setHistoryPath()
977 lastservice=eServiceReference(config.tv.lastservice.value)
978 if lastservice.valid() and self.getCurrentSelection() != lastservice:
979 self.setCurrentSelection(lastservice)
981 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
983 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
984 def __init__(self, session):
985 Screen.__init__(self, session)
986 InfoBarEvent.__init__(self)
987 InfoBarServiceName.__init__(self)
988 InfoBarInstantRecord.__init__(self)
989 self["Clock"] = Clock()
991 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
992 def __init__(self, session):
993 ChannelSelectionBase.__init__(self, session)
994 ChannelSelectionEdit.__init__(self)
995 ChannelSelectionEPG.__init__(self)
997 config.radio = ConfigSubsection();
998 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
999 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
1000 self.onLayoutFinish.append(self.onCreate)
1002 self.info = session.instantiateDialog(RadioInfoBar)
1004 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1006 "keyTV": self.closeRadio,
1007 "keyRadio": self.closeRadio,
1008 "cancel": self.closeRadio,
1009 "ok": self.channelSelected,
1014 for i in self.servicePathRadio:
1015 path += i.toString()
1017 if len(path) and path != config.radio.lastroot.value:
1018 config.radio.lastroot.value = path
1019 config.radio.lastroot.save()
1021 def restoreRoot(self):
1023 re = compile('.+?;')
1024 tmp = re.findall(config.radio.lastroot.value)
1027 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1030 path = self.servicePathRadio.pop()
1031 self.enterPath(path)
1033 self.showFavourites()
1036 def preEnterPath(self, refstr):
1037 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1038 pathstr = config.radio.lastroot.value
1039 if pathstr is not None and pathstr.find(refstr) == 0:
1041 lastservice=eServiceReference(config.radio.lastservice.value)
1042 if lastservice.valid():
1043 self.setCurrentSelection(lastservice)
1050 lastservice=eServiceReference(config.radio.lastservice.value)
1051 if lastservice.valid():
1052 self.servicelist.setCurrent(lastservice)
1053 self.session.nav.playService(lastservice)
1054 self.servicelist.setPlayableIgnoreService(lastservice)
1057 def channelSelected(self): # just return selected service
1058 ref = self.getCurrentSelection()
1060 self.toggleMoveMarked()
1061 elif (ref.flags & 7) == 7:
1063 elif self.bouquet_mark_edit:
1066 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1067 if playingref is None or playingref != ref:
1068 self.session.nav.playService(ref)
1069 self.servicelist.setPlayableIgnoreService(ref)
1070 config.radio.lastservice.value = ref.toString()
1071 config.radio.lastservice.save()
1074 def closeRadio(self):
1076 #set previous tv service
1077 lastservice=eServiceReference(config.tv.lastservice.value)
1078 self.session.nav.playService(lastservice)
1081 class SimpleChannelSelection(ChannelSelectionBase):
1082 def __init__(self, session, title):
1083 ChannelSelectionBase.__init__(self, session)
1085 self.onShown.append(self.__onExecCallback)
1087 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1089 "cancel": self.close,
1090 "ok": self.channelSelected,
1091 "keyRadio": self.setModeRadio,
1092 "keyTV": self.setModeTv,
1095 def __onExecCallback(self):
1096 self.setTitle(self.title)
1099 def channelSelected(self): # just return selected service
1100 ref = self.getCurrentSelection()
1101 if (ref.flags & 7) == 7:
1104 ref = self.getCurrentSelection()
1107 def setModeTv(self):
1109 self.showFavourites()
1111 def setModeRadio(self):
1113 self.showFavourites()