git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
By Anders Holst:
[enigma2.git] / lib / python / Screens / InfoBarGenerics.py
diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index 409018de272ca6ec718577d7fbe9dcf497727145..5336f9a0192d87d3569de886a086780fd7442475 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -29,7 +29,7 @@ from Screens.TimeDateInput import TimeDateInput
 from ServiceReference import ServiceReference
 
 from Tools import Notifications
 from ServiceReference import ServiceReference
 
 from Tools import Notifications
-from Tools.Directories import SCOPE_HDD, resolveFilename, pathExists
+from Tools.Directories import SCOPE_HDD, resolveFilename, fileExists
 
 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
        iPlayableService, eServiceReference, eEPGCache
 
 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
        iPlayableService, eServiceReference, eEPGCache
@@ -348,14 +348,14 @@ class InfoBarMenu:
 
        def mainMenu(self):
                print "loading mainmenu XML..."
 
        def mainMenu(self):
                print "loading mainmenu XML..."
-               menu = mdom.childNodes[0]
-               assert menu.tagName == "menu", "root element in menu must be 'menu'!"
+               menu = mdom.getroot()
+               assert menu.tag == "menu", "root element in menu must be 'menu'!"
 
                self.session.infobar = self
                # so we can access the currently active infobar from screens opened from within the mainmenu
                # at the moment used from the SubserviceSelection
 
 
                self.session.infobar = self
                # so we can access the currently active infobar from screens opened from within the mainmenu
                # at the moment used from the SubserviceSelection
 
-               self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes)
+               self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
 
        def mainMenuClosed(self, *val):
                self.session.infobar = None
 
        def mainMenuClosed(self, *val):
                self.session.infobar = None
@@ -366,28 +366,77 @@ class InfoBarSimpleEventView:
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
                                "showEventInfo": (self.openEventView, _("show event details")),
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
                                "showEventInfo": (self.openEventView, _("show event details")),
+                               "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
                        })
 
                        })
 
+       def showEventInfoWhenNotVisible(self):
+               if self.shown:
+                       self.openEventView()
+               else:
+                       self.toggleShow()
+                       return 1
+
        def openEventView(self):
        def openEventView(self):
-               self.epglist = [ ]
+               epglist = [ ]
+               self.epglist = epglist
                service = self.session.nav.getCurrentService()
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                info = service.info()
                ptr=info.getEvent(0)
                if ptr:
                service = self.session.nav.getCurrentService()
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                info = service.info()
                ptr=info.getEvent(0)
                if ptr:
-                       self.epglist.append(ptr)
+                       epglist.append(ptr)
                ptr=info.getEvent(1)
                if ptr:
                ptr=info.getEvent(1)
                if ptr:
-                       self.epglist.append(ptr)
-               if len(self.epglist) > 0:
-                       self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
+                       epglist.append(ptr)
+               if epglist:
+                       self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
 
        def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
 
        def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
-               if len(self.epglist) > 1:
-                       tmp = self.epglist[0]
-                       self.epglist[0]=self.epglist[1]
-                       self.epglist[1]=tmp
-                       setEvent(self.epglist[0])
+               epglist = self.epglist
+               if len(epglist) > 1:
+                       tmp = epglist[0]
+                       epglist[0] = epglist[1]
+                       epglist[1] = tmp
+                       setEvent(epglist[0])
+
+class SimpleServicelist:
+       def __init__(self, services):
+               self.services = services
+               self.length = len(services)
+               self.current = 0
+
+       def selectService(self, service):
+               if not self.length:
+                       self.current = -1
+                       return False
+               else:
+                       self.current = 0
+                       while self.services[self.current].ref != service:
+                               self.current += 1
+                               if self.current >= self.length:
+                                       return False
+               return True
+
+       def nextService(self):
+               if not self.length:
+                       return
+               if self.current+1 < self.length:
+                       self.current += 1
+               else:
+                       self.current = 0
+
+       def prevService(self):
+               if not self.length:
+                       return
+               if self.current-1 > -1:
+                       self.current -= 1
+               else:
+                       self.current = self.length - 1
+
+       def currentService(self):
+               if not self.length or self.current >= self.length:
+                       return None
+               return self.services[self.current]
 
 class InfoBarEPG:
        """ EPG - Opens an EPG list when the showEPGList action fires """
 
 class InfoBarEPG:
        """ EPG - Opens an EPG list when the showEPGList action fires """
@@ -403,7 +452,7 @@ class InfoBarEPG:
                self.eventView = None
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
                self.eventView = None
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
-                               "showEventView": (self.openEventView, _("show EPG...")),
+                               "showEventInfo": (self.openEventView, _("show EPG...")),
                                "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
                                "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
                        })
                                "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
                                "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
                        })
@@ -440,7 +489,7 @@ class InfoBarEPG:
 
        def openBouquetEPG(self, bouquet, withCallback=True):
                services = self.getBouquetServices(bouquet)
 
        def openBouquetEPG(self, bouquet, withCallback=True):
                services = self.getBouquetServices(bouquet)
-               if len(services):
+               if services:
                        self.epg_bouquet = bouquet
                        if withCallback:
                                self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
                        self.epg_bouquet = bouquet
                        if withCallback:
                                self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
@@ -455,7 +504,7 @@ class InfoBarEPG:
                                self.bouquetSel.up()
                        bouquet = self.bouquetSel.getCurrent()
                        services = self.getBouquetServices(bouquet)
                                self.bouquetSel.up()
                        bouquet = self.bouquetSel.getCurrent()
                        services = self.getBouquetServices(bouquet)
