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()
378 def toggleMoveMode(self):
380 if self.entry_marked:
381 self.toggleMoveMarked() # unmark current entry
382 self.movemode = False
383 self.pathChangedDisabled = False # re-enable path change
384 self.mutableList.flushChanges() # FIXME add check if changes was made
385 self.mutableList = None
386 self.setTitle(self.saved_title)
387 self.saved_title = None
388 if self.getRoot() == self.bouquet_root:
389 self.bouquetNumOffsetCache = { }
391 self.mutableList = self.getMutableList()
393 self.pathChangedDisabled = True # no path change allowed in movemode
394 self.saved_title = self.instance.getTitle()
395 new_title = self.saved_title
396 pos = self.saved_title.find(')')
397 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
398 self.setTitle(new_title);
400 def handleEditCancel(self):
401 if self.movemode: #movemode active?
402 self.channelSelected() # unmark
403 self.toggleMoveMode() # disable move mode
404 elif self.bouquet_mark_edit:
405 self.endMarkedEdit(True) # abort edit mode
407 def toggleMoveMarked(self):
408 if self.entry_marked:
409 self.servicelist.setCurrentMarked(False)
410 self.entry_marked = False
412 self.servicelist.setCurrentMarked(True)
413 self.entry_marked = True
416 self.session.open(ChannelContextMenu, self)
421 class ChannelSelectionBase(Screen):
422 def __init__(self, session):
423 Screen.__init__(self, session)
425 # this makes it much simple to implement a selectable radio or tv mode :)
426 self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17)'
427 self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
429 self["key_red"] = Button(_("All"))
430 self["key_green"] = Button(_("Satellites"))
431 self["key_yellow"] = Button(_("Provider"))
432 self["key_blue"] = Button(_("Favourites"))
434 self["list"] = ServiceList()
435 self.servicelist = self["list"]
437 self.numericalTextInput = NumericalTextInput()
439 self.servicePathTV = [ ]
440 self.servicePathRadio = [ ]
441 self.servicePath = [ ]
445 self.pathChangedDisabled = False
447 self.bouquetNumOffsetCache = { }
449 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
451 "showFavourites": self.showFavourites,
452 "showAllServices": self.showAllServices,
453 "showProviders": self.showProviders,
454 "showSatellites": self.showSatellites,
455 "nextBouquet": self.nextBouquet,
456 "prevBouquet": self.prevBouquet,
457 "1": self.keyNumberGlobal,
458 "2": self.keyNumberGlobal,
459 "3": self.keyNumberGlobal,
460 "4": self.keyNumberGlobal,
461 "5": self.keyNumberGlobal,
462 "6": self.keyNumberGlobal,
463 "7": self.keyNumberGlobal,
464 "8": self.keyNumberGlobal,
465 "9": self.keyNumberGlobal,
469 def appendDVBTypes(self, ref):
471 pos = path.find(' FROM BOUQUET')
473 return eServiceReference(self.service_types + path[pos:])
476 def getBouquetNumOffset(self, bouquet):
477 if self.bouquet_root.getPath().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
479 bouquet = self.appendDVBTypes(bouquet)
481 return self.bouquetNumOffsetCache[bouquet.toString()]
484 serviceHandler = eServiceCenter.getInstance()
485 bouquetlist = serviceHandler.list(self.bouquet_root)
486 if not bouquetlist is None:
488 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
489 if not bouquetIterator.valid(): #end of list
491 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
492 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
494 servicelist = serviceHandler.list(bouquetIterator)
495 if not servicelist is None:
497 serviceIterator = servicelist.getNext()
498 if not serviceIterator.valid(): #check if end of list
500 if serviceIterator.flags: #playable services have no flags
503 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
505 def recallBouquetMode(self):
506 if self.mode == MODE_TV:
507 self.service_types = self.service_types_tv
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.tv" ORDER BY bouquet'
511 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
513 self.service_types = self.service_types_radio
514 if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
515 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
517 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
518 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
522 self.servicePath = self.servicePathTV
523 self.recallBouquetMode()
524 title = self.instance.getTitle()
525 pos = title.find(" (")
531 def setRadioMode(self):
532 self.mode = MODE_RADIO
533 self.servicePath = self.servicePathRadio
534 self.recallBouquetMode()
535 title = self.instance.getTitle()
536 pos = title.find(" (")
542 def setRoot(self, root, justSet=False):
543 path = root.getPath()
544 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
545 pos = path.find(' FROM BOUQUET')
546 isBouquet = pos != -1
547 if not inBouquetRootList and isBouquet:
548 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
549 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
550 refstr = self.service_types + path[pos:]
551 root = eServiceReference(refstr)
553 self.servicelist.setMode(ServiceList.MODE_NORMAL)
554 self.servicelist.setRoot(root, justSet)
555 self.buildTitleString()
557 def removeModeStr(self, str):
558 if self.mode == MODE_TV:
559 pos = str.find(' (TV)')
561 pos = str.find(' (Radio)')
566 def getServiceName(self, ref):
567 str = self.removeModeStr(ServiceReference(ref).getServiceName())
569 pathstr = ref.getPath()
570 if pathstr.find('FROM PROVIDERS') != -1:
572 if pathstr.find('FROM SATELLITES') != -1:
573 return _("Satellites")
574 if pathstr.find(') ORDER BY name') != -1:
578 def buildTitleString(self):
579 titleStr = self.instance.getTitle()
580 pos = titleStr.find(']')
582 pos = titleStr.find(')')
584 titleStr = titleStr[:pos+1]
585 Len = len(self.servicePath)
587 base_ref = self.servicePath[0]
589 end_ref = self.servicePath[Len-1]
592 nameStr = self.getServiceName(base_ref)
593 titleStr += ' ' + nameStr
594 if end_ref is not None:
599 nameStr = self.getServiceName(end_ref)
601 self.setTitle(titleStr)
604 self.servicelist.moveUp()
607 self.servicelist.moveDown()
610 del self.servicePath[:]
612 def enterPath(self, ref, justSet=False):
613 self.servicePath.append(ref)
614 self.setRoot(ref, justSet)
616 def pathUp(self, justSet=False):
617 prev = self.servicePath.pop()
618 length = len(self.servicePath)
620 current = self.servicePath[length-1]
621 self.setRoot(current, justSet)
623 self.setCurrentSelection(prev)
626 def isBasePathEqual(self, ref):
627 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
631 def isPrevPathEqual(self, ref):
632 length = len(self.servicePath)
633 if length > 1 and self.servicePath[length-2] == ref:
637 def preEnterPath(self, refstr):
640 def showAllServices(self):
641 if not self.pathChangedDisabled:
642 refstr = '%s ORDER BY name'%(self.service_types)
643 if not self.preEnterPath(refstr):
644 ref = eServiceReference(refstr)
645 currentRoot = self.getRoot()
646 if currentRoot is None or currentRoot != ref:
650 def showSatellites(self):
651 if not self.pathChangedDisabled:
652 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
653 if not self.preEnterPath(refstr):
654 ref = eServiceReference(refstr)
658 if self.isBasePathEqual(ref):
659 if self.isPrevPathEqual(ref):
661 prev = self.pathUp(justSet)
663 currentRoot = self.getRoot()
664 if currentRoot is None or currentRoot != ref:
667 self.enterPath(ref, True)
669 serviceHandler = eServiceCenter.getInstance()
670 servicelist = serviceHandler.list(ref)
671 if not servicelist is None:
673 service = servicelist.getNext()
674 if not service.valid(): #check if end of list
676 orbpos = service.getData(4) >> 16
677 if service.getPath().find("FROM PROVIDER") != -1:
678 service_name = _("Providers")
680 service_name = _("Services")
682 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
683 service.setName(service_name) # why we need this cast?
685 if orbpos > 1800: # west
686 orbpos = 3600 - orbpos
690 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
692 self.servicelist.addService(service)
693 self.servicelist.finishFill()
695 self.setCurrentSelection(prev)
697 def showProviders(self):
698 if not self.pathChangedDisabled:
699 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
700 if not self.preEnterPath(refstr):
701 ref = eServiceReference(refstr)
702 if self.isBasePathEqual(ref):
705 currentRoot = self.getRoot()
706 if currentRoot is None or currentRoot != ref:
710 def changeBouquet(self, direction):
711 if not self.pathChangedDisabled:
712 if self.isBasePathEqual(self.bouquet_root):
718 ref = self.getCurrentSelection()
722 return self.isBasePathEqual(self.bouquet_root)
725 return self.servicelist.atBegin()
728 return self.servicelist.atEnd()
730 def nextBouquet(self):
731 self.changeBouquet(+1)
733 def prevBouquet(self):
734 self.changeBouquet(-1)
736 def showFavourites(self):
737 if not self.pathChangedDisabled:
738 if not self.preEnterPath(self.bouquet_rootstr):
739 if self.isBasePathEqual(self.bouquet_root):
742 currentRoot = self.getRoot()
743 if currentRoot is None or currentRoot != self.bouquet_root:
745 self.enterPath(self.bouquet_root)
747 def keyNumberGlobal(self, number):
748 char = self.numericalTextInput.getKey(number)
749 self.servicelist.moveToChar(char)
752 return self.servicelist.getRoot()
754 def getCurrentSelection(self):
755 return self.servicelist.getCurrent()
757 def setCurrentSelection(self, service):
758 servicepath = service.getPath()
759 pos = servicepath.find(" FROM BOUQUET")
761 if self.mode == MODE_TV:
762 servicepath = '(type == 1)' + servicepath[pos:]
764 servicepath = '(type == 2)' + servicepath[pos:]
765 service.setPath(servicepath)
766 self.servicelist.setCurrent(service)
768 def getBouquetList(self):
771 serviceHandler = eServiceCenter.getInstance()
772 list = serviceHandler.list(self.bouquet_root)
778 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
779 info = serviceHandler.info(s)
781 bouquets.append((info.getName(s), s))
784 if len(bouquets) == 0 and serviceCount > 0:
785 info = serviceHandler.info(self.bouquet_root)
787 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
791 def keyNumber0(self, num):
792 if len(self.servicePath) > 1:
795 self.keyNumberGlobal(num)
798 if len(self.servicePath) > 1:
799 if self.isBasePathEqual(self.bouquet_root):
800 self.showFavourites()
802 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
803 if self.isBasePathEqual(ref):
804 self.showSatellites()
806 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
807 if self.isBasePathEqual(ref):
810 self.showAllServices()
814 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
815 def __init__(self, session):
816 ChannelSelectionBase.__init__(self,session)
817 ChannelSelectionEdit.__init__(self)
818 ChannelSelectionEPG.__init__(self)
820 #config for lastservice
821 config.tv = ConfigSubsection();
822 config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
823 config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
825 self["actions"] = ActionMap(["OkCancelActions"],
827 "cancel": self.cancel,
828 "ok": self.channelSelected,
830 self.onShown.append(self.__onShown)
832 self.lastChannelRootTimer = eTimer()
833 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
834 self.lastChannelRootTimer.start(100,True)
839 def __onCreate(self):
842 lastservice=eServiceReference(config.tv.lastservice.value)
843 if lastservice.valid():
844 self.setCurrentSelection(lastservice)
848 self.recallBouquetMode()
849 ref = self.session.nav.getCurrentlyPlayingServiceReference()
850 if ref is not None and ref.valid() and ref.getPath() == "":
851 self.servicelist.setPlayableIgnoreService(ref)
853 self.servicelist.setPlayableIgnoreService(eServiceReference())
855 def channelSelected(self):
856 ref = self.getCurrentSelection()
858 self.toggleMoveMarked()
859 elif (ref.flags & 7) == 7:
861 elif self.bouquet_mark_edit:
867 #called from infoBar and channelSelected
869 ref = self.session.nav.getCurrentlyPlayingServiceReference()
870 nref = self.getCurrentSelection()
871 if ref is None or ref != nref:
872 self.session.nav.playService(nref)
875 if self.servicePath is not None:
876 tmp=self.servicePath[:]
879 del self.history[self.history_pos+1:]
882 self.history.append(tmp)
883 hlen = len(self.history)
884 if hlen > HISTORYSIZE:
887 self.history_pos = hlen-1
889 def historyBack(self):
890 hlen = len(self.history)
891 if hlen > 1 and self.history_pos > 0:
892 self.history_pos -= 1
893 self.setHistoryPath()
895 def historyNext(self):
896 hlen = len(self.history)
897 if hlen > 1 and self.history_pos < (hlen-1):
898 self.history_pos += 1
899 self.setHistoryPath()
901 def setHistoryPath(self):
902 path = self.history[self.history_pos][:]
904 del self.servicePath[:]
905 self.servicePath += path
909 if self.getRoot() != root:
911 self.session.nav.playService(ref)
912 self.setCurrentSelection(ref)
917 for i in self.servicePathTV:
920 if len(path) and path != config.tv.lastroot.value:
921 config.tv.lastroot.value = path
922 config.tv.lastroot.save()
924 def restoreRoot(self):
927 tmp = re.findall(config.tv.lastroot.value)
930 self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
933 path = self.servicePathTV.pop()
936 self.showFavourites()
939 def preEnterPath(self, refstr):
940 if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
941 pathstr = config.tv.lastroot.value
942 if pathstr is not None and pathstr.find(refstr) == 0:
944 lastservice=eServiceReference(config.tv.lastservice.value)
945 if lastservice.valid():
946 self.setCurrentSelection(lastservice)
950 def saveChannel(self):
951 ref = self.session.nav.getCurrentlyPlayingServiceReference()
953 refstr = ref.toString()
956 if refstr != config.tv.lastservice.value:
957 config.tv.lastservice.value = refstr
958 config.tv.lastservice.save()
960 def recallPrevService(self):
961 hlen = len(self.history)
963 if self.history_pos == hlen-1:
964 tmp = self.history[self.history_pos]
965 self.history[self.history_pos] = self.history[self.history_pos-1]
966 self.history[self.history_pos-1] = tmp
968 tmp = self.history[self.history_pos+1]
969 self.history[self.history_pos+1] = self.history[self.history_pos]
970 self.history[self.history_pos] = tmp
971 self.setHistoryPath()
976 lastservice=eServiceReference(config.tv.lastservice.value)
977 if lastservice.valid() and self.getCurrentSelection() != lastservice:
978 self.setCurrentSelection(lastservice)
980 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
982 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
983 def __init__(self, session):
984 Screen.__init__(self, session)
985 InfoBarEvent.__init__(self)
986 InfoBarServiceName.__init__(self)
987 InfoBarInstantRecord.__init__(self)
988 self["Clock"] = Clock()
990 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
991 def __init__(self, session):
992 ChannelSelectionBase.__init__(self, session)
993 ChannelSelectionEdit.__init__(self)
994 ChannelSelectionEPG.__init__(self)
996 config.radio = ConfigSubsection();
997 config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
998 config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
999 self.onLayoutFinish.append(self.onCreate)
1001 self.info = session.instantiateDialog(RadioInfoBar)
1003 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1005 "keyTV": self.closeRadio,
1006 "keyRadio": self.closeRadio,
1007 "cancel": self.closeRadio,
1008 "ok": self.channelSelected,
1013 for i in self.servicePathRadio:
1014 path += i.toString()
1016 if len(path) and path != config.radio.lastroot.value:
1017 config.radio.lastroot.value = path
1018 config.radio.lastroot.save()
1020 def restoreRoot(self):
1022 re = compile('.+?;')
1023 tmp = re.findall(config.radio.lastroot.value)
1026 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1029 path = self.servicePathRadio.pop()
1030 self.enterPath(path)
1032 self.showFavourites()
1035 def preEnterPath(self, refstr):
1036 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1037 pathstr = config.radio.lastroot.value
1038 if pathstr is not None and pathstr.find(refstr) == 0:
1040 lastservice=eServiceReference(config.radio.lastservice.value)
1041 if lastservice.valid():
1042 self.setCurrentSelection(lastservice)
1049 lastservice=eServiceReference(config.radio.lastservice.value)
1050 if lastservice.valid():
1051 self.servicelist.setCurrent(lastservice)
1052 self.session.nav.playService(lastservice)
1053 self.servicelist.setPlayableIgnoreService(lastservice)
1056 def channelSelected(self): # just return selected service
1057 ref = self.getCurrentSelection()
1059 self.toggleMoveMarked()
1060 elif (ref.flags & 7) == 7:
1062 elif self.bouquet_mark_edit:
1065 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1066 if playingref is None or playingref != ref:
1067 self.session.nav.playService(ref)
1068 self.servicelist.setPlayableIgnoreService(ref)
1069 config.radio.lastservice.value = ref.toString()
1070 config.radio.lastservice.save()
1073 def closeRadio(self):
1075 #set previous tv service
1076 lastservice=eServiceReference(config.tv.lastservice.value)
1077 self.session.nav.playService(lastservice)
1080 class SimpleChannelSelection(ChannelSelectionBase):
1081 def __init__(self, session, title):
1082 ChannelSelectionBase.__init__(self, session)
1084 self.onShown.append(self.__onExecCallback)
1086 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1088 "cancel": self.close,
1089 "ok": self.channelSelected,
1090 "keyRadio": self.setModeRadio,
1091 "keyTV": self.setModeTv,
1094 def __onExecCallback(self):
1095 self.setTitle(self.title)
1098 def channelSelected(self): # just return selected service
1099 ref = self.getCurrentSelection()
1100 if (ref.flags & 7) == 7:
1103 ref = self.getCurrentSelection()
1106 def setModeTv(self):
1108 self.showFavourites()
1110 def setModeRadio(self):
1112 self.showFavourites()