revert local change (just for testing)
[enigma2.git] / lib / python / Screens / ChannelSelection.py
index d4a5279909f2434b2626fb552d165d4ccb11e90c..ff2928ecf14d1dab2f6df9cf69a29b2bf52ad636 100644 (file)
@@ -4,17 +4,18 @@ from Components.ServiceList import ServiceList
 from Components.ActionMap import NumberActionMap, ActionMap
 from Components.MenuList import MenuList
 from EpgSelection import EPGSelection
-from enigma import eServiceReference, eEPGCache, eEPGCachePtr, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
-from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
+from enigma import eServiceReference, eEPGCache, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
+from Components.config import config, ConfigSubsection, ConfigText
 from Screens.FixedMenu import FixedMenu
 from Tools.NumericalTextInput import NumericalTextInput
 from Components.NimManager import nimmanager
-from Components.ServiceName import ServiceName
-from Components.Clock import Clock
-from Components.EventInfo import EventInfo
+from Components.Sources.Clock import Clock
 from Components.Input import Input
-from Screens.InputBox import InputBox
+from Components.ParentalControl import parentalControl
+from Screens.InputBox import InputBox, PinInput
+from Screens.MessageBox import MessageBox
 from ServiceReference import ServiceReference
+from Tools.BoundFunction import boundFunction
 from re import *
 from os import remove
 