-                       if len(services):
+                       if services:
                                self.epg_bouquet = bouquet
                                epg.setServices(services)
 
                                self.epg_bouquet = bouquet
                                epg.setServices(services)
 
@@ -485,20 +534,40 @@ class InfoBarEPG:
                elif cnt == 1:
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
                elif cnt == 1:
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
+       def changeServiceCB(self, direction, epg):
+               if self.serviceSel:
+                       if direction > 0:
+                               self.serviceSel.nextService()
+                       else:
+                               self.serviceSel.prevService()
+                       epg.setService(self.serviceSel.currentService())
+
+       def SingleServiceEPGClosed(self, ret=False):
+               self.serviceSel = None
+
        def openSingleServiceEPG(self):
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
        def openSingleServiceEPG(self):
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
-               self.session.open(EPGSelection, ref)
+               if ref:
+                       if self.servicelist.getMutableList() is not None: # bouquet in channellist
+                               current_path = self.servicelist.getRoot()
+                               services = self.getBouquetServices(current_path)
+                               self.serviceSel = SimpleServicelist(services)
+                               if self.serviceSel.selectService(ref):
+                                       self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
+                               else:
+                                       self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
+                       else:
+                               self.session.open(EPGSelection, ref)
 
        def showEventInfoPlugins(self):
 
        def showEventInfoPlugins(self):
-               list = []
-               for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO):
-                       list.append((p.name, boundFunction(self.runPlugin, p)))
-               if len(list):
+               list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
+
+               if list:
                        list.append((_("show single service EPG..."), self.openSingleServiceEPG))
                        list.append((_("show single service EPG..."), self.openSingleServiceEPG))
-                       self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list)
+                       self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
                else:
                        self.openSingleServiceEPG()
                else:
                        self.openSingleServiceEPG()
-                       
+
        def runPlugin(self, plugin):
                plugin(session = self.session, servicelist = self.servicelist)
                
        def runPlugin(self, plugin):
                plugin(session = self.session, servicelist = self.servicelist)
                
@@ -510,38 +579,40 @@ class InfoBarEPG:
                self.session.open(EPGSelection, refstr, None, eventid)
 
        def getNowNext(self):
                self.session.open(EPGSelection, refstr, None, eventid)
 
        def getNowNext(self):
-               self.epglist = [ ]
+               epglist = [ ]
                service = self.session.nav.getCurrentService()
                info = service and service.info()
                ptr = info and info.getEvent(0)
                if ptr:
                service = self.session.nav.getCurrentService()
                info = service and service.info()
                ptr = info and info.getEvent(0)
                if ptr:
-                       self.epglist.append(ptr)
+                       epglist.append(ptr)
                ptr = info and info.getEvent(1)
                if ptr:
                ptr = info and info.getEvent(1)
                if ptr:
-                       self.epglist.append(ptr)
+                       epglist.append(ptr)
+               self.epglist = epglist
 
        def __evEventInfoChanged(self):
                if self.is_now_next and len(self.dlg_stack) == 1:
                        self.getNowNext()
                        assert self.eventView
 
        def __evEventInfoChanged(self):
                if self.is_now_next and len(self.dlg_stack) == 1:
                        self.getNowNext()
                        assert self.eventView
-                       if len(self.epglist):
+                       if self.epglist:
                                self.eventView.setEvent(self.epglist[0])
 
        def openEventView(self):
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                self.getNowNext()
                                self.eventView.setEvent(self.epglist[0])
 
        def openEventView(self):
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                self.getNowNext()
-               if len(self.epglist) == 0:
+               epglist = self.epglist
+               if not epglist:
                        self.is_now_next = False
                        epg = eEPGCache.getInstance()
                        ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
                        if ptr:
                        self.is_now_next = False
                        epg = eEPGCache.getInstance()
                        ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
                        if ptr:
-                               self.epglist.append(ptr)
+                               epglist.append(ptr)
                                ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
                                if ptr:
                                ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
                                if ptr:
-                                       self.epglist.append(ptr)
+                                       epglist.append(ptr)
                else:
                        self.is_now_next = True
                else:
                        self.is_now_next = True
-               if len(self.epglist) > 0:
+               if epglist:
                        self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
                        self.dlg_stack.append(self.eventView)
                else:
                        self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
                        self.dlg_stack.append(self.eventView)
                else:
@@ -549,11 +620,12 @@ class InfoBarEPG:
                        self.openMultiServiceEPG(False)
 
        def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
                        self.openMultiServiceEPG(False)
 
        def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
-               if len(self.epglist) > 1:
-                       tmp = self.epglist[0]
-                       self.epglist[0]=self.epglist[1]
-                       self.epglist[1]=tmp
-                       setEvent(self.epglist[0])
+               epglist = self.epglist
+               if len(epglist) > 1:
+                       tmp = epglist[0]
+                       epglist[0]=epglist[1]
+                       epglist[1]=tmp
+                       setEvent(epglist[0])
 
 class InfoBarRdsDecoder:
        """provides RDS and Rass support/display"""
 
 class InfoBarRdsDecoder:
        """provides RDS and Rass support/display"""
@@ -619,13 +691,6 @@ class InfoBarSeek:
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })
-               self.eofState = 0
-               self.eofTimer = eTimer()
-               self.eofTimer.timeout.get().append(self.doEof)
-               self.eofInhibitTimer = eTimer()
-               self.eofInhibitTimer.timeout.get().append(self.inhibitEof)
-
-               self.minSpeedBackward = useSeekBackHack and 16 or 0
 
                class InfoBarSeekActionMap(HelpableActionMap):
                        def __init__(self, screen, *args, **kwargs):
 
                class InfoBarSeekActionMap(HelpableActionMap):
                        def __init__(self, screen, *args, **kwargs):
