from Components.ProgressBar import *
from Components.config import configfile, configsequencearg
from Components.config import config, configElement, ConfigSubsection, configSequence
-from ChannelSelection import ChannelSelection
+from ChannelSelection import ChannelSelection, BouquetSelector
from Components.Pixmap import Pixmap, PixmapConditional
from Components.BlinkingPixmap import BlinkingPixmapConditional
from Screens.Dish import Dish
from Screens.Standby import Standby
from Screens.EventView import EventView
+from Screens.MinuteInput import MinuteInput
from Components.Harddisk import harddiskmanager
from Tools import Notifications
+from Tools.Directories import *
#from enigma import eTimer, eDVBVolumecontrol, quitMainloop
from enigma import *
def __init__(self):
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
- "showEPGList": (self.showEPGList, _("show EPG...")),
+ "showEPGList": (self.openSingleServiceEPG, _("show EPG...")),
})
def showEPGList(self):
+ bouquets = self.servicelist.getBouquetList()
+ if bouquets is None:
+ cnt = 0
+ else:
+ cnt = len(bouquets)
+ if cnt > 1: # show bouquet list
+ self.session.open(BouquetSelector, bouquets, self.openBouquetEPG)
+ elif cnt == 1: # add to only one existing bouquet
+ self.openBouquetEPG(bouquets[0][1])
+ else: #no bouquets so we open single epg
+ self.openSingleEPGSelector(self.session.nav.getCurrentlyPlayingServiceReference())
+
+ def bouquetEPGCallback(self, info):
+ if info:
+ self.openSingleServiceEPG()
+
+ def singleEPGCallback(self, info):
+ if info:
+ self.showEPGList()
+
+ def openSingleServiceEPG(self):
ref=self.session.nav.getCurrentlyPlayingServiceReference()
+ ptr=eEPGCache.getInstance()
+ if ptr.startTimeQuery(ref) != -1:
+ self.session.openWithCallback(self.singleEPGCallback, EPGSelection, ref)
+ else: # try to show now/next
+ print 'no epg for service', ref.toString()
+ try:
+ self.epglist = [ ]
+ service = self.session.nav.getCurrentService()
+ info = service.info()
+ ptr=info.getEvent(0)
+ if ptr:
+ self.epglist.append(ptr)
+ ptr=info.getEvent(1)
+ if ptr:
+ self.epglist.append(ptr)
+ if len(self.epglist) > 0:
+ self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
+ except:
+ pass
+
+ def openBouquetEPG(self, bouquet):
+ ptr=eEPGCache.getInstance()
+ services = [ ]
+ servicelist = eServiceCenter.getInstance().list(bouquet)
+ if not servicelist is None:
+ while True:
+ service = servicelist.getNext()
+ if not service.valid(): #check if end of list
+ break
+ if service.flags: #ignore non playable services
+ continue
+ services.append(ServiceReference(service))
+ if len(services):
+ self.session.openWithCallback(self.bouquetEPGCallback, EPGSelection, services)
+
+ def openSingleEPGSelector(self, ref):
ptr=eEPGCache.getInstance()
if ptr.startTimeQuery(ref) != -1:
self.session.open(EPGSelection, ref)
except:
pass
- def eventViewCallback(self, setEvent, 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]
"unPauseService": (self.unPauseService, "continue"),
"seekFwd": (self.seekFwd, "skip forward"),
+ "seekFwdUp": (self.seekFwdUp, "skip forward"),
"seekBack": (self.seekBack, "skip backward"),
-
+ "seekBackUp": (self.seekBackUp, "skip backward"),
+
"up": (self.showMovies, "movie list"),
"down": (self.showMovies, "movie list")
})
self.seekTimer.timeout.get().append(self.seekTimerFired)
self.skipinterval = 500 # 500ms skip interval
self.onClose.append(self.delSeekTimer)
+
+ self.fwdtimer = False
+ self.fwdKeyTimer = eTimer()
+ self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
+
+ self.rwdtimer = False
+ self.rwdKeyTimer = eTimer()
+ self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
def up(self):
pass
seekable.seekTo(90 * seektime)
def seekFwd(self):
- lookup = {
- self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
- self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
- self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
- self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
- self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
- self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
- self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
- self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
- self.SEEK_STATE_BACK_4X: self.SEEK_STATE_PLAY,
- self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X,
- self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
- self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
- self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
- self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
- self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
- }
- self.setSeekState(lookup[self.seekstate]);
-
+ print "start fwd timer"
+ self.fwdtimer = True
+ self.fwdKeyTimer.start(500)
+
def seekBack(self):
- lookup = {
- self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X,
- self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
- self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
- self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
- self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
- self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
- self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
- self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
- self.SEEK_STATE_BACK_4X: self.SEEK_STATE_BACK_32X,
- self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
- self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
- self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
- self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
- self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
- self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
- }
- self.setSeekState(lookup[self.seekstate]);
+ print "start rewind timer"
+ self.rwdtimer = True
+ self.rwdKeyTimer.start(500)
+
+ def seekFwdUp(self):
+ if self.fwdtimer:
+ self.fwdKeyTimer.stop()
+ self.fwdtimer = False
+ lookup = {
+ self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
+ self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
+ self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
+ self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
+ self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
+ self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
+ self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
+ self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
+ self.SEEK_STATE_BACK_4X: self.SEEK_STATE_PLAY,
+ self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X,
+ self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
+ self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
+ self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
+ self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
+ self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
+ }
+ self.setSeekState(lookup[self.seekstate]);
+
+ def seekBackUp(self):
+ if self.rwdtimer:
+ self.rwdKeyTimer.stop()
+ self.rwdtimer = False
+
+ lookup = {
+ self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X,
+ self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
+ self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
+ self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
+ self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
+ self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
+ self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
+ self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
+ self.SEEK_STATE_BACK_4X: self.SEEK_STATE_BACK_32X,
+ self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
+ self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
+ self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
+ self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
+ self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
+ self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
+ }
+ self.setSeekState(lookup[self.seekstate]);
+
+ def fwdTimerFire(self):
+ print "Display seek fwd"
+ self.fwdKeyTimer.stop()
+ self.fwdtimer = False
+ self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
+
+ def fwdSeekTo(self, minutes):
+ print "Seek", minutes, "minutes forward"
+ if minutes != 0:
+ service = self.session.nav.getCurrentService()
+ if service is None:
+ return
+ seekable = service.seek()
+ if seekable is None:
+ return
+ seekable.seekRelative(1, minutes * 60 * 90000)
+
+ def rwdTimerFire(self):
+ self.rwdKeyTimer.stop()
+ self.rwdtimer = False
+ self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
+
+ def rwdSeekTo(self, minutes):
+ self.fwdSeekTo(0 - minutes)
from RecordTimer import parseEvent
def instantRecord(self):
try:
- stat = os.stat("/hdd/movies")
+ stat = os.stat(resolveFilename(SCOPE_HDD))
except:
- self.session.open(MessageBox, "No HDD found!")
+ self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
return
if self.isInstantRecordRunning():
git.cweiske.de / enigma2.git / blobdiff