@@ -77,6 +78,11 @@ class ChannelContextMenu(Screen):
                if not csel.bouquet_mark_edit and not csel.movemode:
                        if not inBouquetRootList:
                                if (csel.getCurrentSelection().flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
+                                       if config.ParentalControl.configured.value:
+                                               if parentalControl.getProtectionLevel(csel.getCurrentSelection().toCompareString()) == -1:
+                                                       menu.append((_("add to parental protection"), boundFunction(self.addParentalProtection, csel.getCurrentSelection())))
+                                               else:
+                                                       menu.append((_("remove from parental protection"), boundFunction(self.removeParentalProtection, csel.getCurrentSelection())))
                                        if haveBouquets:
                                                menu.append((_("add service to bouquet"), self.addServiceToBouquetSelected))
                                        else:
@@ -88,17 +94,18 @@ class ChannelContextMenu(Screen):
                                        if current_sel_path.find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
                                                menu.append((_("remove all new found flags"), self.removeAllNewFoundFlags))
                                if inBouquet:
-                                       menu.append((_("remove service"), self.removeCurrentService))
-                               if current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
+                                       menu.append((_("remove entry"), self.removeCurrentService))
+                               if current_root is not None and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
                                        menu.append((_("remove new found flag"), self.removeNewFoundFlag))
-                       elif haveBouquets:
-                               menu.append((_("remove bouquet"), self.removeBouquet))
+                       else:
+                                       menu.append((_("add bouquet"), self.showBouquetInputBox))
+                                       menu.append((_("remove entry"), self.removeBouquet))
 
                if inBouquet: # current list is editable?
                        if not csel.bouquet_mark_edit:
                                if not csel.movemode:
+                                       menu.append((_("add marker"), self.showMarkerInputBox))
                                        menu.append((_("enable move mode"), self.toggleMoveMode))
-                                       menu.append((_("add bouquet..."), self.showBouquetInputBox))
                                        if not inBouquetRootList:
                                                if haveBouquets:
                                                        menu.append((_("enable bouquet edit"), self.bouquetMarkStart))
@@ -128,7 +135,23 @@ class ChannelContextMenu(Screen):
 
        def bouquetInputCallback(self, bouquet):
                if bouquet is not None:
-                       self.csel.addBouquet(bouquet, None, True)
+                       self.csel.addBouquet(bouquet, None)
+               self.close()
+
+       def addParentalProtection(self, service):
+               parentalControl.protectService(service.toCompareString())
+               self.close()
+
+       def removeParentalProtection(self, service):
+               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"))
+
+       def pinEntered(self, service, result):
+               if result:
+                       parentalControl.unProtectService(service)
+                       self.close()
+               else:
+                       self.session.openWithCallback(self.close, MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR)
+               
 
        def addServiceToBouquetSelected(self):
                bouquets = self.csel.getBouquetList()
@@ -156,6 +179,14 @@ class ChannelContextMenu(Screen):
                self.csel.removeBouquet()
                self.close()
 
+       def showMarkerInputBox(self):
+               self.session.openWithCallback(self.markerInputCallback, InputBox, title=_("Please enter a name for the new marker"), text="markername", maxSize=False, type=Input.TEXT)
+
+       def markerInputCallback(self, marker):
+               if marker is not None:
+                       self.csel.addMarker(marker)
+               self.close()
+
        def addCurrentServiceToBouquet(self, dest):
                self.csel.addCurrentServiceToBouquet(dest)
                if self.bsel is not None:
@@ -263,7 +294,25 @@ class ChannelSelectionEdit:
                                name += '_'
                return name
 
-       def addBouquet(self, bName, services, refresh=False):
+       def addMarker(self, name):
+               current = self.servicelist.getCurrent()
+               mutableList = self.getMutableList()
+               cnt = 0
+               while mutableList:
+                       str = '1:64:%d:0:0:0:0:0:0:0::%s'%(cnt, name)
+                       ref = eServiceReference(str)
+                       if current and current.valid():
+                               if not mutableList.addService(ref, current):
+                                       self.servicelist.addService(ref, True)
+                                       mutableList.flushChanges()
+                                       break
+                       elif not mutableList.addService(ref):
+                               self.servicelist.addService(ref, True)
+                               mutableList.flushChanges()
+                               break
+                       cnt+=1
+
+       def addBouquet(self, bName, services):
                serviceHandler = eServiceCenter.getInstance()
                mutableBouquetList = serviceHandler.list(self.bouquet_root).startEdit()
                if mutableBouquetList:
@@ -285,9 +334,11 @@ class ChannelSelectionEdit:
                                                for service in services:
                                                        if mutableBouquet.addService(service):
                                                                print "add", service.toString(), "to new bouquet failed"
+                                                       else:
+                                                               current = self.servicelist.getCurrent()
+                                                               if current and current.toString() == self.bouquet_rootstr:
+                                                                       self.servicelist.addService(service, True)
                                        mutableBouquet.flushChanges()
-                                       if refresh:
-                                               self.setRoot(self.getRoot())
                                else:
                                        print "get mutable list for new created bouquet failed"
                        else:
@@ -316,7 +367,6 @@ class ChannelSelectionEdit:
                        remove(filename)
                except OSError:
                        print "error during remove of", filename
-               eDVBDB.getInstance().reloadBouquets()
 
 #  multiple marked entry stuff ( edit mode, later multiepg selection )
        def startMarkedEdit(self):
@@ -384,7 +434,7 @@ class ChannelSelectionEdit:
                        if not mutableList.removeService(ref):
                                self.bouquetNumOffsetCache = { }
                                mutableList.flushChanges() #FIXME dont flush on each single removed service
-                               self.setRoot(self.getRoot())
+                               self.servicelist.removeCurrent()
 
        def addCurrentServiceToBouquet(self, dest):
                mutableList = self.getMutableList(dest)
@@ -436,14 +486,14 @@ class ChannelSelectionEdit:
 MODE_TV = 0
 MODE_RADIO = 1
 
+# this makes it much simple to implement a selectable radio or tv mode :)
+service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
+service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
+
 class ChannelSelectionBase(Screen):
        def __init__(self, session):
                Screen.__init__(self, session)
 
-               # this makes it much simple to implement a selectable radio or tv mode :)
-               self.service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 195) || (type == 25)'
-               self.service_types_radio = '1:7:2:0:0:0:0:0:0:0:(type == 2)'
-
                self["key_red"] = Button(_("All"))
                self["key_green"] = Button(_("Satellites"))
                self["key_yellow"] = Button(_("Provider"))