@@ -640,9 +705,9 @@ class InfoBarSeek:
                                        return 1
                                elif action[:8] == "seekdef:":
                                        key = int(action[8:])
                                        return 1
                                elif action[:8] == "seekdef:":
                                        key = int(action[8:])
-                                       time = [-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
+                                       time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
                                                -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
                                                -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
-                                               -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value][key-1]
+                                               -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
                                        self.screen.doSeekRelative(time * 90000)
                                        return 1                                        
                                else:
                                        self.screen.doSeekRelative(time * 90000)
                                        return 1                                        
                                else:
@@ -673,24 +738,19 @@ class InfoBarSeek:
                self.__seekableStatusChanged()
 
        def makeStateForward(self, n):
                self.__seekableStatusChanged()
 
        def makeStateForward(self, n):
-               minspeed = config.seek.stepwise_minspeed.value
-               repeat = int(config.seek.stepwise_repeat.value)
-               if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
-                       return (0, n * repeat, repeat, ">> %dx" % n)
-               else:
+#              minspeed = config.seek.stepwise_minspeed.value
+#              repeat = int(config.seek.stepwise_repeat.value)
+#              if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
+#                      return (0, n * repeat, repeat, ">> %dx" % n)
+#              else:
                        return (0, n, 0, ">> %dx" % n)
 
        def makeStateBackward(self, n):
                        return (0, n, 0, ">> %dx" % n)
 
        def makeStateBackward(self, n):
-               minspeed = config.seek.stepwise_minspeed.value
-               repeat = int(config.seek.stepwise_repeat.value)
-               if self.minSpeedBackward and n < self.minSpeedBackward:
-                       r = (self.minSpeedBackward - 1)/ n + 1
-                       if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
-                               r = max(r, repeat)
-                       return (0, -n * r, r, "<< %dx" % n)
-               elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
-                       return (0, -n * repeat, repeat, "<< %dx" % n)
-               else:
+#              minspeed = config.seek.stepwise_minspeed.value
+#              repeat = int(config.seek.stepwise_repeat.value)
+#              if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
+#                      return (0, -n * repeat, repeat, "<< %dx" % n)
+#              else:
                        return (0, -n, 0, "<< %dx" % n)
 
        def makeStateSlowMotion(self, n):
                        return (0, -n, 0, "<< %dx" % n)
 
        def makeStateSlowMotion(self, n):
@@ -712,7 +772,7 @@ class InfoBarSeek:
                return False
 
        def getLower(self, n, lst):
                return False
 
        def getLower(self, n, lst):
-               lst = lst+[]
+               lst = lst[:]
                lst.reverse()
                for x in lst:
                        if x < n:
                lst.reverse()
                for x in lst:
                        if x < n:
@@ -759,9 +819,6 @@ class InfoBarSeek:
        def __serviceStarted(self):
                self.seekstate = self.SEEK_STATE_PLAY
                self.__seekableStatusChanged()
        def __serviceStarted(self):
                self.seekstate = self.SEEK_STATE_PLAY
                self.__seekableStatusChanged()
-               if self.eofState != 0:
-                       self.eofTimer.stop()
-               self.eofState = 0
 
        def setSeekState(self, state):
                service = self.session.nav.getCurrentService()
 
        def setSeekState(self, state):
                service = self.session.nav.getCurrentService()
@@ -770,7 +827,7 @@ class InfoBarSeek:
                        return False
 
                if not self.isSeekable():
                        return False
 
                if not self.isSeekable():
-                       if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+                       if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
                                state = self.SEEK_STATE_PLAY
 
                pauseable = service.pause()
                                state = self.SEEK_STATE_PLAY
 
                pauseable = service.pause()
@@ -813,7 +870,7 @@ class InfoBarSeek:
                        if config.seek.on_pause.value == "play":
                                self.unPauseService()
                        elif config.seek.on_pause.value == "step":
                        if config.seek.on_pause.value == "play":
                                self.unPauseService()
                        elif config.seek.on_pause.value == "step":
-                               self.doSeekRelative(0)
+                               self.doSeekRelative(1)
                        elif config.seek.on_pause.value == "last":
                                self.setSeekState(self.lastseekstate)
                                self.lastseekstate = self.SEEK_STATE_PLAY
                        elif config.seek.on_pause.value == "last":
                                self.setSeekState(self.lastseekstate)
                                self.lastseekstate = self.SEEK_STATE_PLAY
@@ -832,16 +889,6 @@ class InfoBarSeek:
                seekable = self.getSeek()
                if seekable is None:
                        return
                seekable = self.getSeek()
                if seekable is None:
                        return
-               prevstate = self.seekstate
-               if self.eofState == 1:
-                       self.eofState = 2
-                       self.inhibitEof()
-               if self.seekstate == self.SEEK_STATE_EOF:
-                       if prevstate == self.SEEK_STATE_PAUSE:
-                               self.setSeekState(self.SEEK_STATE_PAUSE)
-                       else:
-                               self.setSeekState(self.SEEK_STATE_PLAY)
-               self.eofInhibitTimer.start(200, True)
                seekable.seekTo(pts)
 
        def doSeekRelative(self, pts):
                seekable.seekTo(pts)
 
        def doSeekRelative(self, pts):
@@ -849,15 +896,12 @@ class InfoBarSeek:
                if seekable is None:
                        return
                prevstate = self.seekstate
                if seekable is None:
                        return
                prevstate = self.seekstate
