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, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
8 from Components.config import config, ConfigSubsection, ConfigText
9 from Screens.FixedMenu import FixedMenu
10 from Tools.NumericalTextInput import NumericalTextInput
11 from Components.NimManager import nimmanager
12 from Components.Sources.Clock import Clock
13 from Components.Input import Input
14 from Components.ParentalControl import parentalControl
15 from Screens.InputBox import InputBox, PinInput
16 from Screens.MessageBox import MessageBox
17 from ServiceReference import ServiceReference
18 from Tools.BoundFunction import boundFunction
22 FLAG_SERVICE_NEW_FOUND = 64 #define in lib/dvb/idvb.h as dxNewFound = 64
24 import xml.dom.minidom
26 class BouquetSelector(Screen):
27 def __init__(self, session, bouquets, selectedFunc, enableWrapAround=False):
28 Screen.__init__(self, session)
30 self.selectedFunc=selectedFunc
32 self["actions"] = ActionMap(["OkCancelActions"],
34 "ok": self.okbuttonClick,
35 "cancel": self.cancelClick
39 entrys.append((x[0], x[1]))
40 self["menu"] = MenuList(entrys, enableWrapAround)
43 cur = self["menu"].getCurrent()
46 def okbuttonClick(self):
47 self.selectedFunc(self.getCurrent())
55 def cancelClick(self):
58 class ChannelContextMenu(Screen):
59 def __init__(self, session, csel):
60 Screen.__init__(self, session)
64 self["actions"] = ActionMap(["OkCancelActions"],
66 "ok": self.okbuttonClick,
67 "cancel": self.cancelClick
71 current_root = csel.getRoot()
72 current_sel_path = csel.getCurrentSelection().getPath()
73 current_sel_flags = csel.getCurrentSelection().flags
74 inBouquetRootList = current_root and current_root.getPath().find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
75 inBouquet = csel.getMutableList() is not None
76 haveBouquets = config.usage.multibouquet.value
78 if not csel.bouquet_mark_edit and not csel.movemode:
79 if not inBouquetRootList:
80 if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
81 if config.ParentalControl.configured.value:
82 if parentalControl.getProtectionLevel(csel.getCurrentSelection().toCompareString()) == -1:
83 menu.append((_("add to parental protection"), boundFunction(self.addParentalProtection, csel.getCurrentSelection())))
85 menu.append((_("remove from parental protection"), boundFunction(self.removeParentalProtection, csel.getCurrentSelection())))
87 menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
89 menu.append((_("add service to favourites"), self.addServiceToBouquetSelected))
92 if not inBouquet and current_sel_path.find("PROVIDERS") == -1:
93 menu.append((_("copy to favourites"), self.copyCurrentToBouquetList))
94 if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
95 menu.append((_("remove all new found flags"), self.removeAllNewFoundFlags))
97 menu.append((_("remove entry"), self.removeCurrentService))
98 if current_root is not None and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
99 menu.append((_("remove new found flag"), self.removeNewFoundFlag))
101 menu.append((_("add bouquet"), self.showBouquetInputBox))
102 menu.append((_("remove entry"), self.removeBouquet))
104 if inBouquet: # current list is editable?
105 if not csel.bouquet_mark_edit:
106 if not csel.movemode:
107 menu.append((_("add marker"), self.showMarkerInputBox))
108 menu.append((_("enable move mode"), self.toggleMoveMode))
109 if not inBouquetRootList:
111 menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
113 menu.append((_("enable favourite edit"), self.bouquetMarkStart))
115 menu.append((_("disable move mode"), self.toggleMoveMode))
116 elif not inBouquetRootList:
118 menu.append((_("end bouquet edit"), self.bouquetMarkEnd))
119 menu.append((_("abort bouquet edit"), self.bouquetMarkAbort))
121 menu.append((_("end favourites edit"), self.bouquetMarkEnd))
122 menu.append((_("abort favourites edit"), self.bouquetMarkAbort))
124 menu.append((_("back"), self.cancelClick))
125 self["menu"] = MenuList(menu)
127 def okbuttonClick(self):
128 self["menu"].getCurrent()[1]()
130 def cancelClick(self):
133 def showBouquetInputBox(self):
134 self.session.openWithCallback(self.bouquetInputCallback, InputBox, title=_("Please enter a name for the new bouquet"), text="bouquetname", maxSize=False, type=Input.TEXT)
136 def bouquetInputCallback(self, bouquet):
137 if bouquet is not None:
138 self.csel.addBouquet(bouquet, None)
141 def addParentalProtection(self, service):
142 parentalControl.protectService(service.toCompareString())
145 def removeParentalProtection(self, service):
146 self.session.openWithCallback(boundFunction(self.pinEntered, service.toCompareString()), PinInput, pinList = [config.ParentalControl.servicepin[0].value], triesEntry = config.ParentalControl.retries.servicepin, title = _("Enter the service pin"), windowTitle = _("Change pin code"))
148 def pinEntered(self, service, result):
150 parentalControl.unProtectService(service)
153 self.session.openWithCallback(self.close, MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR)
155 def addServiceToBouquetSelected(self):
156 bouquets = self.csel.getBouquetList()
161 if cnt > 1: # show bouquet list
162 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, bouquets, self.addCurrentServiceToBouquet)
163 elif cnt == 1: # add to only one existing bouquet
164 self.addCurrentServiceToBouquet(bouquets[0][1])
165 else: #no bouquets in root.. so assume only one favourite list is used
166 self.addCurrentServiceToBouquet(self.csel.bouquet_root)
168 def bouquetSelClosed(self, recursive):
173 def copyCurrentToBouquetList(self):
174 self.csel.copyCurrentToBouquetList()
177 def removeBouquet(self):
178 self.csel.removeBouquet()
181 def showMarkerInputBox(self):
182 self.session.openWithCallback(self.markerInputCallback, InputBox, title=_("Please enter a name for the new marker"), text="markername", maxSize=False, type=Input.TEXT)
184 def markerInputCallback(self, marker):
185 if marker is not None:
186 self.csel.addMarker(marker)
189 def addCurrentServiceToBouquet(self, dest):
190 self.csel.addCurrentServiceToBouquet(dest)
191 if self.bsel is not None:
192 self.bsel.close(True)
194 self.close(True) # close bouquet selection
196 def removeCurrentService(self):
197 self.csel.removeCurrentService()
200 def toggleMoveMode(self):
201 self.csel.toggleMoveMode()
204 def bouquetMarkStart(self):
205 self.csel.startMarkedEdit()
208 def bouquetMarkEnd(self):
209 self.csel.endMarkedEdit(abort=False)
212 def bouquetMarkAbort(self):
213 self.csel.endMarkedEdit(abort=True)
216 def removeNewFoundFlag(self):
217 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
220 def removeAllNewFoundFlags(self):
221 curpath = self.csel.getCurrentSelection().getPath()
222 idx = curpath.find("satellitePosition == ")
224 tmp = curpath[idx+21:]
227 satpos = int(tmp[:idx])
228 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
231 class ChannelSelectionEPG:
233 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
235 "showEPGList": self.showEPGList,
238 def showEPGList(self):
239 ref=self.getCurrentSelection()
240 ptr=eEPGCache.getInstance()
241 if ptr.startTimeQuery(ref) != -1:
242 self.session.open(EPGSelection, ref)
244 print 'no epg for service', ref.toString()
246 class ChannelSelectionEdit:
248 self.entry_marked = False
249 self.movemode = False
250 self.bouquet_mark_edit = False
251 self.mutableList = None
253 self.saved_title = None
254 self.saved_root = None
256 class ChannelSelectionEditActionMap(ActionMap):
257 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
258 ActionMap.__init__(self, contexts, actions, prio)
261 def action(self, contexts, action):
262 if action == "cancel":
263 self.csel.handleEditCancel()
264 return 0 # fall-trough
266 return 0 # fall-trough
268 return ActionMap.action(self, contexts, action)
270 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
272 "contextMenu": self.doContext,
275 def getMutableList(self, root=eServiceReference()):
276 if not self.mutableList is None:
277 return self.mutableList
278 serviceHandler = eServiceCenter.getInstance()
281 list = root and serviceHandler.list(root)
283 return list.startEdit()
286 def buildBouquetID(self, str):
290 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
296 def addMarker(self, name):
297 current = self.servicelist.getCurrent()
298 mutableList = self.getMutableList()
301 str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
302 ref = eServiceReference(str)
303 if current and current.valid():
304 if not mutableList.addService(ref, current):
305 self.servicelist.addService(ref, True)
306 mutableList.flushChanges()
308 elif not mutableList.addService(ref):
309 self.servicelist.addService(ref, True)
310 mutableList.flushChanges()
314 def addBouquet(self, bName, services):
315 serviceHandler = eServiceCenter.getInstance()
316 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
317 if mutableBouquetList:
318 if self.mode == MODE_TV:
320 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
323 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
324 new_bouquet_ref = eServiceReference(str)
325 if not mutableBouquetList.addService(new_bouquet_ref):
326 self.bouquetNumOffsetCache = { }
327 mutableBouquetList.flushChanges()
328 eDVBDB.getInstance().reloadBouquets()
329 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
331 mutableBouquet.setListName(bName)
332 if services is not None:
333 for service in services:
334 if mutableBouquet.addService(service):
335 print "add", service.toString(), "to new bouquet failed"
337 current = self.servicelist.getCurrent()
338 if current and current.toString() == self.bouquet_rootstr:
339 self.servicelist.addService(service, True)
340 mutableBouquet.flushChanges()
342 print "get mutable list for new created bouquet failed"
344 print "add", str, "to bouquets failed"
346 print "bouquetlist is not editable"
348 def copyCurrentToBouquetList(self):
349 provider = ServiceReference(self.getCurrentSelection())
350 providerName = provider.getServiceName()
351 serviceHandler = eServiceCenter.getInstance()
352 services = serviceHandler.list(provider.ref)
353 self.addBouquet(providerName, services and services.getContent('R', True))
355 def removeBouquet(self):
356 refstr = self.getCurrentSelection().toString()
357 self.bouquetNumOffsetCache = { }
358 pos = refstr.find('FROM BOUQUET "')
360 refstr = refstr[pos+14:]
361 pos = refstr.find('"')
363 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
364 self.removeCurrentService()
368 print "error during remove of", filename
370 # multiple marked entry stuff ( edit mode, later multiepg selection )
371 def startMarkedEdit(self):
372 self.mutableList = self.getMutableList()
373 # add all services from the current list to internal marked set in listboxservicecontent
374 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
375 self.saved_title = self.instance.getTitle()
376 pos = self.saved_title.find(')')
377 new_title = self.saved_title[:pos+1]
378 if config.usage.multibouquet.value:
379 new_title += ' ' + _("[bouquet edit]")
381 new_title += ' ' + _("[favourite edit]")
382 self.setTitle(new_title)
383 self.bouquet_mark_edit = True
384 self.__marked = self.servicelist.getRootServices()
385 for x in self.__marked:
386 self.servicelist.addMarked(eServiceReference(x))
387 self.savedPath = self.servicePath[:]
388 self.showAllServices()
390 def endMarkedEdit(self, abort):
391 if not abort and self.mutableList is not None:
392 self.bouquetNumOffsetCache = { }
393 new_marked = set(self.servicelist.getMarked())
394 old_marked = set(self.__marked)
395 removed = old_marked - new_marked
396 added = new_marked - old_marked
400 self.mutableList.removeService(eServiceReference(x))
403 self.mutableList.addService(eServiceReference(x))
405 self.mutableList.flushChanges()
408 self.bouquet_mark_edit = False
409 self.mutableList = None
410 self.setTitle(self.saved_title)
411 self.saved_title = None
412 # self.servicePath is just a reference to servicePathTv or Radio...
413 # so we never ever do use the asignment operator in self.servicePath
414 del self.servicePath[:] # remove all elements
415 self.servicePath += self.savedPath # add saved elements
417 self.setRoot(self.servicePath[len(self.servicePath)-1])
419 def clearMarks(self):
420 self.servicelist.clearMarks()
423 ref = self.servicelist.getCurrent()
424 if self.servicelist.isMarked(ref):
425 self.servicelist.removeMarked(ref)
427 self.servicelist.addMarked(ref)
429 def removeCurrentService(self):
430 ref = self.servicelist.getCurrent()
431 mutableList = self.getMutableList()
432 if ref.valid() and mutableList is not None:
433 if not mutableList.removeService(ref):
434 self.bouquetNumOffsetCache = { }
435 mutableList.flushChanges() #FIXME dont flush on each single removed service
436 self.servicelist.removeCurrent()
438 def addCurrentServiceToBouquet(self, dest):
439 mutableList = self.getMutableList(dest)
440 if not mutableList is None:
441 if not mutableList.addService(self.servicelist.getCurrent()):
442 self.bouquetNumOffsetCache = { }
443 mutableList.flushChanges()
445 def toggleMoveMode(self):
447 if self.entry_marked:
448 self.toggleMoveMarked() # unmark current entry
449 self.movemode = False
450 self.pathChangedDisabled = False # re-enable path change
451 self.mutableList.flushChanges() # FIXME add check if changes was made
452 self.mutableList = None
453 self.setTitle(self.saved_title)
454 self.saved_title = None
455 if self.getRoot() == self.bouquet_root:
456 self.bouquetNumOffsetCache = { }
458 self.mutableList = self.getMutableList()
460 self.pathChangedDisabled = True # no path change allowed in movemode
461 self.saved_title = self.instance.getTitle()
462 new_title = self.saved_title
463 pos = self.saved_title.find(')')
464 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
465 self.setTitle(new_title);
467 def handleEditCancel(self):
468 if self.movemode: #movemode active?
469 self.channelSelected() # unmark
470 self.toggleMoveMode() # disable move mode
471 elif self.bouquet_mark_edit:
472 self.endMarkedEdit(True) # abort edit mode
474 def toggleMoveMarked(self):
475 if self.entry_marked:
476 self.servicelist.setCurrentMarked(False)
477 self.entry_marked = False
479 self.servicelist.setCurrentMarked(True)
480 self.entry_marked = True
483 self.session.open(ChannelContextMenu, self)
488 # this makes it much simple to implement a selectable radio or tv mode :)
489 service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
490 service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
492 class ChannelSelectionBase(Screen):
493 def __init__(self, session):
494 Screen.__init__(self, session)
496 self["key_red"] = Button(_("All"))
497 self["key_green"] = Button(_("Satellites"))
498 self["key_yellow"] = Button(_("Provider"))
499 self["key_blue"] = Button(_("Favourites"))
501 self["list"] = ServiceList()
502 self.servicelist = self["list"]
504 self.numericalTextInput = NumericalTextInput()
505 self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
507 self.servicePathTV = [ ]
508 self.servicePathRadio = [ ]
509 self.servicePath = [ ]
513 self.pathChangedDisabled = False
515 self.bouquetNumOffsetCache = { }
517 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
519 "showFavourites": self.showFavourites,
520 "showAllServices": self.showAllServices,
521 "showProviders": self.showProviders,
522 "showSatellites": self.showSatellites,
523 "nextBouquet": self.nextBouquet,
524 "prevBouquet": self.prevBouquet,
525 "nextMarker": self.nextMarker,
526 "prevMarker": self.prevMarker,
527 "1": self.keyNumberGlobal,
528 "2": self.keyNumberGlobal,
529 "3": self.keyNumberGlobal,
530 "4": self.keyNumberGlobal,
531 "5": self.keyNumberGlobal,
532 "6": self.keyNumberGlobal,
533 "7": self.keyNumberGlobal,
534 "8": self.keyNumberGlobal,
535 "9": self.keyNumberGlobal,
538 self.recallBouquetMode()
540 def appendDVBTypes(self, ref):
542 pos = path.find(' FROM BOUQUET')
544 return eServiceReference(self.service_types + path[pos:])
547 def getBouquetNumOffset(self, bouquet):
548 if config.usage.multibouquet.value:
550 bouquet = self.appendDVBTypes(bouquet)
552 return self.bouquetNumOffsetCache[bouquet.toString()]
555 serviceHandler = eServiceCenter.getInstance()
556 bouquetlist = serviceHandler.list(self.bouquet_root)
557 if not bouquetlist is None:
559 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
560 if not bouquetIterator.valid(): #end of list
562 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
563 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
565 servicelist = serviceHandler.list(bouquetIterator)
566 if not servicelist is None:
568 serviceIterator = servicelist.getNext()
569 if not serviceIterator.valid(): #check if end of list
571 if serviceIterator.flags: #playable services have no flags
574 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
576 def recallBouquetMode(self):
577 if self.mode == MODE_TV:
578 self.service_types = service_types_tv
579 if config.usage.multibouquet.value:
580 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
582 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
584 self.service_types = service_types_radio
585 if config.usage.multibouquet.value:
586 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
588 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
589 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
593 self.servicePath = self.servicePathTV
594 self.recallBouquetMode()
595 title = self.instance.getTitle()
596 pos = title.find(" (")
602 def setRadioMode(self):
603 self.mode = MODE_RADIO
604 self.servicePath = self.servicePathRadio
605 self.recallBouquetMode()
606 title = self.instance.getTitle()
607 pos = title.find(" (")
613 def setRoot(self, root, justSet=False):
614 path = root.getPath()
615 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
616 pos = path.find(' FROM BOUQUET')
617 isBouquet = pos != -1
618 if not inBouquetRootList and isBouquet:
619 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
620 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
621 refstr = self.service_types + path[pos:]
622 root = eServiceReference(refstr)
624 self.servicelist.setMode(ServiceList.MODE_NORMAL)
625 self.servicelist.setRoot(root, justSet)
626 self.buildTitleString()
628 def removeModeStr(self, str):
629 if self.mode == MODE_TV:
630 pos = str.find(' (TV)')
632 pos = str.find(' (Radio)')
637 def getServiceName(self, ref):
638 str = self.removeModeStr(ServiceReference(ref).getServiceName())
640 pathstr = ref.getPath()
641 if pathstr.find('FROM PROVIDERS') != -1:
643 if pathstr.find('FROM SATELLITES') != -1:
644 return _("Satellites")
645 if pathstr.find(') ORDER BY name') != -1:
649 def buildTitleString(self):
650 titleStr = self.instance.getTitle()
651 pos = titleStr.find(']')
653 pos = titleStr.find(')')
655 titleStr = titleStr[:pos+1]
656 Len = len(self.servicePath)
658 base_ref = self.servicePath[0]
660 end_ref = self.servicePath[Len-1]
663 nameStr = self.getServiceName(base_ref)
664 titleStr += ' ' + nameStr
665 if end_ref is not None:
670 nameStr = self.getServiceName(end_ref)
672 self.setTitle(titleStr)
675 self.servicelist.moveUp()
678 self.servicelist.moveDown()
681 del self.servicePath[:]
683 def enterPath(self, ref, justSet=False):
684 self.servicePath.append(ref)
685 self.setRoot(ref, justSet)
687 def pathUp(self, justSet=False):
688 prev = self.servicePath.pop()
689 length = len(self.servicePath)
691 current = self.servicePath[length-1]
692 self.setRoot(current, justSet)
694 self.setCurrentSelection(prev)
697 def isBasePathEqual(self, ref):
698 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
702 def isPrevPathEqual(self, ref):
703 length = len(self.servicePath)
704 if length > 1 and self.servicePath[length-2] == ref:
708 def preEnterPath(self, refstr):
711 def showAllServices(self):
712 if not self.pathChangedDisabled:
713 refstr = '%s ORDER BY name'%(self.service_types)
714 if not self.preEnterPath(refstr):
715 ref = eServiceReference(refstr)
716 currentRoot = self.getRoot()
717 if currentRoot is None or currentRoot != ref:
721 def showSatellites(self):
722 if not self.pathChangedDisabled:
723 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
724 if not self.preEnterPath(refstr):
725 ref = eServiceReference(refstr)
729 if self.isBasePathEqual(ref):
730 if self.isPrevPathEqual(ref):
732 prev = self.pathUp(justSet)
734 currentRoot = self.getRoot()
735 if currentRoot is None or currentRoot != ref:
738 self.enterPath(ref, True)
740 serviceHandler = eServiceCenter.getInstance()
741 servicelist = serviceHandler.list(ref)
742 if not servicelist is None:
744 service = servicelist.getNext()
745 if not service.valid(): #check if end of list
747 orbpos = service.getUnsignedData(4) >> 16
748 if service.getPath().find("FROM PROVIDER") != -1:
749 service_name = _("Providers")
750 elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
751 service_name = _("New")
753 service_name = _("Services")
755 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
756 service.setName(service_name) # why we need this cast?
758 if orbpos == 0xFFFF: #Cable
759 n = ("%s (%s)") % (service_name, _("Cable"))
760 elif orbpos == 0xEEEE: #Terrestrial
761 n = ("%s (%s)") % (service_name, _("Terrestrial"))
763 if orbpos > 1800: # west
764 orbpos = 3600 - orbpos
768 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
770 self.servicelist.addService(service)
771 self.servicelist.finishFill()
773 self.setCurrentSelection(prev)
775 def showProviders(self):
776 if not self.pathChangedDisabled:
777 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
778 if not self.preEnterPath(refstr):
779 ref = eServiceReference(refstr)
780 if self.isBasePathEqual(ref):
783 currentRoot = self.getRoot()
784 if currentRoot is None or currentRoot != ref:
788 def changeBouquet(self, direction):
789 if not self.pathChangedDisabled:
790 if self.isBasePathEqual(self.bouquet_root):
796 ref = self.getCurrentSelection()
800 return self.isBasePathEqual(self.bouquet_root)
803 return self.servicelist.atBegin()
806 return self.servicelist.atEnd()
808 def nextBouquet(self):
809 self.changeBouquet(+1)
811 def prevBouquet(self):
812 self.changeBouquet(-1)
814 def showFavourites(self):
815 if not self.pathChangedDisabled:
816 if not self.preEnterPath(self.bouquet_rootstr):
817 if self.isBasePathEqual(self.bouquet_root):
820 currentRoot = self.getRoot()
821 if currentRoot is None or currentRoot != self.bouquet_root:
823 self.enterPath(self.bouquet_root)
825 def keyNumberGlobal(self, number):
826 unichar = self.numericalTextInput.getKey(number)
827 charstr = unichar.encode("utf-8")
828 if len(charstr) == 1:
829 self.servicelist.moveToChar(charstr[0])
832 return self.servicelist.getRoot()
834 def getCurrentSelection(self):
835 return self.servicelist.getCurrent()
837 def setCurrentSelection(self, service):
838 servicepath = service.getPath()
839 pos = servicepath.find(" FROM BOUQUET")
841 if self.mode == MODE_TV:
842 servicepath = '(type == 1)' + servicepath[pos:]
844 servicepath = '(type == 2)' + servicepath[pos:]
845 service.setPath(servicepath)
846 self.servicelist.setCurrent(service)
848 def getBouquetList(self):
849 if config.usage.multibouquet.value:
852 serviceHandler = eServiceCenter.getInstance()
853 list = serviceHandler.list(self.bouquet_root)
859 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
860 info = serviceHandler.info(s)
862 bouquets.append((info.getName(s), s))
865 if len(bouquets) == 0 and serviceCount > 0:
866 info = serviceHandler.info(self.bouquet_root)
868 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
872 def keyNumber0(self, num):
873 if len(self.servicePath) > 1:
876 self.keyNumberGlobal(num)
879 if len(self.servicePath) > 1:
880 if self.isBasePathEqual(self.bouquet_root):
881 self.showFavourites()
883 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
884 if self.isBasePathEqual(ref):
885 self.showSatellites()
887 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
888 if self.isBasePathEqual(ref):
891 self.showAllServices()
893 def nextMarker(self):
894 self.servicelist.moveToNextMarker()
896 def prevMarker(self):
897 self.servicelist.moveToPrevMarker()
901 #config for lastservice
902 config.tv = ConfigSubsection()
903 config.tv.lastservice = ConfigText()
904 config.tv.lastroot = ConfigText()
905 config.radio = ConfigSubsection()
906 config.radio.lastservice = ConfigText()
907 config.radio.lastroot = ConfigText()
908 config.servicelist = ConfigSubsection()
909 config.servicelist.lastmode = ConfigText(default = "tv")
911 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
912 def __init__(self, session):
913 ChannelSelectionBase.__init__(self,session)
914 ChannelSelectionEdit.__init__(self)
915 ChannelSelectionEPG.__init__(self)
917 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
919 "cancel": self.cancel,
920 "ok": self.channelSelected,
921 "keyRadio": self.setModeRadio,
922 "keyTV": self.setModeTv,
925 self.onShown.append(self.__onShown)
927 self.lastChannelRootTimer = eTimer()
928 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
929 self.lastChannelRootTimer.start(100,True)
931 self.history_tv = [ ]
932 self.history_radio = [ ]
933 self.history = self.history_tv
936 self.lastservice = config.tv.lastservice
937 self.lastroot = config.tv.lastroot
938 self.revertMode = None
942 lastservice=eServiceReference(self.lastservice.value)
943 if lastservice.valid():
944 self.setCurrentSelection(lastservice)
947 if self.revertMode is None and config.servicelist.lastmode.value == "radio":
948 self.revertMode = MODE_RADIO
949 self.history = self.history_tv
950 self.lastservice = config.tv.lastservice
951 self.lastroot = config.tv.lastroot
952 config.servicelist.lastmode.value = "tv"
956 def setModeRadio(self):
957 if self.revertMode is None and config.servicelist.lastmode.value == "tv":
958 self.revertMode = MODE_TV
959 if config.usage.e1like_radio_mode.value:
960 self.history = self.history_radio
961 self.lastservice = config.radio.lastservice
962 self.lastroot = config.radio.lastroot
963 config.servicelist.lastmode.value = "radio"
967 def __onCreate(self):
968 if config.usage.e1like_radio_mode.value:
969 if config.servicelist.lastmode.value == "tv":
975 lastservice=eServiceReference(self.lastservice.value)
976 if lastservice.valid():
980 self.recallBouquetMode()
981 ref = self.session.nav.getCurrentlyPlayingServiceReference()
982 if ref is not None and ref.valid() and ref.getPath() == "":
983 self.servicelist.setPlayableIgnoreService(ref)
985 self.servicelist.setPlayableIgnoreService(eServiceReference())
987 def channelSelected(self):
988 ref = self.getCurrentSelection()
990 self.toggleMoveMarked()
991 elif (ref.flags & 7) == 7:
993 elif self.bouquet_mark_edit:
995 elif not (ref.flags & 64): # no marker
999 #called from infoBar and channelSelected
1001 self.revertMode=None
1002 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1003 nref = self.getCurrentSelection()
1004 if ref is None or ref != nref:
1005 self.session.nav.playService(nref)
1008 config.servicelist.lastmode.save()
1009 self.addToHistory(nref)
1011 def addToHistory(self, ref):
1012 if self.servicePath is not None:
1013 tmp=self.servicePath[:]
1016 del self.history[self.history_pos+1:]
1019 self.history.append(tmp)
1020 hlen = len(self.history)
1021 if hlen > HISTORYSIZE:
1024 self.history_pos = hlen-1
1026 def historyBack(self):
1027 hlen = len(self.history)
1028 if hlen > 1 and self.history_pos > 0:
1029 self.history_pos -= 1
1030 self.setHistoryPath()
1032 def historyNext(self):
1033 hlen = len(self.history)
1034 if hlen > 1 and self.history_pos < (hlen-1):
1035 self.history_pos += 1
1036 self.setHistoryPath()
1038 def setHistoryPath(self):
1039 path = self.history[self.history_pos][:]
1041 del self.servicePath[:]
1042 self.servicePath += path
1046 if self.getRoot() != root:
1048 self.session.nav.playService(ref)
1049 self.setCurrentSelection(ref)
1054 for i in self.servicePath:
1055 path += i.toString()
1057 if len(path) and path != self.lastroot.value:
1058 self.lastroot.value = path
1059 self.lastroot.save()
1061 def restoreRoot(self):
1063 re = compile('.+?;')
1064 tmp = re.findall(self.lastroot.value)
1067 self.servicePath.append(eServiceReference(i[:len(i)-1]))
1070 path = self.servicePath.pop()
1071 self.enterPath(path)
1073 self.showFavourites()
1076 def preEnterPath(self, refstr):
1077 if len(self.servicePath) and self.servicePath[0] != eServiceReference(refstr):
1078 pathstr = self.lastroot.value
1079 if pathstr is not None and pathstr.find(refstr) == 0:
1081 lastservice=eServiceReference(self.lastservice.value)
1082 if lastservice.valid():
1083 self.setCurrentSelection(lastservice)
1087 def saveChannel(self):
1088 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1090 refstr = ref.toString()
1093 if refstr != self.lastservice.value:
1094 self.lastservice.value = refstr
1095 self.lastservice.save()
1097 def setCurrentServicePath(self, path):
1098 hlen = len(self.history)
1100 self.history[self.history_pos] = path
1102 self.history.append(path)
1103 self.setHistoryPath()
1105 def getCurrentServicePath(self):
1106 hlen = len(self.history)
1108 return self.history[self.history_pos]
1111 def recallPrevService(self):
1112 hlen = len(self.history)
1114 if self.history_pos == hlen-1:
1115 tmp = self.history[self.history_pos]
1116 self.history[self.history_pos] = self.history[self.history_pos-1]
1117 self.history[self.history_pos-1] = tmp
1119 tmp = self.history[self.history_pos+1]
1120 self.history[self.history_pos+1] = self.history[self.history_pos]
1121 self.history[self.history_pos] = tmp
1122 self.setHistoryPath()
1125 if self.revertMode is None:
1127 lastservice=eServiceReference(self.lastservice.value)
1128 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1129 self.setCurrentSelection(lastservice)
1130 elif self.revertMode == MODE_TV:
1132 elif self.revertMode == MODE_RADIO:
1134 self.revertMode = None
1137 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord, InfoBarRadioText
1139 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
1140 def __init__(self, session):
1141 Screen.__init__(self, session)
1142 InfoBarEvent.__init__(self)
1143 InfoBarServiceName.__init__(self)
1144 InfoBarInstantRecord.__init__(self)
1145 self["CurrentTime"] = Clock()
1147 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, InfoBarRadioText):
1149 ALLOW_SUSPEND = True
1151 def __init__(self, session):
1152 ChannelSelectionBase.__init__(self, session)
1153 ChannelSelectionEdit.__init__(self)
1154 ChannelSelectionEPG.__init__(self)
1155 InfoBarRadioText.__init__(self)
1157 config.radio = ConfigSubsection();
1158 config.radio.lastservice = ConfigText()
1159 config.radio.lastroot = ConfigText()
1160 self.onLayoutFinish.append(self.onCreate)
1162 self.info = session.instantiateDialog(RadioInfoBar)
1164 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1166 "keyTV": self.closeRadio,
1167 "keyRadio": self.closeRadio,
1168 "cancel": self.closeRadio,
1169 "ok": self.channelSelected,
1174 for i in self.servicePathRadio:
1175 path += i.toString()
1177 if len(path) and path != config.radio.lastroot.value:
1178 config.radio.lastroot.value = path
1179 config.radio.lastroot.save()
1181 def restoreRoot(self):
1183 re = compile('.+?;')
1184 tmp = re.findall(config.radio.lastroot.value)
1187 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1190 path = self.servicePathRadio.pop()
1191 self.enterPath(path)
1193 self.showFavourites()
1196 def preEnterPath(self, refstr):
1197 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1198 pathstr = config.radio.lastroot.value
1199 if pathstr is not None and pathstr.find(refstr) == 0:
1201 lastservice=eServiceReference(config.radio.lastservice.value)
1202 if lastservice.valid():
1203 self.setCurrentSelection(lastservice)
1210 lastservice=eServiceReference(config.radio.lastservice.value)
1211 if lastservice.valid():
1212 self.servicelist.setCurrent(lastservice)
1213 self.session.nav.playService(lastservice)
1214 self.servicelist.setPlayableIgnoreService(lastservice)
1217 def channelSelected(self): # just return selected service
1218 ref = self.getCurrentSelection()
1220 self.toggleMoveMarked()
1221 elif (ref.flags & 7) == 7:
1223 elif self.bouquet_mark_edit:
1225 elif not (ref.flags & 64): # no marker
1226 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1227 if playingref is None or playingref != ref:
1228 self.session.nav.playService(ref)
1229 self.servicelist.setPlayableIgnoreService(ref)
1230 config.radio.lastservice.value = ref.toString()
1231 config.radio.lastservice.save()
1234 def closeRadio(self):
1236 #set previous tv service
1237 lastservice=eServiceReference(config.tv.lastservice.value)
1238 self.session.nav.playService(lastservice)
1241 class SimpleChannelSelection(ChannelSelectionBase):
1242 def __init__(self, session, title):
1243 ChannelSelectionBase.__init__(self, session)
1245 self.onShown.append(self.__onExecCallback)
1247 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1249 "cancel": self.close,
1250 "ok": self.channelSelected,
1251 "keyRadio": self.setModeRadio,
1252 "keyTV": self.setModeTv,
1255 def __onExecCallback(self):
1256 self.setTitle(self.title)
1259 def channelSelected(self): # just return selected service
1260 ref = self.getCurrentSelection()
1261 if (ref.flags & 7) == 7:
1263 elif not (ref.flags & 64):
1264 ref = self.getCurrentSelection()
1267 def setModeTv(self):
1269 self.showFavourites()
1271 def setModeRadio(self):
1273 self.showFavourites()