@@ -453,6 +503,7 @@ class ChannelSelectionBase(Screen):
                self.servicelist = self["list"]
 
                self.numericalTextInput = NumericalTextInput()
+               self.numericalTextInput.setUseableChars(u'1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
                self.servicePathTV = [ ]
                self.servicePathRadio = [ ]
@@ -472,6 +523,8 @@ class ChannelSelectionBase(Screen):
                                "showSatellites": self.showSatellites,
                                "nextBouquet": self.nextBouquet,
                                "prevBouquet": self.prevBouquet,
+                               "nextMarker": self.nextMarker,
+                               "prevMarker": self.prevMarker,
                                "1": self.keyNumberGlobal,
                                "2": self.keyNumberGlobal,
                                "3": self.keyNumberGlobal,
@@ -483,6 +536,7 @@ class ChannelSelectionBase(Screen):
                                "9": self.keyNumberGlobal,
                                "0": self.keyNumber0
                        })
+               self.recallBouquetMode()
 
        def appendDVBTypes(self, ref):
                path = ref.getPath()
@@ -522,14 +576,14 @@ class ChannelSelectionBase(Screen):
 
        def recallBouquetMode(self):
                if self.mode == MODE_TV:
-                       self.service_types = self.service_types_tv
-                       if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
+                       self.service_types = service_types_tv
+                       if config.usage.multibouquet.value:
                                self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
                        else:
                                self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
                else:
-                       self.service_types = self.service_types_radio
-                       if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
+                       self.service_types = service_types_radio
+                       if config.usage.multibouquet.value:
                                self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
                        else:
                                self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
@@ -770,8 +824,10 @@ class ChannelSelectionBase(Screen):
                                                self.enterPath(self.bouquet_root)
 
        def keyNumberGlobal(self, number):
-               char = self.numericalTextInput.getKey(number)
-               self.servicelist.moveToChar(char)
+               unichar = self.numericalTextInput.getKey(number)
+               charstr = unichar.encode("utf-8")
+               if len(charstr) == 1:
+                       self.servicelist.moveToChar(charstr[0])
 
        def getRoot(self):
                return self.servicelist.getRoot()
@@ -834,39 +890,90 @@ class ChannelSelectionBase(Screen):
                                        else:
                                                self.showAllServices()
 
+       def nextMarker(self):
+               self.servicelist.moveToNextMarker()
+
+       def prevMarker(self):
+               self.servicelist.moveToPrevMarker()
+
 HISTORYSIZE = 20
 
+#config for lastservice
+config.tv = ConfigSubsection()
+config.tv.lastservice = ConfigText()
+config.tv.lastroot = ConfigText()
+config.radio = ConfigSubsection()
+config.radio.lastservice = ConfigText()
+config.radio.lastroot = ConfigText()
+config.servicelist = ConfigSubsection()
+config.servicelist.lastmode = ConfigText(default = "tv")
+
 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
        def __init__(self, session):
                ChannelSelectionBase.__init__(self,session)
                ChannelSelectionEdit.__init__(self)
                ChannelSelectionEPG.__init__(self)
 
-               #config for lastservice
-               config.tv = ConfigSubsection();
-               config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0);
-               config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0);
-
-               self["actions"] = ActionMap(["OkCancelActions"],
+               self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions"],
                        {
                                "cancel": self.cancel,
                                "ok": self.channelSelected,
+                               "keyRadio": self.setModeRadio,
+                               "keyTV": self.setModeTv,
                        })
+
                self.onShown.append(self.__onShown)
 
                self.lastChannelRootTimer = eTimer()
                self.lastChannelRootTimer.timeout.get().append(self.__onCreate)
                self.lastChannelRootTimer.start(100,True)
 