-               if self.eofState == 1:
-                       self.eofState = 2
-                       self.inhibitEof()
+
                if self.seekstate == self.SEEK_STATE_EOF:
                        if prevstate == self.SEEK_STATE_PAUSE:
                                self.setSeekState(self.SEEK_STATE_PAUSE)
                        else:
                                self.setSeekState(self.SEEK_STATE_PLAY)
                if self.seekstate == self.SEEK_STATE_EOF:
                        if prevstate == self.SEEK_STATE_PAUSE:
                                self.setSeekState(self.SEEK_STATE_PAUSE)
                        else:
                                self.setSeekState(self.SEEK_STATE_PLAY)
-               self.eofInhibitTimer.start(200, True)
                seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
                if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
                        self.showAfterSeek()
                seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
                if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
                        self.showAfterSeek()
@@ -892,30 +936,31 @@ class InfoBarSeek:
                        self.setSeekState(self.makeStateSlowMotion(speed))
 
        def seekBack(self):
                        self.setSeekState(self.makeStateSlowMotion(speed))
 
        def seekBack(self):
-               if self.seekstate == self.SEEK_STATE_PLAY:
+               seekstate = self.seekstate
+               if seekstate == self.SEEK_STATE_PLAY:
                        self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
                        self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
-               elif self.seekstate == self.SEEK_STATE_EOF:
+               elif seekstate == self.SEEK_STATE_EOF:
                        self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
                        self.doSeekRelative(-6)
                        self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
                        self.doSeekRelative(-6)
-               elif self.seekstate == self.SEEK_STATE_PAUSE:
-                       self.doSeekRelative(-3)
-               elif self.isStateForward(self.seekstate):
-                       speed = self.seekstate[1]
-                       if self.seekstate[2]:
-                               speed /= self.seekstate[2]
+               elif seekstate == self.SEEK_STATE_PAUSE:
+                       self.doSeekRelative(-1)
+               elif self.isStateForward(seekstate):
+                       speed = seekstate[1]
+                       if seekstate[2]:
+                               speed /= seekstate[2]
                        speed = self.getLower(speed, config.seek.speeds_forward.value)
                        if speed:
                                self.setSeekState(self.makeStateForward(speed))
                        else:
                                self.setSeekState(self.SEEK_STATE_PLAY)
                        speed = self.getLower(speed, config.seek.speeds_forward.value)
                        if speed:
                                self.setSeekState(self.makeStateForward(speed))
                        else:
                                self.setSeekState(self.SEEK_STATE_PLAY)
-               elif self.isStateBackward(self.seekstate):
-                       speed = -self.seekstate[1]
-                       if self.seekstate[2]:
-                               speed /= self.seekstate[2]
+               elif self.isStateBackward(seekstate):
+                       speed = -seekstate[1]
+                       if seekstate[2]:
+                               speed /= seekstate[2]
                        speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
                        self.setSeekState(self.makeStateBackward(speed))
                        speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
                        self.setSeekState(self.makeStateBackward(speed))
-               elif self.isStateSlowMotion(self.seekstate):
-                       speed = self.getHigher(self.seekstate[2], config.seek.speeds_slowmotion.value)
+               elif self.isStateSlowMotion(seekstate):
+                       speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
                        if speed:
                                self.setSeekState(self.makeStateSlowMotion(speed))
                        else:
                        if speed:
                                self.setSeekState(self.makeStateSlowMotion(speed))
                        else:
@@ -968,44 +1013,19 @@ class InfoBarSeek:
                return False
                
        def __evEOF(self):
                return False
                
        def __evEOF(self):
-               if self.eofState == 0 and self.seekstate != self.SEEK_STATE_EOF:
-                       self.eofState = 1
-                       time = self.calcRemainingTime()
-                       if not time:
-                               time = 3000   # Failed to calc, use default
-                       elif time == 0:
-                               time = 300    # Passed end, shortest wait
-                       elif time > 15000:
-                               self.eofState = -2  # Too long, block eof
-                               time = 15000
-                       else:
-                               time += 1000  # Add margin
-                       self.eofTimer.start(time, True)
-
-       def inhibitEof(self):
-               if self.eofState >= 1:
-                       self.eofState = -self.eofState
-                       self.eofTimer.stop()
-                       self.doEof()
-
-       def doEof(self):
                if self.seekstate == self.SEEK_STATE_EOF:
                        return
                if self.seekstate == self.SEEK_STATE_EOF:
                        return
-               if self.eofState == -2 or self.isStateBackward(self.seekstate):
-                       self.eofState = 0
-                       return
 
 
-               # if we are seeking, we try to end up ~1s before the end, and pause there.
-               eofstate = self.eofState
+               # if we are seeking forward, we try to end up ~1s before the end, and pause there.
                seekstate = self.seekstate
                seekstate = self.seekstate
-               self.eofState = 0
-               if not self.seekstate == self.SEEK_STATE_PAUSE:
+               if self.seekstate != self.SEEK_STATE_PAUSE:
                        self.setSeekState(self.SEEK_STATE_EOF)
                        self.setSeekState(self.SEEK_STATE_EOF)
-               if eofstate == -1 or not seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+
+               if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
                        seekable = self.getSeek()
                        if seekable is not None:
                                seekable.seekTo(-1)
                        seekable = self.getSeek()
                        if seekable is not None:
                                seekable.seekTo(-1)
-               if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY:
+               if seekstate == self.SEEK_STATE_PLAY: # regular EOF
                        self.doEofInternal(True)
                else:
                        self.doEofInternal(False)
                        self.doEofInternal(True)
                else:
                        self.doEofInternal(False)
