code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Screens/InfoBarGenerics.py

   1 from Screen import Screen
   2 from Components.ActionMap import ActionMap, HelpableActionMap
   3 from Components.ActionMap import NumberActionMap
   4 from Components.Label import Label
   5 from Components.config import configfile, configsequencearg
   6 from Components.config import config, configElement, ConfigSubsection, configSequence
   7 from ChannelSelection import ChannelSelection
   8
   9 from Components.ServiceName import ServiceName
  10 from Components.EventInfo import EventInfo
  11
  12 from ServiceReference import ServiceReference
  13 from EpgSelection import EPGSelection
  14
  15 from Screens.MessageBox import MessageBox
  16 from Screens.Volume import Volume
  17 from Screens.Mute import Mute
  18 from Screens.Standby import Standby
  19 from Screens.EventView import EventView
  20
  21 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
  22 from enigma import *
  23
  24 import time
  25 import os
  26
  27 # hack alert!
  28 from Menu import MainMenu, mdom
  29
  30 class InfoBarVolumeControl:
  31         """Volume control, handles volUp, volDown, volMute actions and display
  32         a corresponding dialog"""
  33         def __init__(self):
  34                 config.audio = ConfigSubsection()
  35                 config.audio.volume = configElement("config.audio.volume", configSequence, [5], configsequencearg.get("INTEGER", (0, 100)))
  36
  37                 self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
  38                         {
  39                                 "volumeUp": self.volUp,
  40                                 "volumeDown": self.volDown,
  41                                 "volumeMute": self.volMute,
  42                         })
  43
  44                 self.volumeDialog = self.session.instantiateDialog(Volume)
  45                 self.muteDialog = self.session.instantiateDialog(Mute)
  46
  47                 self.hideVolTimer = eTimer()
  48                 self.hideVolTimer.timeout.get().append(self.volHide)
  49
  50                 vol = config.audio.volume.value[0]
  51                 self.volumeDialog.setValue(vol)
  52                 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
  53
  54         def volSave(self):
  55                 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
  56                 config.audio.volume.save()
  57
  58         def     volUp(self):
  59                 eDVBVolumecontrol.getInstance().volumeUp()
  60                 self.volumeDialog.instance.show()
  61                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
  62                 self.volSave()
  63                 self.hideVolTimer.start(3000)
  64
  65         def     volDown(self):
  66                 eDVBVolumecontrol.getInstance().volumeDown()
  67                 self.volumeDialog.instance.show()
  68                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
  69                 self.volSave()
  70                 self.hideVolTimer.start(3000)
  71
  72         def volHide(self):
  73                 self.volumeDialog.instance.hide()
  74
  75         def     volMute(self):
  76                 eDVBVolumecontrol.getInstance().volumeToggleMute()
  77                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
  78
  79                 if (eDVBVolumecontrol.getInstance().isMuted()):
  80                         self.muteDialog.instance.show()
  81                 else:
  82                         self.muteDialog.instance.hide()
  83
  84 class InfoBarShowHide:
  85         """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
  86         fancy animations. """
  87         STATE_HIDDEN = 0
  88         STATE_HIDING = 1
  89         STATE_SHOWING = 2
  90         STATE_SHOWN = 3
  91
  92         def __init__(self):
  93                 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
  94                         {
  95                                 "toggleShow": self.toggleShow,
  96                                 "hide": self.hide,
  97                         })
  98
  99                 self.state = self.STATE_SHOWN
 100
 101                 self.onClose.append(self.delHideTimer)
 102
 103                 self.hideTimer = eTimer()
 104                 self.hideTimer.timeout.get().append(self.doTimerHide)
 105                 self.hideTimer.start(1000)
 106
 107         def delHideTimer(self):
 108                 del self.hideTimer
 109
 110         def hide(self):
 111                 self.instance.hide()
 112
 113         def doTimerHide(self):
 114                 if self.state == self.STATE_SHOWN:
 115                         self.instance.hide()
 116                         self.state = self.STATE_HIDDEN
 117
 118         def toggleShow(self):
 119                 if self.state == self.STATE_SHOWN:
 120                         self.instance.hide()
 121                         #pls check animation support, sorry
 122 #                       self.startHide()
 123                         self.state = self.STATE_HIDDEN
 124                 else:
 125                         self.instance.show()
 126 #                       self.startShow()
 127                         self.state = self.STATE_SHOWN
 128                         #TODO: make it customizable
 129                         self.hideTimer.start(5000)
 130
 131         def startShow(self):
 132                 self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
 133                 self.state = self.STATE_SHOWN
 134
 135         def startHide(self):
 136                 self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
 137                 self.state = self.STATE_HIDDEN
 138
 139 class NumberZap(Screen):
 140         def quit(self):
 141                 self.Timer.stop()
 142                 self.close(0)
 143
 144         def keyOK(self):
 145                 self.Timer.stop()
 146                 self.close(int(self["number"].getText()))
 147
 148         def keyNumberGlobal(self, number):
 149                 self.Timer.start(3000)          #reset timer
 150                 self.field = self.field + str(number)
 151                 self["number"].setText(self.field)
 152                 if len(self.field) >= 4:
 153                         self.keyOK()
 154
 155         def __init__(self, session, number):
 156                 Screen.__init__(self, session)
 157                 self.field = str(number)
 158
 159                 self["number"] = Label(self.field)
 160
 161                 self["actions"] = NumberActionMap( [ "SetupActions" ],
 162                         {
 163                                 "cancel": self.quit,
 164                                 "ok": self.keyOK,
 165                                 "1": self.keyNumberGlobal,
 166                                 "2": self.keyNumberGlobal,
 167                                 "3": self.keyNumberGlobal,
 168                                 "4": self.keyNumberGlobal,
 169                                 "5": self.keyNumberGlobal,
 170                                 "6": self.keyNumberGlobal,
 171                                 "7": self.keyNumberGlobal,
 172                                 "8": self.keyNumberGlobal,
 173                                 "9": self.keyNumberGlobal,
 174                                 "0": self.keyNumberGlobal
 175                         })
 176
 177                 self.Timer = eTimer()
 178                 self.Timer.timeout.get().append(self.keyOK)
 179                 self.Timer.start(3000)
 180
 181 class InfoBarPowerKey:
 182         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
 183
 184         def __init__(self):
 185                 self.powerKeyTimer = eTimer()
 186                 self.powerKeyTimer.timeout.get().append(self.powertimer)
 187                 self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
 188                         {
 189                                 "powerdown": self.powerdown,
 190                                 "powerup": self.powerup,
 191                                 "discreteStandby": (self.standby, "Go standby"),
 192                                 "discretePowerOff": (self.quit, "Go to deep standby"),
 193                         })
 194
 195         def powertimer(self):
 196                 print "PowerOff - Now!"
 197                 self.quit()
 198
 199         def powerdown(self):
 200                 self.standbyblocked = 0
 201                 self.powerKeyTimer.start(3000)
 202
 203         def powerup(self):
 204                 self.powerKeyTimer.stop()
 205                 if self.standbyblocked == 0:
 206                         self.standbyblocked = 1
 207                         self.standby()
 208
 209         def standby(self):
 210                 self.session.open(Standby, self)
 211
 212         def quit(self):
 213                 # halt
 214                 quitMainloop(1)
 215
 216 class InfoBarNumberZap:
 217         """ Handles an initial number for NumberZapping """
 218         def __init__(self):
 219                 self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
 220                         {
 221                                 "1": self.keyNumberGlobal,
 222                                 "2": self.keyNumberGlobal,
 223                                 "3": self.keyNumberGlobal,
 224                                 "4": self.keyNumberGlobal,
 225                                 "5": self.keyNumberGlobal,
 226                                 "6": self.keyNumberGlobal,
 227                                 "7": self.keyNumberGlobal,
 228                                 "8": self.keyNumberGlobal,
 229                                 "9": self.keyNumberGlobal,
 230                                 "0": self.keyNumberGlobal,
 231                         })
 232
 233         def keyNumberGlobal(self, number):
 234 #               print "You pressed number " + str(number)
 235                 self.session.openWithCallback(self.numberEntered, NumberZap, number)
 236
 237         def numberEntered(self, retval):
 238 #               print self.servicelist
 239                 if retval > 0:
 240                         self.servicelist.zapToNumber(retval)
 241
 242 class InfoBarChannelSelection:
 243         """ ChannelSelection - handles the channelSelection dialog and the initial
 244         channelChange actions which open the channelSelection dialog """
 245         def __init__(self):
 246                 #instantiate forever
 247                 self.servicelist = self.session.instantiateDialog(ChannelSelection)
 248
 249                 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
 250                         {
 251                                 "switchChannelUp": self.switchChannelUp,
 252                                 "switchChannelDown": self.switchChannelDown,
 253                                 "zapUp": (self.zapUp, _("next channel")),
 254                                 "zapDown": (self.zapDown, _("previous channel")),
 255                         })
 256
 257         def switchChannelUp(self):
 258                 self.servicelist.moveUp()
 259                 self.session.execDialog(self.servicelist)
 260
 261         def switchChannelDown(self):
 262                 self.servicelist.moveDown()
 263                 self.session.execDialog(self.servicelist)
 264
 265         def     zapUp(self):
 266                 self.servicelist.moveUp()
 267                 self.servicelist.zap()
 268
 269         def     zapDown(self):
 270                 self.servicelist.moveDown()
 271                 self.servicelist.zap()
 272
 273 class InfoBarMenu:
 274         """ Handles a menu action, to open the (main) menu """
 275         def __init__(self):
 276                 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
 277                         {
 278                                 "mainMenu": (self.mainMenu, "Enter main menu..."),
 279                         })
 280
 281         def mainMenu(self):
 282                 print "loading mainmenu XML..."
 283                 menu = mdom.childNodes[0]
 284                 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
 285                 self.session.open(MainMenu, menu, menu.childNodes)
 286
 287 class InfoBarEPG:
 288         """ EPG - Opens an EPG list when the showEPGList action fires """
 289         def __init__(self):
 290                 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
 291                         {
 292                                 "showEPGList": (self.showEPGList, _("show EPG...")),
 293                         })
 294
 295         def showEPGList(self):
 296                 ref=self.session.nav.getCurrentlyPlayingServiceReference()
 297                 ptr=eEPGCache.getInstance()
 298                 if ptr.startTimeQuery(ref) != -1:
 299                         self.session.open(EPGSelection, ref)
 300                 else: # try to show now/next
 301                         print 'no epg for service', ref.toString()
 302                         try:
 303                                 self.epglist = [ ]
 304                                 service = self.session.nav.getCurrentService()
 305                                 info = service.info()
 306                                 ptr=info.getEvent(0)
 307                                 if ptr:
 308                                         self.epglist.append(ptr)
 309                                 ptr=info.getEvent(1)
 310                                 if ptr:
 311                                         self.epglist.append(ptr)
 312                                 if len(self.epglist) > 0:
 313                                         self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
 314                         except:
 315                                 pass
 316
 317         def eventViewCallback(self, setEvent, val): #used for now/next displaying
 318                 if len(self.epglist) > 1:
 319                         tmp = self.epglist[0]
 320                         self.epglist[0]=self.epglist[1]
 321                         self.epglist[1]=tmp
 322                         setEvent(self.epglist[0])
 323
 324 class InfoBarEvent:
 325         """provides a current/next event info display"""
 326         def __init__(self):
 327                 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
 328                 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
 329
 330                 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
 331                 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
 332
 333                 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
 334                 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
 335
 336 class InfoBarServiceName:
 337         def __init__(self):
 338                 self["ServiceName"] = ServiceName(self.session.nav)
 339
 340 class InfoBarPVR:
 341         """handles PVR specific actions like seeking, pause"""
 342         def __init__(self):
 343                 self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions",
 344                         {
 345                                 "pauseService": (self.pauseService, "pause"),
 346                                 "unPauseService": (self.unPauseService, "continue"),
 347
 348                                 "seekFwd": (self.seekFwd, "skip forward"),
 349                                 "seekBack": (self.seekBack, "skip backward"),
 350                         })
 351
 352         def pauseService(self):
 353                 self.session.nav.pause(1)
 354
 355         def unPauseService(self):
 356                 self.session.nav.pause(0)
 357
 358         def doSeek(self, dir, seektime):
 359                 service = self.session.nav.getCurrentService()
 360                 if service is None:
 361                         return
 362
 363                 seekable = service.seek()
 364                 if seekable is None:
 365                         return
 366                 seekable.seekRelative(dir, 90 * seektime)
 367
 368         def seekFwd(self):
 369                 self.doSeek(+1, 60000)
 370
 371         def seekBack(self):
 372                 self.doSeek(-1, 60000)
 373
 374 class InfoBarInstantRecord:
 375         """Instant Record - handles the instantRecord action in order to
 376         start/stop instant records"""
 377         def __init__(self):
 378                 self["InstnantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
 379                         {
 380                                 "instantRecord": (self.instantRecord, "Instant Record..."),
 381                         })
 382                 self.recording = None
 383
 384         def stopCurrentRecording(self):
 385                 self.session.nav.RecordTimer.removeEntry(self.recording)
 386                 self.recording = None
 387
 388         def startInstantRecording(self):
 389                 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
 390
 391                 # try to get event info
 392                 epg = None
 393                 try:
 394                         service = self.session.nav.getCurrentService()
 395                         info = service.info()
 396                         ev = info.getEvent(0)
 397                         epg = ev
 398                 except:
 399                         pass
 400
 401                 # fix me, description.
 402                 self.recording = self.session.nav.recordWithTimer(time.time(), time.time() + 3600, serviceref, epg, "instant record")
 403                 self.recording.dontSave = True
 404
 405         def recordQuestionCallback(self, answer):
 406                 if answer == False:
 407                         return
 408
 409                 if self.recording != None:
 410                         self.stopCurrentRecording()
 411                 else:
 412                         self.startInstantRecording()
 413
 414         def instantRecord(self):
 415                 try:
 416                         stat = os.stat("/hdd/movies")
 417                 except:
 418                         self.session.open(MessageBox, "No HDD found!")
 419                         return
 420
 421                 if self.recording != None:
 422                         self.session.openWithCallback(self.recordQuestionCallback, MessageBox, "Do you want to stop the current\n(instant) recording?")
 423                 else:
 424                         self.session.openWithCallback(self.recordQuestionCallback, MessageBox, "Start recording?")
 425
 426 from Screens.AudioSelection import AudioSelection
 427
 428 class InfoBarAudioSelection:
 429         def __init__(self):
 430                 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
 431                         {
 432                                 "audioSelection": (self.audioSelection, "Audio Options..."),
 433                         })
 434
 435         def audioSelection(self):
 436                 service = self.session.nav.getCurrentService()
 437                 audio = service.audioTracks()
 438                 n = audio.getNumberOfTracks()
 439                 if n > 0:
 440                         self.session.open(AudioSelection, audio)