-               self.history = [ ]
+               self.history_tv = [ ]
+               self.history_radio = [ ]
+               self.history = self.history_tv
                self.history_pos = 0
 
-       def __onCreate(self):
-               self.setTvMode()
+               self.lastservice = config.tv.lastservice
+               self.lastroot = config.tv.lastroot
+               self.revertMode = None
+
+       def setMode(self):
                self.restoreRoot()
-               lastservice=eServiceReference(config.tv.lastservice.value)
+               lastservice=eServiceReference(self.lastservice.value)
                if lastservice.valid():
                        self.setCurrentSelection(lastservice)
+
+       def setModeTv(self):
+               if self.revertMode is None and config.servicelist.lastmode.value == "radio":
+                       self.revertMode = MODE_RADIO
+               self.history = self.history_tv
+               self.lastservice = config.tv.lastservice
+               self.lastroot = config.tv.lastroot
+               config.servicelist.lastmode.value = "tv"
+               self.setTvMode()
+               self.setMode()
+
+       def setModeRadio(self):
+               if self.revertMode is None and config.servicelist.lastmode.value == "tv":
+                       self.revertMode = MODE_TV
+               if config.usage.e1like_radio_mode.value:
+                       self.history = self.history_radio
+                       self.lastservice = config.radio.lastservice
+                       self.lastroot = config.radio.lastroot
+                       config.servicelist.lastmode.value = "radio"
+                       self.setRadioMode()
+                       self.setMode()
+
+       def __onCreate(self):
+               if config.usage.e1like_radio_mode.value:
+                       if config.servicelist.lastmode.value == "tv":
+                               self.setModeTv()
+                       else:
+                               self.setModeRadio()
+               else:
+                       self.setModeTv()
+               lastservice=eServiceReference(self.lastservice.value)
+               if lastservice.valid():
                        self.zap()
 
        def __onShown(self):
@@ -885,18 +992,20 @@ class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelect
                        self.enterPath(ref)
                elif self.bouquet_mark_edit:
                        self.doMark()
-               else:
+               elif not (ref.flags & 64): # no marker
                        self.zap()
                        self.close(ref)
 
        #called from infoBar and channelSelected
        def zap(self):
+               self.revertMode=None
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                nref = self.getCurrentSelection()
                if ref is None or ref != nref:
                        self.session.nav.playService(nref)
                        self.saveRoot()
                        self.saveChannel()
+                       config.servicelist.lastmode.save()
                        self.addToHistory(nref)
 
        def addToHistory(self, ref):
@@ -942,34 +1051,34 @@ class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelect
 
        def saveRoot(self):
                path = ''
-               for i in self.servicePathTV:
+               for i in self.servicePath:
                        path += i.toString()
                        path += ';'
-               if len(path) and path != config.tv.lastroot.value:
-                       config.tv.lastroot.value = path
-                       config.tv.lastroot.save()
+               if len(path) and path != self.lastroot.value:
+                       self.lastroot.value = path
+                       self.lastroot.save()
 
        def restoreRoot(self):
                self.clearPath()
                re = compile('.+?;')
-               tmp = re.findall(config.tv.lastroot.value)
+               tmp = re.findall(self.lastroot.value)
                cnt = 0
                for i in tmp:
-                       self.servicePathTV.append(eServiceReference(i[:len(i)-1]))
+                       self.servicePath.append(eServiceReference(i[:len(i)-1]))
                        cnt += 1
                if cnt:
-                       path = self.servicePathTV.pop()
+                       path = self.servicePath.pop()
                        self.enterPath(path)
                else:
                        self.showFavourites()
                        self.saveRoot()
 
        def preEnterPath(self, refstr):
-               if len(self.servicePathTV) and self.servicePathTV[0] != eServiceReference(refstr):
-                       pathstr = config.tv.lastroot.value
+               if len(self.servicePath) and self.servicePath[0] != eServiceReference(refstr):
+                       pathstr = self.lastroot.value
                        if pathstr is not None and pathstr.find(refstr) == 0:
                                self.restoreRoot()