@@ -1020,11 +1040,12 @@ class InfoBarSeek:
 from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:
 from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:
-       def __init__(self, screen=PVRState):
+       def __init__(self, screen=PVRState, force_show = False):
                self.onPlayStateChanged.append(self.__playStateChanged)
                self.pvrStateDialog = self.session.instantiateDialog(screen)
                self.onShow.append(self._mayShow)
                self.onHide.append(self.pvrStateDialog.hide)
                self.onPlayStateChanged.append(self.__playStateChanged)
                self.pvrStateDialog = self.session.instantiateDialog(screen)
                self.onShow.append(self._mayShow)
                self.onHide.append(self.pvrStateDialog.hide)
+               self.force_show = force_show
 
        def _mayShow(self):
                if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
 
        def _mayShow(self):
                if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
@@ -1033,11 +1054,17 @@ class InfoBarPVRState:
        def __playStateChanged(self, state):
                playstateString = state[3]
                self.pvrStateDialog["state"].setText(playstateString)
        def __playStateChanged(self, state):
                playstateString = state[3]
                self.pvrStateDialog["state"].setText(playstateString)
-               self._mayShow()
+               
+               # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
+               if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
+                       self.pvrStateDialog.hide()
+               else:
+                       self._mayShow()
+                       
 
 class InfoBarTimeshiftState(InfoBarPVRState):
        def __init__(self):
 
 class InfoBarTimeshiftState(InfoBarPVRState):
        def __init__(self):
-               InfoBarPVRState.__init__(self, screen=TimeshiftState)
+               InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
 
        def _mayShow(self):
                if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
 
        def _mayShow(self):
                if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
@@ -1224,7 +1251,7 @@ class InfoBarExtensions:
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                                "extensions": (self.showExtensionSelection, _("view extensions...")),
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                                "extensions": (self.showExtensionSelection, _("view extensions...")),
-                       })
+                       }, 1) # lower priority
 
        def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
                self.list.append((type, extension, key))
 
        def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
                self.list.append((type, extension, key))
@@ -1272,10 +1299,10 @@ class InfoBarExtensions:
                                        extensionsList.remove(extension)
                                else:
                                        extensionsList.remove(extension)
                                        extensionsList.remove(extension)
                                else:
                                        extensionsList.remove(extension)
-               for x in extensionsList:
-                       list.append((x[0](), x))
+               list.extend([(x[0](), x) for x in extensionsList])
+
                keys += [""] * len(extensionsList)
                keys += [""] * len(extensionsList)
-               self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
+               self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
 
        def extensionCallback(self, answer):
                if answer is not None:
 
        def extensionCallback(self, answer):
                if answer is not None:
@@ -1293,13 +1320,15 @@ class InfoBarPlugins:
                return name
 
        def getPluginList(self):
                return name
 
        def getPluginList(self):
-               list = []
-               for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
-                       list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
+               list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
+               list.sort(key = lambda e: e[2]) # sort by name
                return list
 
        def runPlugin(self, plugin):
                return list
 
        def runPlugin(self, plugin):
-               plugin(session = self.session, servicelist = self.servicelist)
+               if isinstance(self, InfoBarChannelSelection):
+                       plugin(session = self.session, servicelist = self.servicelist)
+               else:
+                       plugin(session = self.session)
 
 from Components.Task import job_manager
 class InfoBarJobman:
 
 from Components.Task import job_manager
 class InfoBarJobman:
@@ -1307,10 +1336,7 @@ class InfoBarJobman:
                self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
 
        def getJobList(self):
                self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
 
        def getJobList(self):
