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