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])
166 def bouquetSelClosed(self, recursive):
171 def copyCurrentToBouquetList(self):
172 self.csel.copyCurrentToBouquetList()
175 def removeBouquet(self):
176 self.csel.removeBouquet()
179 def showMarkerInputBox(self):
180 self.session.openWithCallback(self.markerInputCallback, InputBox, title=_("Please enter a name for the new marker"), text="markername", maxSize=False, type=Input.TEXT)
182 def markerInputCallback(self, marker):
183 if marker is not None:
184 self.csel.addMarker(marker)
187 def addCurrentServiceToBouquet(self, dest):
188 self.csel.addCurrentServiceToBouquet(dest)
189 if self.bsel is not None:
190 self.bsel.close(True)
192 self.close(True) # close bouquet selection
194 def removeCurrentService(self):
195 self.csel.removeCurrentService()
198 def toggleMoveMode(self):
199 self.csel.toggleMoveMode()
202 def bouquetMarkStart(self):
203 self.csel.startMarkedEdit()
206 def bouquetMarkEnd(self):
207 self.csel.endMarkedEdit(abort=False)
210 def bouquetMarkAbort(self):
211 self.csel.endMarkedEdit(abort=True)
214 def removeNewFoundFlag(self):
215 eDVBDB.getInstance().removeFlag(self.csel.getCurrentSelection(), FLAG_SERVICE_NEW_FOUND)
218 def removeAllNewFoundFlags(self):
219 curpath = self.csel.getCurrentSelection().getPath()
220 idx = curpath.find("satellitePosition == ")
222 tmp = curpath[idx+21:]
225 satpos = int(tmp[:idx])
226 eDVBDB.getInstance().removeFlags(FLAG_SERVICE_NEW_FOUND, -1, -1, -1, satpos)
229 class ChannelSelectionEPG:
231 self["ChannelSelectEPGActions"] = ActionMap(["ChannelSelectEPGActions"],
233 "showEPGList": self.showEPGList,
236 def showEPGList(self):
237 ref=self.getCurrentSelection()
238 ptr=eEPGCache.getInstance()
239 if ptr.startTimeQuery(ref) != -1:
240 self.session.open(EPGSelection, ref)
242 print 'no epg for service', ref.toString()
244 class ChannelSelectionEdit:
246 self.entry_marked = False
247 self.movemode = False
248 self.bouquet_mark_edit = False
249 self.mutableList = None
251 self.saved_title = None
252 self.saved_root = None
254 class ChannelSelectionEditActionMap(ActionMap):
255 def __init__(self, csel, contexts = [ ], actions = { }, prio=0):
256 ActionMap.__init__(self, contexts, actions, prio)
259 def action(self, contexts, action):
260 if action == "cancel":
261 self.csel.handleEditCancel()
262 return 0 # fall-trough
264 return 0 # fall-trough
266 return ActionMap.action(self, contexts, action)
268 self["ChannelSelectEditActions"] = ChannelSelectionEditActionMap(self, ["ChannelSelectEditActions", "OkCancelActions"],
270 "contextMenu": self.doContext,
273 def getMutableList(self, root=eServiceReference()):
274 if not self.mutableList is None:
275 return self.mutableList
276 serviceHandler = eServiceCenter.getInstance()
279 list = root and serviceHandler.list(root)
281 return list.startEdit()
284 def buildBouquetID(self, str):
288 if (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9'):
294 def addMarker(self, name):
295 current = self.servicelist.getCurrent()
296 mutableList = self.getMutableList()
299 str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
300 ref = eServiceReference(str)
301 if current and current.valid():
302 if not mutableList.addService(ref, current):
303 self.servicelist.addService(ref, True)
304 mutableList.flushChanges()
306 elif not mutableList.addService(ref):
307 self.servicelist.addService(ref, True)
308 mutableList.flushChanges()
312 def addBouquet(self, bName, services):
313 serviceHandler = eServiceCenter.getInstance()
314 mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
315 if mutableBouquetList:
316 if self.mode == MODE_TV:
318 str = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET \"userbouquet.%s.tv\" ORDER BY bouquet'%(self.buildBouquetID(bName))
321 str = '1:7:2:0:0:0:0:0:0:0:(type == 2) FROM BOUQUET \"userbouquet.%s.radio\" ORDER BY bouquet'%(self.buildBouquetID(bName))
322 new_bouquet_ref = eServiceReference(str)
323 if not mutableBouquetList.addService(new_bouquet_ref):
324 self.bouquetNumOffsetCache = { }
325 mutableBouquetList.flushChanges()
326 eDVBDB.getInstance().reloadBouquets()
327 mutableBouquet = serviceHandler.list(new_bouquet_ref).startEdit()
329 mutableBouquet.setListName(bName)
330 if services is not None:
331 for service in services:
332 if mutableBouquet.addService(service):
333 print "add", service.toString(), "to new bouquet failed"
335 current = self.servicelist.getCurrent()
336 if current and current.toString() == self.bouquet_rootstr:
337 self.servicelist.addService(service, True)
338 mutableBouquet.flushChanges()
340 print "get mutable list for new created bouquet failed"
342 print "add", str, "to bouquets failed"
344 print "bouquetlist is not editable"
346 def copyCurrentToBouquetList(self):
347 provider = ServiceReference(self.getCurrentSelection())
348 providerName = provider.getServiceName()
349 serviceHandler = eServiceCenter.getInstance()
350 services = serviceHandler.list(provider.ref)
351 self.addBouquet(providerName, services and services.getContent('R', True))
353 def removeBouquet(self):
354 refstr = self.getCurrentSelection().toString()
355 self.bouquetNumOffsetCache = { }
356 pos = refstr.find('FROM BOUQUET "')
358 refstr = refstr[pos+14:]
359 pos = refstr.find('"')
361 filename = '/etc/enigma2/' + refstr[:pos] # FIXMEEE !!! HARDCODED /etc/enigma2
362 self.removeCurrentService()
366 print "error during remove of", filename
368 # multiple marked entry stuff ( edit mode, later multiepg selection )
369 def startMarkedEdit(self):
370 self.mutableList = self.getMutableList()
371 # add all services from the current list to internal marked set in listboxservicecontent
372 self.clearMarks() # this clears the internal marked set in the listboxservicecontent
373 self.saved_title = self.instance.getTitle()
374 pos = self.saved_title.find(')')
375 new_title = self.saved_title[:pos+1]
376 if config.usage.multibouquet.value:
377 new_title += ' ' + _("[bouquet edit]")
379 new_title += ' ' + _("[favourite edit]")
380 self.setTitle(new_title)
381 self.bouquet_mark_edit = True
382 self.__marked = self.servicelist.getRootServices()
383 for x in self.__marked:
384 self.servicelist.addMarked(eServiceReference(x))
385 self.savedPath = self.servicePath[:]
386 self.showAllServices()
388 def endMarkedEdit(self, abort):
389 if not abort and self.mutableList is not None:
390 self.bouquetNumOffsetCache = { }
391 new_marked = set(self.servicelist.getMarked())
392 old_marked = set(self.__marked)
393 removed = old_marked - new_marked
394 added = new_marked - old_marked
398 self.mutableList.removeService(eServiceReference(x))
401 self.mutableList.addService(eServiceReference(x))
403 self.mutableList.flushChanges()
406 self.bouquet_mark_edit = False
407 self.mutableList = None
408 self.setTitle(self.saved_title)
409 self.saved_title = None
410 # self.servicePath is just a reference to servicePathTv or Radio...
411 # so we never ever do use the asignment operator in self.servicePath
412 del self.servicePath[:] # remove all elements
413 self.servicePath += self.savedPath # add saved elements
415 self.setRoot(self.servicePath[len(self.servicePath)-1])
417 def clearMarks(self):
418 self.servicelist.clearMarks()
421 ref = self.servicelist.getCurrent()
422 if self.servicelist.isMarked(ref):
423 self.servicelist.removeMarked(ref)
425 self.servicelist.addMarked(ref)
427 def removeCurrentService(self):
428 ref = self.servicelist.getCurrent()
429 mutableList = self.getMutableList()
430 if ref.valid() and mutableList is not None:
431 if not mutableList.removeService(ref):
432 self.bouquetNumOffsetCache = { }
433 mutableList.flushChanges() #FIXME dont flush on each single removed service
434 self.servicelist.removeCurrent()
436 def addCurrentServiceToBouquet(self, dest):
437 mutableList = self.getMutableList(dest)
438 if not mutableList is None:
439 if not mutableList.addService(self.servicelist.getCurrent()):
440 self.bouquetNumOffsetCache = { }
441 mutableList.flushChanges()
443 def toggleMoveMode(self):
445 if self.entry_marked:
446 self.toggleMoveMarked() # unmark current entry
447 self.movemode = False
448 self.pathChangedDisabled = False # re-enable path change
449 self.mutableList.flushChanges() # FIXME add check if changes was made
450 self.mutableList = None
451 self.setTitle(self.saved_title)
452 self.saved_title = None
453 if self.getRoot() == self.bouquet_root:
454 self.bouquetNumOffsetCache = { }
456 self.mutableList = self.getMutableList()
458 self.pathChangedDisabled = True # no path change allowed in movemode
459 self.saved_title = self.instance.getTitle()
460 new_title = self.saved_title
461 pos = self.saved_title.find(')')
462 new_title = self.saved_title[:pos+1] + ' ' + _("[move mode]") + self.saved_title[pos+1:]
463 self.setTitle(new_title);
465 def handleEditCancel(self):
466 if self.movemode: #movemode active?
467 self.channelSelected() # unmark
468 self.toggleMoveMode() # disable move mode
469 elif self.bouquet_mark_edit:
470 self.endMarkedEdit(True) # abort edit mode
472 def toggleMoveMarked(self):
473 if self.entry_marked:
474 self.servicelist.setCurrentMarked(False)
475 self.entry_marked = False
477 self.servicelist.setCurrentMarked(True)
478 self.entry_marked = True
481 self.session.open(ChannelContextMenu, self)
486 # this makes it much simple to implement a selectable radio or tv mode :)
487 service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
488 service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
490 class ChannelSelectionBase(Screen):
491 def __init__(self, session):
492 Screen.__init__(self, session)
494 self["key_red"] = Button(_("All"))
495 self["key_green"] = Button(_("Satellites"))
496 self["key_yellow"] = Button(_("Provider"))
497 self["key_blue"] = Button(_("Favourites"))
499 self["list"] = ServiceList()
500 self.servicelist = self["list"]
502 self.numericalTextInput = NumericalTextInput()
503 self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
505 self.servicePathTV = [ ]
506 self.servicePathRadio = [ ]
507 self.servicePath = [ ]
511 self.pathChangedDisabled = False
513 self.bouquetNumOffsetCache = { }
515 self["ChannelSelectBaseActions"] = NumberActionMap(["ChannelSelectBaseActions", "NumberActions"],
517 "showFavourites": self.showFavourites,
518 "showAllServices": self.showAllServices,
519 "showProviders": self.showProviders,
520 "showSatellites": self.showSatellites,
521 "nextBouquet": self.nextBouquet,
522 "prevBouquet": self.prevBouquet,
523 "nextMarker": self.nextMarker,
524 "prevMarker": self.prevMarker,
525 "1": self.keyNumberGlobal,
526 "2": self.keyNumberGlobal,
527 "3": self.keyNumberGlobal,
528 "4": self.keyNumberGlobal,
529 "5": self.keyNumberGlobal,
530 "6": self.keyNumberGlobal,
531 "7": self.keyNumberGlobal,
532 "8": self.keyNumberGlobal,
533 "9": self.keyNumberGlobal,
536 self.recallBouquetMode()
538 def appendDVBTypes(self, ref):
540 pos = path.find(' FROM BOUQUET')
542 return eServiceReference(self.service_types + path[pos:])
545 def getBouquetNumOffset(self, bouquet):
546 if config.usage.multibouquet.value:
548 bouquet = self.appendDVBTypes(bouquet)
550 return self.bouquetNumOffsetCache[bouquet.toString()]
553 serviceHandler = eServiceCenter.getInstance()
554 bouquetlist = serviceHandler.list(self.bouquet_root)
555 if not bouquetlist is None:
557 bouquetIterator = self.appendDVBTypes(bouquetlist.getNext())
558 if not bouquetIterator.valid(): #end of list
560 self.bouquetNumOffsetCache[bouquetIterator.toString()]=offsetCount
561 if ((bouquetIterator.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
563 servicelist = serviceHandler.list(bouquetIterator)
564 if not servicelist is None:
566 serviceIterator = servicelist.getNext()
567 if not serviceIterator.valid(): #check if end of list
569 if serviceIterator.flags: #playable services have no flags
572 return self.bouquetNumOffsetCache.get(bouquet.toString(), offsetCount)
574 def recallBouquetMode(self):
575 if self.mode == MODE_TV:
576 self.service_types = service_types_tv
577 if config.usage.multibouquet.value:
578 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
580 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
582 self.service_types = service_types_radio
583 if config.usage.multibouquet.value:
584 self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
586 self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
587 self.bouquet_root = eServiceReference(self.bouquet_rootstr)
591 self.servicePath = self.servicePathTV
592 self.recallBouquetMode()
593 title = self.instance.getTitle()
594 pos = title.find(" (")
600 def setRadioMode(self):
601 self.mode = MODE_RADIO
602 self.servicePath = self.servicePathRadio
603 self.recallBouquetMode()
604 title = self.instance.getTitle()
605 pos = title.find(" (")
611 def setRoot(self, root, justSet=False):
612 path = root.getPath()
613 inBouquetRootList = path.find('FROM BOUQUET "bouquets.') != -1 #FIXME HACK
614 pos = path.find(' FROM BOUQUET')
615 isBouquet = pos != -1
616 if not inBouquetRootList and isBouquet:
617 self.servicelist.setMode(ServiceList.MODE_FAVOURITES)
618 self.servicelist.setNumberOffset(self.getBouquetNumOffset(root))
619 refstr = self.service_types + path[pos:]
620 root = eServiceReference(refstr)
622 self.servicelist.setMode(ServiceList.MODE_NORMAL)
623 self.servicelist.setRoot(root, justSet)
624 self.buildTitleString()
626 def removeModeStr(self, str):
627 if self.mode == MODE_TV:
628 pos = str.find(' (TV)')
630 pos = str.find(' (Radio)')
635 def getServiceName(self, ref):
636 str = self.removeModeStr(ServiceReference(ref).getServiceName())
638 pathstr = ref.getPath()
639 if pathstr.find('FROM PROVIDERS') != -1:
641 if pathstr.find('FROM SATELLITES') != -1:
642 return _("Satellites")
643 if pathstr.find(') ORDER BY name') != -1:
647 def buildTitleString(self):
648 titleStr = self.instance.getTitle()
649 pos = titleStr.find(']')
651 pos = titleStr.find(')')
653 titleStr = titleStr[:pos+1]
654 Len = len(self.servicePath)
656 base_ref = self.servicePath[0]
658 end_ref = self.servicePath[Len-1]
661 nameStr = self.getServiceName(base_ref)
662 titleStr += ' ' + nameStr
663 if end_ref is not None:
668 nameStr = self.getServiceName(end_ref)
670 self.setTitle(titleStr)
673 self.servicelist.moveUp()
676 self.servicelist.moveDown()
679 del self.servicePath[:]
681 def enterPath(self, ref, justSet=False):
682 self.servicePath.append(ref)
683 self.setRoot(ref, justSet)
685 def pathUp(self, justSet=False):
686 prev = self.servicePath.pop()
687 length = len(self.servicePath)
689 current = self.servicePath[length-1]
690 self.setRoot(current, justSet)
692 self.setCurrentSelection(prev)
695 def isBasePathEqual(self, ref):
696 if len(self.servicePath) > 1 and self.servicePath[0] == ref:
700 def isPrevPathEqual(self, ref):
701 length = len(self.servicePath)
702 if length > 1 and self.servicePath[length-2] == ref:
706 def preEnterPath(self, refstr):
709 def showAllServices(self):
710 if not self.pathChangedDisabled:
711 refstr = '%s ORDER BY name'%(self.service_types)
712 if not self.preEnterPath(refstr):
713 ref = eServiceReference(refstr)
714 currentRoot = self.getRoot()
715 if currentRoot is None or currentRoot != ref:
719 def showSatellites(self):
720 if not self.pathChangedDisabled:
721 refstr = '%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types)
722 if not self.preEnterPath(refstr):
723 ref = eServiceReference(refstr)
727 if self.isBasePathEqual(ref):
728 if self.isPrevPathEqual(ref):
730 prev = self.pathUp(justSet)
732 currentRoot = self.getRoot()
733 if currentRoot is None or currentRoot != ref:
736 self.enterPath(ref, True)
738 serviceHandler = eServiceCenter.getInstance()
739 servicelist = serviceHandler.list(ref)
740 if not servicelist is None:
742 service = servicelist.getNext()
743 if not service.valid(): #check if end of list
745 orbpos = service.getUnsignedData(4) >> 16
746 if service.getPath().find("FROM PROVIDER") != -1:
747 service_name = _("Providers")
748 elif service.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
749 service_name = _("New")
751 service_name = _("Services")
753 service_name += str(' - %s'%(nimmanager.getSatDescription(orbpos)))
754 service.setName(service_name) # why we need this cast?
756 if orbpos == 0xFFFF: #Cable
757 n = ("%s (%s)") % (service_name, _("Cable"))
758 elif orbpos == 0xEEEE: #Terrestrial
759 n = ("%s (%s)") % (service_name, _("Terrestrial"))
761 if orbpos > 1800: # west
762 orbpos = 3600 - orbpos
766 n = ("%s (%d.%d" + h + ")") % (service_name, orbpos / 10, orbpos % 10)
768 self.servicelist.addService(service)
769 self.servicelist.finishFill()
771 self.setCurrentSelection(prev)
773 def showProviders(self):
774 if not self.pathChangedDisabled:
775 refstr = '%s FROM PROVIDERS ORDER BY name'%(self.service_types)
776 if not self.preEnterPath(refstr):
777 ref = eServiceReference(refstr)
778 if self.isBasePathEqual(ref):
781 currentRoot = self.getRoot()
782 if currentRoot is None or currentRoot != ref:
786 def changeBouquet(self, direction):
787 if not self.pathChangedDisabled:
788 if self.isBasePathEqual(self.bouquet_root):
794 ref = self.getCurrentSelection()
798 return self.isBasePathEqual(self.bouquet_root)
801 return self.servicelist.atBegin()
804 return self.servicelist.atEnd()
806 def nextBouquet(self):
807 self.changeBouquet(+1)
809 def prevBouquet(self):
810 self.changeBouquet(-1)
812 def showFavourites(self):
813 if not self.pathChangedDisabled:
814 if not self.preEnterPath(self.bouquet_rootstr):
815 if self.isBasePathEqual(self.bouquet_root):
818 currentRoot = self.getRoot()
819 if currentRoot is None or currentRoot != self.bouquet_root:
821 self.enterPath(self.bouquet_root)
823 def keyNumberGlobal(self, number):
824 unichar = self.numericalTextInput.getKey(number)
825 charstr = unichar.encode("utf-8")
826 if len(charstr) == 1:
827 self.servicelist.moveToChar(charstr[0])
830 return self.servicelist.getRoot()
832 def getCurrentSelection(self):
833 return self.servicelist.getCurrent()
835 def setCurrentSelection(self, service):
836 servicepath = service.getPath()
837 pos = servicepath.find(" FROM BOUQUET")
839 if self.mode == MODE_TV:
840 servicepath = '(type == 1)' + servicepath[pos:]
842 servicepath = '(type == 2)' + servicepath[pos:]
843 service.setPath(servicepath)
844 self.servicelist.setCurrent(service)
846 def getBouquetList(self):
848 serviceHandler = eServiceCenter.getInstance()
849 if config.usage.multibouquet.value:
850 list = serviceHandler.list(self.bouquet_root)
856 if ((s.flags & eServiceReference.flagDirectory) == eServiceReference.flagDirectory):
857 info = serviceHandler.info(s)
859 bouquets.append((info.getName(s), s))
862 info = serviceHandler.info(self.bouquet_root)
864 bouquets.append((info.getName(self.bouquet_root), self.bouquet_root))
868 def keyNumber0(self, num):
869 if len(self.servicePath) > 1:
872 self.keyNumberGlobal(num)
875 if len(self.servicePath) > 1:
876 if self.isBasePathEqual(self.bouquet_root):
877 self.showFavourites()
879 ref = eServiceReference('%s FROM SATELLITES ORDER BY satellitePosition'%(self.service_types))
880 if self.isBasePathEqual(ref):
881 self.showSatellites()
883 ref = eServiceReference('%s FROM PROVIDERS ORDER BY name'%(self.service_types))
884 if self.isBasePathEqual(ref):
887 self.showAllServices()
889 def nextMarker(self):
890 self.servicelist.moveToNextMarker()
892 def prevMarker(self):
893 self.servicelist.moveToPrevMarker()
897 #config for lastservice
898 config.tv = ConfigSubsection()
899 config.tv.lastservice = ConfigText()
900 config.tv.lastroot = ConfigText()
901 config.radio = ConfigSubsection()
902 config.radio.lastservice = ConfigText()
903 config.radio.lastroot = ConfigText()
904 config.servicelist = ConfigSubsection()
905 config.servicelist.lastmode = ConfigText(default = "tv")
907 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
908 def __init__(self, session):
909 ChannelSelectionBase.__init__(self,session)
910 ChannelSelectionEdit.__init__(self)
911 ChannelSelectionEPG.__init__(self)
913 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
915 "cancel": self.cancel,
916 "ok": self.channelSelected,
917 "keyRadio": self.setModeRadio,
918 "keyTV": self.setModeTv,
921 self.onShown.append(self.__onShown)
923 self.lastChannelRootTimer = eTimer()
924 self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
925 self.lastChannelRootTimer.start(100,True)
927 self.history_tv = [ ]
928 self.history_radio = [ ]
929 self.history = self.history_tv
932 self.lastservice = config.tv.lastservice
933 self.lastroot = config.tv.lastroot
934 self.revertMode = None
938 lastservice=eServiceReference(self.lastservice.value)
939 if lastservice.valid():
940 self.setCurrentSelection(lastservice)
943 if self.revertMode is None and config.servicelist.lastmode.value == "radio":
944 self.revertMode = MODE_RADIO
945 self.history = self.history_tv
946 self.lastservice = config.tv.lastservice
947 self.lastroot = config.tv.lastroot
948 config.servicelist.lastmode.value = "tv"
952 def setModeRadio(self):
953 if self.revertMode is None and config.servicelist.lastmode.value == "tv":
954 self.revertMode = MODE_TV
955 if config.usage.e1like_radio_mode.value:
956 self.history = self.history_radio
957 self.lastservice = config.radio.lastservice
958 self.lastroot = config.radio.lastroot
959 config.servicelist.lastmode.value = "radio"
963 def __onCreate(self):
964 if config.usage.e1like_radio_mode.value:
965 if config.servicelist.lastmode.value == "tv":
971 lastservice=eServiceReference(self.lastservice.value)
972 if lastservice.valid():
976 self.recallBouquetMode()
977 ref = self.session.nav.getCurrentlyPlayingServiceReference()
978 if ref is not None and ref.valid() and ref.getPath() == "":
979 self.servicelist.setPlayableIgnoreService(ref)
981 self.servicelist.setPlayableIgnoreService(eServiceReference())
983 def channelSelected(self):
984 ref = self.getCurrentSelection()
986 self.toggleMoveMarked()
987 elif (ref.flags & 7) == 7:
989 elif self.bouquet_mark_edit:
991 elif not (ref.flags & 64): # no marker
995 #called from infoBar and channelSelected
998 ref = self.session.nav.getCurrentlyPlayingServiceReference()
999 nref = self.getCurrentSelection()
1000 if ref is None or ref != nref:
1001 self.session.nav.playService(nref)
1004 config.servicelist.lastmode.save()
1005 self.addToHistory(nref)
1007 def addToHistory(self, ref):
1008 if self.servicePath is not None:
1009 tmp=self.servicePath[:]
1012 del self.history[self.history_pos+1:]
1015 self.history.append(tmp)
1016 hlen = len(self.history)
1017 if hlen > HISTORYSIZE:
1020 self.history_pos = hlen-1
1022 def historyBack(self):
1023 hlen = len(self.history)
1024 if hlen > 1 and self.history_pos > 0:
1025 self.history_pos -= 1
1026 self.setHistoryPath()
1028 def historyNext(self):
1029 hlen = len(self.history)
1030 if hlen > 1 and self.history_pos < (hlen-1):
1031 self.history_pos += 1
1032 self.setHistoryPath()
1034 def setHistoryPath(self):
1035 path = self.history[self.history_pos][:]
1037 del self.servicePath[:]
1038 self.servicePath += path
1042 if self.getRoot() != root:
1044 self.session.nav.playService(ref)
1045 self.setCurrentSelection(ref)
1050 for i in self.servicePath:
1051 path += i.toString()
1053 if len(path) and path != self.lastroot.value:
1054 self.lastroot.value = path
1055 self.lastroot.save()
1057 def restoreRoot(self):
1059 re = compile('.+?;')
1060 tmp = re.findall(self.lastroot.value)
1063 self.servicePath.append(eServiceReference(i[:len(i)-1]))
1066 path = self.servicePath.pop()
1067 self.enterPath(path)
1069 self.showFavourites()
1072 def preEnterPath(self, refstr):
1073 if len(self.servicePath) and self.servicePath[0] != eServiceReference(refstr):
1074 pathstr = self.lastroot.value
1075 if pathstr is not None and pathstr.find(refstr) == 0:
1077 lastservice=eServiceReference(self.lastservice.value)
1078 if lastservice.valid():
1079 self.setCurrentSelection(lastservice)
1083 def saveChannel(self):
1084 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1086 refstr = ref.toString()
1089 if refstr != self.lastservice.value:
1090 self.lastservice.value = refstr
1091 self.lastservice.save()
1093 def setCurrentServicePath(self, path):
1094 hlen = len(self.history)
1096 self.history[self.history_pos] = path
1098 self.history.append(path)
1099 self.setHistoryPath()
1101 def getCurrentServicePath(self):
1102 hlen = len(self.history)
1104 return self.history[self.history_pos]
1107 def recallPrevService(self):
1108 hlen = len(self.history)
1110 if self.history_pos == hlen-1:
1111 tmp = self.history[self.history_pos]
1112 self.history[self.history_pos] = self.history[self.history_pos-1]
1113 self.history[self.history_pos-1] = tmp
1115 tmp = self.history[self.history_pos+1]
1116 self.history[self.history_pos+1] = self.history[self.history_pos]
1117 self.history[self.history_pos] = tmp
1118 self.setHistoryPath()
1121 if self.revertMode is None:
1123 lastservice=eServiceReference(self.lastservice.value)
1124 if lastservice.valid() and self.getCurrentSelection() != lastservice:
1125 self.setCurrentSelection(lastservice)
1126 elif self.revertMode == MODE_TV:
1128 elif self.revertMode == MODE_RADIO:
1130 self.revertMode = None
1133 from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord, InfoBarRadioText
1135 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
1136 def __init__(self, session):
1137 Screen.__init__(self, session)
1138 InfoBarEvent.__init__(self)
1139 InfoBarServiceName.__init__(self)
1140 InfoBarInstantRecord.__init__(self)
1141 self["CurrentTime"] = Clock()
1143 class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, InfoBarRadioText):
1145 ALLOW_SUSPEND = True
1147 def __init__(self, session):
1148 ChannelSelectionBase.__init__(self, session)
1149 ChannelSelectionEdit.__init__(self)
1150 ChannelSelectionEPG.__init__(self)
1151 InfoBarRadioText.__init__(self)
1153 config.radio = ConfigSubsection();
1154 config.radio.lastservice = ConfigText()
1155 config.radio.lastroot = ConfigText()
1156 self.onLayoutFinish.append(self.onCreate)
1158 self.info = session.instantiateDialog(RadioInfoBar)
1160 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1162 "keyTV": self.closeRadio,
1163 "keyRadio": self.closeRadio,
1164 "cancel": self.closeRadio,
1165 "ok": self.channelSelected,
1170 for i in self.servicePathRadio:
1171 path += i.toString()
1173 if len(path) and path != config.radio.lastroot.value:
1174 config.radio.lastroot.value = path
1175 config.radio.lastroot.save()
1177 def restoreRoot(self):
1179 re = compile('.+?;')
1180 tmp = re.findall(config.radio.lastroot.value)
1183 self.servicePathRadio.append(eServiceReference(i[:len(i)-1]))
1186 path = self.servicePathRadio.pop()
1187 self.enterPath(path)
1189 self.showFavourites()
1192 def preEnterPath(self, refstr):
1193 if len(self.servicePathRadio) and self.servicePathRadio[0] != eServiceReference(refstr):
1194 pathstr = config.radio.lastroot.value
1195 if pathstr is not None and pathstr.find(refstr) == 0:
1197 lastservice=eServiceReference(config.radio.lastservice.value)
1198 if lastservice.valid():
1199 self.setCurrentSelection(lastservice)
1206 lastservice=eServiceReference(config.radio.lastservice.value)
1207 if lastservice.valid():
1208 self.servicelist.setCurrent(lastservice)
1209 self.session.nav.playService(lastservice)
1210 self.servicelist.setPlayableIgnoreService(lastservice)
1213 def channelSelected(self): # just return selected service
1214 ref = self.getCurrentSelection()
1216 self.toggleMoveMarked()
1217 elif (ref.flags & 7) == 7:
1219 elif self.bouquet_mark_edit:
1221 elif not (ref.flags & 64): # no marker
1222 playingref = self.session.nav.getCurrentlyPlayingServiceReference()
1223 if playingref is None or playingref != ref:
1224 self.session.nav.playService(ref)
1225 self.servicelist.setPlayableIgnoreService(ref)
1226 config.radio.lastservice.value = ref.toString()
1227 config.radio.lastservice.save()
1230 def closeRadio(self):
1232 #set previous tv service
1233 lastservice=eServiceReference(config.tv.lastservice.value)
1234 self.session.nav.playService(lastservice)
1237 class SimpleChannelSelection(ChannelSelectionBase):
1238 def __init__(self, session, title):
1239 ChannelSelectionBase.__init__(self, session)
1241 self.onShown.append(self.__onExecCallback)
1243 self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
1245 "cancel": self.close,
1246 "ok": self.channelSelected,
1247 "keyRadio": self.setModeRadio,
1248 "keyTV": self.setModeTv,
1251 def __onExecCallback(self):
1252 self.setTitle(self.title)
1255 def channelSelected(self): # just return selected service
1256 ref = self.getCurrentSelection()
1257 if (ref.flags & 7) == 7:
1259 elif not (ref.flags & 64):
1260 ref = self.getCurrentSelection()
1263 def setModeTv(self):
1265 self.showFavourites()
1267 def setModeRadio(self):
1269 self.showFavourites()