-               list = []
-               for job in job_manager.getPendingJobs():
-                       list.append(((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None))
-               return list
+               return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
 
        def getJobName(self, job):
                return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
 
        def getJobName(self, job):
                return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
@@ -1321,7 +1347,6 @@ class InfoBarJobman:
                self.session.openWithCallback(self.JobViewCB, JobView, job)
        
        def JobViewCB(self, in_background):
                self.session.openWithCallback(self.JobViewCB, JobView, job)
        
        def JobViewCB(self, in_background):
-               from Screens.TaskView import JobView
                job_manager.in_background = in_background
 
 # depends on InfoBarExtensions
                job_manager.in_background = in_background
 
 # depends on InfoBarExtensions
@@ -1338,11 +1363,18 @@ class InfoBarSleepTimer:
 # depends on InfoBarExtensions
 class InfoBarPiP:
        def __init__(self):
 # depends on InfoBarExtensions
 class InfoBarPiP:
        def __init__(self):
-               self.session.pipshown = False
+               try:
+                       self.session.pipshown
+               except:
+                       self.session.pipshown = False
                if SystemInfo.get("NumVideoDecoders", 1) > 1:
                if SystemInfo.get("NumVideoDecoders", 1) > 1:
-                       self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
-                       self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
-                       self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
+                       if (self.allowPiP):
+                               self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
+                               self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
+                               self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
+                       else:
+                               self.addExtension((self.getShowHideName, self.showPiP, self.pipShown), "blue")
+                               self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
 
        def pipShown(self):
                return self.session.pipshown
 
        def pipShown(self):
                return self.session.pipshown
@@ -1437,8 +1469,8 @@ class InfoBarInstantRecord:
                except:
                        pass
 
                except:
                        pass
 
-               begin = time()
-               end = time() + 3600 * 24 * 365 * 1 # 1 year
+               begin = int(time())
+               end = begin + 3600      # dummy
                name = "instant record"
                description = ""
                eventid = None
                name = "instant record"
                description = ""
                eventid = None
@@ -1459,23 +1491,32 @@ class InfoBarInstantRecord:
 
                recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
                recording.dontSave = True
 
                recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
                recording.dontSave = True
-               recording.autoincrease = True
-
-               simulTimerList = self.session.nav.RecordTimer.record(recording)
-               if simulTimerList is not None:
-                       print "timer conflict detected!"
-                       if (len(simulTimerList) > 1):
-                               print "tsc_list > 1"
-                               recording.end = simulTimerList[1].begin - 30
+               
+               if event is None or limitEvent == False:
+                       recording.autoincrease = True
+                       if recording.setAutoincreaseEnd():
                                self.session.nav.RecordTimer.record(recording)
                                self.session.nav.RecordTimer.record(recording)
-                               print "new endtime applied"
-                       else:
-                               print "conflict with only one timer? ! ?"
-               self.recording.append(recording)
+                               self.recording.append(recording)
+               else:
+                               simulTimerList = self.session.nav.RecordTimer.record(recording)
+                               if simulTimerList is not None:  # conflict with other recording
+                                       name = simulTimerList[1].name
+                                       name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
+                                       print "[TIMER] conflicts with", name_date
+                                       recording.autoincrease = True   # start with max available length, then increment
+                                       if recording.setAutoincreaseEnd():
+                                               self.session.nav.RecordTimer.record(recording)
+                                               self.recording.append(recording)
+                                               self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
+                                       else:
+                                               self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
+                                       recording.autoincrease = False
+                               else:
+                                       self.recording.append(recording)
 
        def isInstantRecordRunning(self):
                print "self.recording:", self.recording
 
        def isInstantRecordRunning(self):
                print "self.recording:", self.recording
-               if len(self.recording) > 0:
+               if self.recording:
                        for x in self.recording:
                                if x.isRunning():
                                        return True
                        for x in self.recording:
                                if x.isRunning():
                                        return True
@@ -1518,7 +1559,7 @@ class InfoBarInstantRecord:
                print "after:\n", self.recording
 
        def setEndtime(self, entry):
                print "after:\n", self.recording
 
        def setEndtime(self, entry):
-               if entry is not None:
+               if entry is not None and entry >= 0:
                        self.selectedEntry = entry
                        self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
                        dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
                        self.selectedEntry = entry
                        self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
                        dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
@@ -1535,21 +1576,22 @@ class InfoBarInstantRecord:
                                self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
 
        def changeDuration(self, entry):
                                self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
 
        def changeDuration(self, entry):
-               if entry is not None:
+               if entry is not None and entry >= 0:
                        self.selectedEntry = entry
                        self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
 
        def inputCallback(self, value):
                if value is not None:
                        print "stopping recording after", int(value), "minutes."
                        self.selectedEntry = entry
                        self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
 
        def inputCallback(self, value):
                if value is not None:
                        print "stopping recording after", int(value), "minutes."
+                       entry = self.recording[self.selectedEntry]
                        if int(value) != 0:
                        if int(value) != 0:
-                               self.recording[self.selectedEntry].autoincrease = False
-                       self.recording[self.selectedEntry].end = time() + 60 * int(value)
-                       self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
+                               entry.autoincrease = False
+                       entry.end = int(time()) + 60 * int(value)
+                       self.session.nav.RecordTimer.timeChanged(entry)
 
        def instantRecord(self):
                dir = config.movielist.last_videodir.value
 
        def instantRecord(self):
                dir = config.movielist.last_videodir.value
-               if not pathExists(dir):
+               if not fileExists(dir, 'w'):
                        dir = resolveFilename(SCOPE_HDD)
                try:
                        stat = os_stat(dir)
                        dir = resolveFilename(SCOPE_HDD)
                try:
                        stat = os_stat(dir)
@@ -1561,22 +1603,22 @@ class InfoBarInstantRecord:
                if self.isInstantRecordRunning():
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                title=_("A recording is currently running.\nWhat do you want to do?"), \
                if self.isInstantRecordRunning():
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                title=_("A recording is currently running.\nWhat do you want to do?"), \
-                               list=[(_("stop recording"), "stop"), \
-                               (_("change recording (duration)"), "changeduration"), \
-                               (_("change recording (endtime)"), "changeendtime"), \
-                               (_("add recording (indefinitely)"), "indefinitely"), \
+                               list=((_("stop recording"), "stop"), \
                                (_("add recording (stop after current event)"), "event"), \
                                (_("add recording (stop after current event)"), "event"), \
+                               (_("add recording (indefinitely)"), "indefinitely"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \
-                               (_("do nothing"), "no")])
+                               (_("change recording (duration)"), "changeduration"), \
+                               (_("change recording (endtime)"), "changeendtime"), \
+                               (_("do nothing"), "no")))
                else:
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                title=_("Start recording?"), \
                else:
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                title=_("Start recording?"), \
-                               list=[(_("add recording (indefinitely)"), "indefinitely"), \
-                               (_("add recording (stop after current event)"), "event"), \
+                               list=((_("add recording (stop after current event)"), "event"), \
+                               (_("add recording (indefinitely)"), "indefinitely"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \
-                               (_("don't record"), "no")])
+                               (_("don't record"), "no")))
 
 from Tools.ISO639 import LanguageCodes
 
 
 from Tools.ISO639 import LanguageCodes
 
@@ -1595,20 +1637,30 @@ class InfoBarAudioSelection:
                if n > 0:
                        self.audioChannel = service.audioChannel()
 
                if n > 0:
                        self.audioChannel = service.audioChannel()
 