-                               lastservice=eServiceReference(config.tv.lastservice.value)
+                               lastservice=eServiceReference(self.lastservice.value)
                                if lastservice.valid():
                                        self.setCurrentSelection(lastservice)
                                return True
@@ -981,9 +1090,23 @@ class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelect
                        refstr = ref.toString()
                else:
                        refstr = ""
-               if refstr != config.tv.lastservice.value:
-                       config.tv.lastservice.value = refstr
-                       config.tv.lastservice.save()
+               if refstr != self.lastservice.value:
+                       self.lastservice.value = refstr
+                       self.lastservice.save()
+
+       def setCurrentServicePath(self, path):
+               hlen = len(self.history)
+               if hlen > 0:
+                       self.history[self.history_pos] = path
+               else:
+                       self.history.append(path)
+               self.setHistoryPath()
+
+       def getCurrentServicePath(self):
+               hlen = len(self.history)
+               if hlen > 0:
+                       return self.history[self.history_pos]
+               return None
 
        def recallPrevService(self):
                hlen = len(self.history)
@@ -999,13 +1122,19 @@ class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelect
                        self.setHistoryPath()
 
        def cancel(self):
+               if self.revertMode is None:
+                       self.restoreRoot()
+                       lastservice=eServiceReference(self.lastservice.value)
+                       if lastservice.valid() and self.getCurrentSelection() != lastservice:
+                               self.setCurrentSelection(lastservice)
+               elif self.revertMode == MODE_TV:
+                       self.setModeTv()
+               elif self.revertMode == MODE_RADIO:
+                       self.setModeRadio()
+               self.revertMode = None
                self.close(None)
-               self.restoreRoot()
-               lastservice=eServiceReference(config.tv.lastservice.value)
-               if lastservice.valid() and self.getCurrentSelection() != lastservice:
-                       self.setCurrentSelection(lastservice)
 
-from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord
+from Screens.InfoBarGenerics import InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord, InfoBarRadioText
 
 class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecord):
        def __init__(self, session):
@@ -1013,17 +1142,21 @@ class RadioInfoBar(Screen, InfoBarEvent, InfoBarServiceName, InfoBarInstantRecor
                InfoBarEvent.__init__(self)
                InfoBarServiceName.__init__(self)
                InfoBarInstantRecord.__init__(self)
-               self["Clock"] = Clock()
+               self["CurrentTime"] = Clock()
+
+class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG, InfoBarRadioText):
+
+       ALLOW_SUSPEND = True
 
-class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
        def __init__(self, session):
                ChannelSelectionBase.__init__(self, session)
                ChannelSelectionEdit.__init__(self)
                ChannelSelectionEPG.__init__(self)
+               InfoBarRadioText.__init__(self)
 
                config.radio = ConfigSubsection();
-               config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
-               config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
+               config.radio.lastservice = ConfigText()
+               config.radio.lastroot = ConfigText()
                self.onLayoutFinish.append(self.onCreate)
 
                self.info = session.instantiateDialog(RadioInfoBar)
@@ -1089,7 +1222,7 @@ class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelS
                        self.enterPath(ref)
                elif self.bouquet_mark_edit:
                        self.doMark()
-               else:
+               elif not (ref.flags & 64): # no marker
                        playingref = self.session.nav.getCurrentlyPlayingServiceReference()
                        if playingref is None or playingref != ref:
                                self.session.nav.playService(ref)
@@ -1127,7 +1260,7 @@ class SimpleChannelSelection(ChannelSelectionBase):
                ref = self.getCurrentSelection()
                if (ref.flags & 7) == 7:
                        self.enterPath(ref)
-               else:
+               elif not (ref.flags & 64):
                        ref = self.getCurrentSelection()
                        self.close(ref)