-                       for x in range(n):
-                               i = audio.getTrackInfo(x)
-                               language = i.getLanguage()
+                       idx = 0
+                       while idx < n:
+                               cnt = 0
+                               i = audio.getTrackInfo(idx)
+                               languages = i.getLanguage().split('/')
                                description = i.getDescription()
                                description = i.getDescription()
+                               language = ""
 
 
-                               if LanguageCodes.has_key(language):
-                                       language = LanguageCodes[language][0]
+                               for lang in languages:
+                                       if cnt:
+                                               language += ' / '
+                                       if LanguageCodes.has_key(lang):
+                                               language += LanguageCodes[lang][0]
+                                       else:
+                                               language += lang
+                                       cnt += 1
 
                                if len(description):
                                        description += " (" + language + ")"
                                else:
                                        description = language
 
 
                                if len(description):
                                        description += " (" + language + ")"
                                else:
                                        description = language
 
-                               tlist.append((description, x))
+                               tlist.append((description, idx))
+                               idx += 1
 
                        tlist.sort(key=lambda x: x[0])
 
 
                        tlist.sort(key=lambda x: x[0])
 
@@ -1623,16 +1675,16 @@ class InfoBarAudioSelection:
                                        break
 
                        if SystemInfo["CanDownmixAC3"]:
                                        break
 
                        if SystemInfo["CanDownmixAC3"]:
-                               tlist = [(_("AC3 downmix") + " - " +[_("Off"), _("On")][config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
-                                       ([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"),
+                               tlist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
+                                       ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"),
                                        ("--", "")] + tlist
                                keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
                                selection += 3
                        else:
                                        ("--", "")] + tlist
                                keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
                                selection += 3
                        else:
-                               tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+                               tlist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
                                keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
                                selection += 2
                                keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
                                selection += 2
-                       self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
+                       self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
                else:
                        del self.audioTracks
 
                else:
                        del self.audioTracks
 
@@ -1641,7 +1693,7 @@ class InfoBarAudioSelection:
                list = choicelist.list
                t = list[0][1]
                list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
                list = choicelist.list
                t = list[0][1]
                list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
-                       _("AC3 downmix") + " - " +[_("On"), _("Off")][config.av.downmix_ac3.value and 1 or 0])
+                       _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
                choicelist.setList(list)
                if config.av.downmix_ac3.value:
                        config.av.downmix_ac3.value = False
                choicelist.setList(list)
                if config.av.downmix_ac3.value:
                        config.av.downmix_ac3.value = False
@@ -1655,8 +1707,8 @@ class InfoBarAudioSelection:
                                if audio[1] == "mode":
                                        keys = ["red", "green", "yellow"]
                                        selection = self.audioChannel.getCurrentChannel()
                                if audio[1] == "mode":
                                        keys = ["red", "green", "yellow"]
                                        selection = self.audioChannel.getCurrentChannel()
-                                       tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
-                                       self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
+                                       tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
+                                       self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
                        else:
                                del self.audioChannel
                                if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
                        else:
                                del self.audioChannel
                                if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
@@ -1710,9 +1762,12 @@ class InfoBarSubserviceSelection:
                if n and n > 0:
                        selection = -1
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                if n and n > 0:
                        selection = -1
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
-                       for x in range(n):
-                               if subservices.getSubservice(x).toString() == ref.toString():
-                                       selection = x
+                       idx = 0
+                       while idx < n:
+                               if subservices.getSubservice(idx).toString() == ref.toString():
+                                       selection = idx
+                                       break
+                               idx += 1
                        if selection != -1:
                                selection += direction
                                if selection >= n:
                        if selection != -1:
                                selection += direction
                                if selection >= n:
@@ -1734,11 +1789,13 @@ class InfoBarSubserviceSelection:
                if n and n > 0:
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                        tlist = []
                if n and n > 0:
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                        tlist = []
-                       for x in range(n):
-                               i = subservices.getSubservice(x)
+                       idx = 0
+                       while idx < n:
+                               i = subservices.getSubservice(idx)
                                if i.toString() == ref.toString():
                                if i.toString() == ref.toString():
-                                       selection = x
+                                       selection = idx
                                tlist.append((i.getName(), i))
                                tlist.append((i.getName(), i))
+                               idx += 1
 
                        if self.bouquets and len(self.bouquets):
                                keys = ["red", "blue", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
 
                        if self.bouquets and len(self.bouquets):
                                keys = ["red", "blue", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
@@ -1752,7 +1809,7 @@ class InfoBarSubserviceSelection:
                                keys = ["red", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
                                selection += 2
 
                                keys = ["red", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
                                selection += 2
 
-                       self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
+                       self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
 
        def subserviceSelected(self, service):
                del self.bouquets
 
        def subserviceSelected(self, service):
                del self.bouquets
@@ -1815,10 +1872,11 @@ class InfoBarNotifications:
                        self.checkNotifications()
 
        def checkNotifications(self):
                        self.checkNotifications()
 
        def checkNotifications(self):
-               if len(Notifications.notifications):
-                       n = Notifications.notifications[0]
+               notifications = Notifications.notifications
+               if notifications:
+                       n = notifications[0]
 
 
-                       Notifications.notifications = Notifications.notifications[1:]
+                       del notifications[0]
                        cb = n[0]
 
                        if n[3].has_key("onSessionOpenCallback"):
                        cb = n[0]
 
                        if n[3].has_key("onSessionOpenCallback"):
@@ -1971,7 +2029,7 @@ class InfoBarCueSheetSupport:
                        if bestdiff >= 0:
                                nearest = [0, False]
                for cp in self.cut_list:
                        if bestdiff >= 0:
                                nearest = [0, False]
                for cp in self.cut_list:
-                       if beforecut and cp[1] in [self.CUT_TYPE_IN, self.CUT_TYPE_OUT]:
+                       if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
                                beforecut = False
                                if cp[1] == self.CUT_TYPE_IN:  # Start is here, disregard previous marks
                                        diff = cmp(cp[0] - pts)
                                beforecut = False
                                if cp[1] == self.CUT_TYPE_IN:  # Start is here, disregard previous marks
                                        diff = cmp(cp[0] - pts)
@@ -1980,7 +2038,7 @@ class InfoBarCueSheetSupport:
                                                bestdiff = diff
                                        else:
                                                nearest = None
                                                bestdiff = diff
                                        else:
                                                nearest = None
-                       if cp[1] in [self.CUT_TYPE_MARK, self.CUT_TYPE_LAST]:
+                       if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
                                diff = cmp(cp[0] - pts)
                                if diff >= 0 and (nearest is None or bestdiff > diff):
                                        nearest = cp
                                diff = cmp(cp[0] - pts)
                                if diff >= 0 and (nearest is None or bestdiff > diff):
                                        nearest = cp
@@ -2066,9 +2124,6 @@ class InfoBarSummary(Screen):
 #                      <convert type="ServiceName">Reference</convert>
 #              </widget>
 
 #                      <convert type="ServiceName">Reference</convert>
 #              </widget>
 
-       def __init__(self, session, parent):
-               Screen.__init__(self, session, parent = parent)
-
 class InfoBarSummarySupport:
        def __init__(self):
                pass
 class InfoBarSummarySupport:
        def __init__(self):
                pass
@@ -2094,9 +2149,6 @@ class InfoBarMoviePlayerSummary(Screen):
                </widget>
        </screen>"""
 
                </widget>
        </screen>"""
 
-       def __init__(self, session, parent):
-               Screen.__init__(self, session)
-
 class InfoBarMoviePlayerSummarySupport:
        def __init__(self):
                pass
 class InfoBarMoviePlayerSummarySupport:
        def __init__(self):
                pass
@@ -2137,19 +2189,19 @@ class InfoBarSubtitleSupport(object):
                self.__selected_subtitle = None
 
        def __serviceStopped(self):
                self.__selected_subtitle = None
 
        def __serviceStopped(self):
-               self.subtitle_window.hide()
-               self.__subtitles_enabled = False
                self.cached_subtitle_checked = False
                self.cached_subtitle_checked = False
+               if self.__subtitles_enabled:
+                       self.subtitle_window.hide()
+                       self.__subtitles_enabled = False
+                       self.__selected_subtitle = None
 
        def __updatedInfo(self):
                if not self.cached_subtitle_checked:
 
        def __updatedInfo(self):
                if not self.cached_subtitle_checked:
-                       subtitle = self.getCurrentServiceSubtitle()
                        self.cached_subtitle_checked = True
                        self.cached_subtitle_checked = True
-                       self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
+                       subtitle = self.getCurrentServiceSubtitle()
+                       self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
                        if self.__selected_subtitle:
                        if self.__selected_subtitle:
-                               subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
-                               self.subtitle_window.show()
-                               self.__subtitles_enabled = True
+                               self.setSubtitlesEnable(True)
 
        def getCurrentServiceSubtitle(self):
                service = self.session.nav.getCurrentService()
 
        def getCurrentServiceSubtitle(self):
                service = self.session.nav.getCurrentService()
@@ -2157,14 +2209,16 @@ class InfoBarSubtitleSupport(object):
 
        def setSubtitlesEnable(self, enable=True):
                subtitle = self.getCurrentServiceSubtitle()
 
        def setSubtitlesEnable(self, enable=True):
                subtitle = self.getCurrentServiceSubtitle()
-               if enable and self.__selected_subtitle is not None:
-                       if subtitle and not self.__subtitles_enabled:
-                               subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
-                               self.subtitle_window.show()
-                               self.__subtitles_enabled = True
+               if enable:
+                       if self.__selected_subtitle:
+                               if subtitle and not self.__subtitles_enabled:
+                                       subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
+                                       self.subtitle_window.show()
+                                       self.__subtitles_enabled = True
                else:
                        if subtitle:
                                subtitle.disableSubtitles(self.subtitle_window.instance)
                else:
                        if subtitle:
                                subtitle.disableSubtitles(self.subtitle_window.instance)
+                       self.__selected_subtitle = False
                        self.__subtitles_enabled = False
                        self.subtitle_window.hide()
 
                        self.__subtitles_enabled = False
                        self.subtitle_window.hide()
 
@@ -2197,7 +2251,7 @@ class InfoBarServiceErrorPopupSupport:
                else:
                        self.last_error = error
 
                else:
                        self.last_error = error
 
-               errors = {
+               error = {
                        eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
                        eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
                        eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
                        eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
                        eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
                        eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
@@ -2208,9 +2262,7 @@ class InfoBarServiceErrorPopupSupport:
                        eDVBServicePMTHandler.eventSOF: None,
                        eDVBServicePMTHandler.eventEOF: None,
                        eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
                        eDVBServicePMTHandler.eventSOF: None,
                        eDVBServicePMTHandler.eventEOF: None,
                        eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
-               }
-
-               error = errors.get(error) #this returns None when the key not exist in the dict
+               }.get(error) #this returns None when the key not exist in the dict
 
                if error is not None:
                        Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
 
                if error is not None:
                        Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources