raoul
/
openlp
forked from openlp/openlp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cleanups, add settings dialog

This commit is contained in:
rimach crichter@web.de 2011-05-21 10:18:52 +02:00
parent 43a55c7087
commit 578e0fea3f
8 changed files with 326 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
openlp/core/ui/slidecontroller.py
View File

@ -297,11 +297,11 @@ class SlideController(QtGui.QWidget):
# Signals
QtCore.QObject.connect(self.previewListWidget,
QtCore.SIGNAL(u'clicked(QModelIndex)'), self.onSlideSelected)
QtCore.QObject.connect(self.seekSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaSeek)
QtCore.QObject.connect(self.volumeSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaVolume)
if self.isLive:
QtCore.QObject.connect(self.seekSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaSeek)
QtCore.QObject.connect(self.volumeSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaVolume)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'maindisplay_active'), self.updatePreview)
QtCore.QObject.connect(Receiver.get_receiver(),

54
openlp/plugins/media/lib/__init__.py
View File

@ -35,7 +35,7 @@ class MediaBackends(object):
class MediaState(object):
"""
An enumeration for possible States of the Media Player
(copied from Phonon::State
(copied partially from Phonon::State)
"""
Loading = 0
Stopped = 1
@ -50,54 +50,96 @@ class MediaController(object):
"""
def __init__(self, parent):
self.parent = parent
self.isActive = False
self.state = MediaState.Off
self.hasOwnWidget = False
def setup(self, display):
"""
Create the related widgets for the current display
"""
pass
def load(self, display, path, volume):
pass
"""
Load a new media file and check if it is valid
"""
return True
def resize(self, display, controller):
"""
If the main display size or position is changed,
the media widgets should also resized
"""
pass
def play(self, display):
"""
Starts playing of current Media File
"""
pass
def pause(self, display):
"""
Pause of current Media File
"""
pass
def stop(self, display):
"""
Stop playing of current Media File
"""
pass
def volume(self, display, vol):
"""
Change volume of current Media File
"""
pass
def seek(self, display, seekVal):
"""
Change playing position of current Media File
"""
pass
def reset(self, display):
"""
Remove the current loaded video
"""
pass
def set_visible(self, display, status):
"""
Show/Hide the media widgets
"""
pass
def update_ui(self, controller, display):
"""
Do some ui related stuff
(e.g. update the seek slider)
"""
pass
@staticmethod
def is_available():
pass
"""
Check availability of the related backend
"""
return False
def get_supported_file_types(self):
"""
Returns the supported file types for
Audio
Video
Locations
"""
pass
from mediaitem import MediaMediaItem
from mediatab import MediaTab
from mediacontroller import MediaManager
from webkitcontroller import WebkitController
#from phononcontroller import PhononController
#from vlccontroller import VlcController
__all__ = ['MediaMediaItem']

137
openlp/plugins/media/lib/mediacontroller.py
View File

@ -28,15 +28,10 @@
import logging
import sys, os
from PyQt4 import QtCore
#try:
# import vlc
#except:
# pass
from PyQt4 import QtCore, QtGui, QtWebKit
from PyQt4.phonon import Phonon
from openlp.core.lib import Receiver
from openlp.core.lib import Receiver, translate
from openlp.core.lib.ui import UiStrings, critical_error_message_box
from openlp.plugins.media.lib import MediaBackends, MediaState
from webkitcontroller import WebkitController
from phononcontroller import PhononController
@ -47,30 +42,28 @@ log = logging.getLogger(__name__)
class MediaManager(object):
"""
The implementation of a Media Manager
The idea is to separate the media related implementation into the plugin files
and unify the access from other parts of code
The idea is to separate the media related implementation
into the plugin files and unify the access from other parts of code
The media manager adds an own class for every type of backend
Currently these are QtWebkit, Phonon and planed Vlc.
On the other hand currently the previewController display only use phonon for media output.
So I would suggest to rename the maindisplay.py to display.py and modify the code,
so that the display class can be used for the maindisplay as well as for the previewController display.
"""
def __init__(self, parent):
self.parent = parent
self.backend = {}
self.backends = {}
self.curDisplayMediaController = {}
#one controller for every backend
#Create Backend Controllers
if WebkitController.is_available():
self.backend['webkit'] = WebkitController(self)
self.backends['webkit'] = WebkitController(self)
if PhononController.is_available():
self.backend['phonon'] = PhononController(self)
self.backends['phonon'] = PhononController(self)
if VlcController.is_available():
self.backend['vlc'] = VlcController(self)
self.backends['vlc'] = VlcController(self)
#Timer for video state
self.Timer = QtCore.QTimer()
self.Timer.setInterval(200)
#signals
self.withLivePreview = False
#Signals
QtCore.QObject.connect(self.Timer,
QtCore.SIGNAL("timeout()"), self.video_state)
QtCore.QObject.connect(Receiver.get_receiver(),
@ -108,28 +101,35 @@ class MediaManager(object):
for display in self.curDisplayMediaController.keys():
if display == self.parent.previewController.previewDisplay or \
display == self.parent.previewController.display:
self.curDisplayMediaController[display].update_ui(self.parent.previewController, display)
self.curDisplayMediaController[display] \
.update_ui(self.parent.previewController, display)
else:
self.curDisplayMediaController[display].update_ui(self.parent.liveController, display)
if self.curDisplayMediaController[display].state == MediaState.Playing:
self.curDisplayMediaController[display] \
.update_ui(self.parent.liveController, display)
if self.curDisplayMediaController[display] \
.state == MediaState.Playing:
isAnyonePlaying = True
if not isAnyonePlaying:
self.Timer.stop()
def setup_display(self, display):
# check controller relevant displays
if display == self.parent.previewController.previewDisplay or \
display == self.parent.liveController.display:
for backend_typ in self.backend.values():
backend_typ.setup(display)
"""
After a new display is configured, all media related widget
will be created too
"""
if not self.withLivePreview and \
display == self.parent.liveController.previewDisplay:
return
for backend in self.backends.values():
backend.setup(display)
def resize(self, controller):
"""
after Mainwindow changes or Splitter moved all related media
After Mainwindow changes or Splitter moved all related media
widgets have to be resized
"""
pass
#has to be clarified
#TODO
#for display in self.curDisplayMediaController.keys():
# self.curDisplayMediaController[display].resize(display, controller)
@ -143,29 +143,41 @@ class MediaManager(object):
isBackground = msg[3]
log.debug(u'video')
vol = float(volume) / float(10)
isValid = False
#stop running videos
self.video_reset(controller)
if controller.isLive:
# if isBackground:
# We are running a background theme
controller.display.override[u'theme'] = u''
controller.display.override[u'video'] = True
# display = controller.previewDisplay
# self.check_file_type(display, videoPath, False)
# self.curDisplayMediaController[display].load(display, videoPath, volume)
if self.withLivePreview:
display = controller.previewDisplay
if self.check_file_type(display, videoPath, False):
self.curDisplayMediaController[display] \
.load(display, videoPath, volume)
display = controller.display
self.check_file_type(display, videoPath, False)
self.curDisplayMediaController[display].load(display, videoPath, volume)
if self.check_file_type(display, videoPath, isBackground):
isValid = self.curDisplayMediaController[display] \
.load(display, videoPath, volume)
controller.display.webLoaded = True
else:
display = controller.previewDisplay
self.check_file_type(display, videoPath, False)
self.curDisplayMediaController[display].load(display, videoPath, volume)
self.check_file_type(display, videoPath, isBackground)
isValid = self.curDisplayMediaController[display] \
.load(display, videoPath, volume)
if not isValid:
#Media could not be loaded correctly
critical_error_message_box(
translate('MediaPlugin.MediaItem', 'Unsupported File'),
unicode(translate('MediaPlugin.MediaItem',
'Unsupported File')))
return
#check size of all media_widgets
self.resize(controller)
#now start playing
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].play(display)
print self.curDisplayMediaController[display]
self.video_play(controller)
def check_file_type(self, display, videoPath, isBackground):
"""
@ -173,19 +185,19 @@ class MediaManager(object):
from the prioritized backend list
"""
if videoPath.endswith(u'.swf') or isBackground:
self.curDisplayMediaController[display] = self.backend['webkit']
elif videoPath.endswith(u'.wmv'):
self.curDisplayMediaController[display] = self.backend['phonon']
self.curDisplayMediaController[display] = self.backends['webkit']
elif QtCore.QSettings().value(u'media/use webkit',
QtCore.QVariant(True)).toInt()[0] == 0:
self.curDisplayMediaController[display] = self.backends['webkit']
elif QtCore.QSettings().value(u'media/use vlc',
QtCore.QVariant(True)).toInt()[0] == 0:
self.curDisplayMediaController[display] = self.backends['vlc']
elif QtCore.QSettings().value(u'media/use phonon',
QtCore.QVariant(True)).toInt()[0] == 0:
self.curDisplayMediaController[display] = self.backends['phonon']
else:
self.curDisplayMediaController[display] = self.backend['vlc']
for key in self.backend.keys():
if self.backend[key] == self.curDisplayMediaController[display]:
self.backend[key].set_visible(display, True)
# else:
# self.backend[key].set_visible(display, False)
if len(self.curDisplayMediaController) > 0:
if not self.Timer.isActive():
self.Timer.start()
return False
return True
def video_play(self, controller):
"""
@ -198,7 +210,6 @@ class MediaManager(object):
# show screen
if not self.Timer.isActive():
self.Timer.start()
#display.setVisible(True)
def video_pause(self, controller):
"""
@ -258,7 +269,6 @@ class MediaManager(object):
if display.parent == controller:
self.curDisplayMediaController[display].seek(display, seekVal)
def video_reset(self, controller):
"""
Responds to the request to reset a loaded video
@ -268,48 +278,49 @@ class MediaManager(object):
if display.parent == controller:
self.curDisplayMediaController[display].reset(display)
del self.curDisplayMediaController[display]
# if controller.isLive:
#Receiver.send_message(u'maindisplay_active')
def video_hide(self, msg):
"""
Hide the related video Widget
"""
print "hide"
isLive = msg[1]
if isLive:
controller = self.parent.liveController
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
if self.curDisplayMediaController[display].state == MediaState.Playing:
if self.curDisplayMediaController[display] \
.state == MediaState.Playing:
self.curDisplayMediaController[display].pause(display)
self.curDisplayMediaController[display].set_visible(display, False)
self.curDisplayMediaController[display] \
.set_visible(display, False)
def video_blank(self, msg):
"""
Blank the related video Widget
"""
print "blank"
isLive = msg[1]
if isLive:
controller = self.parent.liveController
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
if self.curDisplayMediaController[display].state == MediaState.Playing:
if self.curDisplayMediaController[display] \
.state == MediaState.Playing:
self.curDisplayMediaController[display].pause(display)
self.curDisplayMediaController[display].set_visible(display, False)
self.curDisplayMediaController[display] \
.set_visible(display, False)
def video_unblank(self, msg):
"""
Unblank the related video Widget
"""
print "unblank"
Receiver.send_message(u'maindisplay_show')
isLive = msg[1]
if isLive:
controller = self.parent.liveController
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
if self.curDisplayMediaController[display].state == MediaState.Paused:
if self.curDisplayMediaController[display] \
.state == MediaState.Paused:
self.curDisplayMediaController[display].play(display)
self.curDisplayMediaController[display].set_visible(display, True)
self.curDisplayMediaController[display] \
.set_visible(display, True)

27
openlp/plugins/media/lib/mediaitem.py
View File

@ -24,7 +24,6 @@
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
from datetime import datetime
import logging
import os
@ -89,7 +88,6 @@ class MediaMediaItem(MediaManagerItem):
Called to reset the Live backgound with the media selected,
"""
self.resetAction.setVisible(False)
#self.parent.liveController.display.resetVideo()
Receiver.send_message(u'media_reset',
self.parent.liveController)
@ -132,17 +130,6 @@ class MediaMediaItem(MediaManagerItem):
unicode(translate('MediaPlugin.MediaItem',
'The file %s no longer exists.')) % filename)
return False
# self.mediaObject.stop()
# self.mediaObject.clearQueue()
# self.mediaObject.setCurrentSource(Phonon.MediaSource(filename))
# if not self.mediaStateWait(Phonon.Stopped):
# Due to string freeze, borrow a message from presentations
# This will be corrected in 1.9.6
# critical_error_message_box(
# translate('PresentationPlugin.MediaItem', 'Unsupported File'),
# unicode(translate('PresentationPlugin.MediaItem',
# 'Unsupported File')))
#return False
# File too big for processing
if os.path.getsize(filename) <= 52428800: # 50MiB
# self.mediaObject.play()
@ -172,20 +159,6 @@ class MediaMediaItem(MediaManagerItem):
service_item.add_from_command(path, name, frame)
return True
def mediaStateWait(self, mediaState):
"""
Wait for the video to change its state
Wait no longer than 5 seconds.
"""
start = datetime.now()
while self.mediaObject.state() != mediaState:
if self.mediaObject.state() == Phonon.ErrorState:
return False
Receiver.send_message(u'openlp_process_events')
if (datetime.now() - start).seconds > 5:
return False
return True
def initialise(self):
self.listView.clear()
self.listView.setIconSize(QtCore.QSize(88, 50))

142
openlp/plugins/media/lib/mediatab.py
View File

@ -38,40 +38,152 @@ class MediaTab(SettingsTab):
def setupUi(self):
self.setObjectName(u'MediaTab')
SettingsTab.setupUi(self)
self.mediaModeGroupBox = QtGui.QGroupBox(self.leftColumn)
self.mediaModeGroupBox.setObjectName(u'mediaModeGroupBox')
self.mediaModeLayout = QtGui.QFormLayout(self.mediaModeGroupBox)
self.mediaModeLayout.setObjectName(u'mediaModeLayout')
self.usePhononCheckBox = QtGui.QCheckBox(self.mediaModeGroupBox)
self.mediaLayoutWidget = QtGui.QWidget(self.leftColumn)
self.mediaBackendLayout = QtGui.QVBoxLayout(self.mediaLayoutWidget)
self.mediaBackendLayout.setObjectName(u'mediaBackendLayout')
self.mediaBackendsGroupBox = QtGui.QGroupBox(self.mediaLayoutWidget)
self.mediaBackendsGroupBox.setObjectName(u'mediaBackendsGroupBox')
self.mediaBackendsGroupLayout = QtGui.QVBoxLayout( \
self.mediaBackendsGroupBox)
self.mediaBackendsGroupLayout.setObjectName( \
u'mediaBackendsGroupLayout')
self.usePhononCheckBox = QtGui.QCheckBox(self.mediaBackendsGroupBox)
self.usePhononCheckBox.setObjectName(u'usePhononCheckBox')
self.mediaModeLayout.addRow(self.usePhononCheckBox)
self.leftLayout.addWidget(self.mediaModeGroupBox)
self.mediaBackendsGroupLayout.addWidget(self.usePhononCheckBox)
self.useVlcCheckBox = QtGui.QCheckBox(self.mediaBackendsGroupBox)
self.useVlcCheckBox.setObjectName(u'useVlcCheckBox')
self.mediaBackendsGroupLayout.addWidget(self.useVlcCheckBox)
self.mediaBackendLayout.addWidget(self.mediaBackendsGroupBox)
self.backendOrderLabel = QtGui.QLabel(self.mediaLayoutWidget)
self.backendOrderLabel.setObjectName(u'backendOrderLabel')
self.mediaBackendLayout.addWidget(self.backendOrderLabel)
self.backendOrderlistWidget = QtGui.QListWidget(self.mediaLayoutWidget)
self.backendOrderlistWidget.setVerticalScrollBarPolicy( \
QtCore.Qt.ScrollBarAsNeeded)
self.backendOrderlistWidget.setHorizontalScrollBarPolicy( \
QtCore.Qt.ScrollBarAlwaysOff)
self.backendOrderlistWidget.setEditTriggers( \
QtGui.QAbstractItemView.NoEditTriggers)
self.backendOrderlistWidget.setObjectName(u'backendOrderlistWidget')
self.mediaBackendLayout.addWidget(self.backendOrderlistWidget)
self.orderingButtonLayout = QtGui.QHBoxLayout()
self.orderingButtonLayout.setObjectName(u'orderingButtonLayout')
self.orderingDownButton = QtGui.QPushButton(self.mediaLayoutWidget)
self.orderingDownButton.setObjectName(u'orderingDownButton')
self.orderingButtonLayout.addWidget(self.orderingDownButton)
self.orderingUpButton = QtGui.QPushButton(self.mediaLayoutWidget)
self.orderingUpButton.setObjectName(u'orderingUpButton')
self.orderingButtonLayout.addWidget(self.orderingUpButton)
self.mediaBackendLayout.addLayout(self.orderingButtonLayout)
self.leftLayout.addWidget(self.mediaLayoutWidget)
self.leftLayout.addStretch()
self.rightLayout.addStretch()
QtCore.QObject.connect(self.usePhononCheckBox,
QtCore.SIGNAL(u'stateChanged(int)'),
self.onUsePhononCheckBoxChanged)
QtCore.QObject.connect(self.useVlcCheckBox,
QtCore.SIGNAL(u'stateChanged(int)'),
self.onUseVlcCheckBoxChanged)
QtCore.QObject.connect(self.orderingUpButton,
QtCore.SIGNAL(u'pressed()'), self.onOrderingUpButtonPressed)
QtCore.QObject.connect(self.orderingDownButton,
QtCore.SIGNAL(u'pressed()'), self.onOrderingDownButtonPressed)
def retranslateUi(self):
self.mediaModeGroupBox.setTitle(
translate('MediaPlugin.MediaTab', 'Media Display'))
self.usePhononCheckBox.setText(
translate('MediaPlugin.MediaTab', 'Use Phonon for video playback'))
translate('MediaPlugin.MediaTab', 'use Phonon'))
self.useVlcCheckBox.setText(
translate('MediaPlugin.MediaTab', 'use Vlc'))
self.backendOrderLabel.setText(
translate('MediaPlugin.MediaTab', 'Backend Order'))
self.orderingDownButton.setText(
translate('MediaPlugin.MediaTab', 'Down'))
self.orderingUpButton.setText(
translate('MediaPlugin.MediaTab', 'Up'))
def onUsePhononCheckBoxChanged(self, check_state):
self.usePhonon = (check_state == QtCore.Qt.Checked)
self.usePhononChanged = True
if check_state == QtCore.Qt.Checked:
self.usePhonon = self.backendOrderlistWidget.count()
else:
self.usePhonon = -1
self.updateBackendList()
def onUseVlcCheckBoxChanged(self, check_state):
if check_state == QtCore.Qt.Checked:
self.useVlc = self.backendOrderlistWidget.count()
else:
self.useVlc = -1
self.updateBackendList()
def onOrderingUpButtonPressed(self):
currentRow = self.backendOrderlistWidget.currentRow()
if currentRow > 0:
item = self.backendOrderlistWidget.takeItem(currentRow)
self.backendOrderlistWidget.insertItem(currentRow-1, item)
self.backendOrderlistWidget.setCurrentRow(currentRow-1)
self.updateOrdering()
def onOrderingDownButtonPressed(self):
currentRow = self.backendOrderlistWidget.currentRow()
if currentRow < self.backendOrderlistWidget.count()-1:
item = self.backendOrderlistWidget.takeItem(currentRow)
self.backendOrderlistWidget.insertItem(currentRow+1, item)
self.backendOrderlistWidget.setCurrentRow(currentRow+1)
self.updateOrdering()
def updateOrdering(self):
for num in range (0, self.backendOrderlistWidget.count()):
item = self.backendOrderlistWidget.item(num)
if item.text == u'Webkit':
self.useWebkit = num
elif item.text == u'Phonon':
self.usePhonon = num
elif item.text == u'Vlc':
self.useVlc = num
def updateBackendList(self):
self.backendOrderlistWidget.clear()
for num in range(0, 3):
if self.useWebkit == num:
self.backendOrderlistWidget.addItem(u'Webkit')
elif self.usePhonon == num:
self.backendOrderlistWidget.addItem(u'Phonon')
elif self.useVlc == num:
self.backendOrderlistWidget.addItem(u'Vlc')
def load(self):
self.useWebkit = QtCore.QSettings().value(
self.settingsSection + u'/use webkit',
QtCore.QVariant(True)).toInt()[0]
self.usePhonon = QtCore.QSettings().value(
self.settingsSection + u'/use phonon',
QtCore.QVariant(True)).toBool()
self.usePhononCheckBox.setChecked(self.usePhonon)
QtCore.QVariant(True)).toInt()[0]
self.useVlc = QtCore.QSettings().value(
self.settingsSection + u'/use vlc',
QtCore.QVariant(True)).toInt()[0]
self.usePhononCheckBox.setChecked((self.usePhonon != -1))
self.useVlcCheckBox.setChecked((self.useVlc != -1))
def save(self):
changedValues = False
oldUseWebkit = QtCore.QSettings().value(
u'media/use webkit', QtCore.QVariant(True)).toInt()[0]
if oldUseWebkit != self.useWebkit:
QtCore.QSettings().setValue(self.settingsSection + u'/use webkit',
QtCore.QVariant(self.useWebkit))
changedValues = True
oldUsePhonon = QtCore.QSettings().value(
u'media/use phonon', QtCore.QVariant(True)).toBool()
u'media/use phonon', QtCore.QVariant(True)).toInt()[0]
if oldUsePhonon != self.usePhonon:
QtCore.QSettings().setValue(self.settingsSection + u'/use phonon',
QtCore.QVariant(self.usePhonon))
changedValues = True
oldUseVlc = QtCore.QSettings().value(
u'media/use vlc', QtCore.QVariant(True)).toInt()[0]
if oldUseVlc != self.useVlc:
QtCore.QSettings().setValue(self.settingsSection + u'/use vlc',
QtCore.QVariant(self.useVlc))
changedValues = True
if changedValues:
Receiver.send_message(u'config_screen_changed')

35
openlp/plugins/media/lib/phononcontroller.py
View File

@ -25,11 +25,17 @@
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import logging
from datetime import datetime
from PyQt4 import QtCore, QtGui
from PyQt4.phonon import Phonon
from openlp.core.lib import Receiver
from openlp.plugins.media.lib import MediaController, MediaState
log = logging.getLogger(__name__)
class PhononController(MediaController):
"""
Specialiced MediaController class
@ -59,7 +65,8 @@ class PhononController(MediaController):
display.phononWidget.setVisible(False)
display.phononWidget.resize(display.size())
display.mediaObject = Phonon.MediaObject(display)
display.audio = Phonon.AudioOutput(Phonon.VideoCategory, display.mediaObject)
display.audio = Phonon.AudioOutput( \
Phonon.VideoCategory, display.mediaObject)
Phonon.createPath(display.mediaObject, display.phononWidget)
Phonon.createPath(display.mediaObject, display.audio)
display.phononWidget.raise_()
@ -90,14 +97,27 @@ class PhononController(MediaController):
u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume):
print "load vid in Phonon Controller"
display.mediaObject.stop()
display.mediaObject.clearQueue()
log.debug(u'load vid in Phonon Controller')
display.mediaObject.setCurrentSource(Phonon.MediaSource(path))
# Need the timer to trigger set the trigger to 200ms
# Value taken from web documentation.
if not self.mediaStateWait(display, Phonon.StoppedState):
return False
vol = float(volume) / float(10)
display.audio.setVolume(vol)
return True
def mediaStateWait(self, display, mediaState):
"""
Wait for the video to change its state
Wait no longer than 5 seconds.
"""
start = datetime.now()
while display.mediaObject.state() != mediaState:
if display.mediaObject.state() == Phonon.ErrorState:
return False
Receiver.send_message(u'openlp_process_events')
if (datetime.now() - start).seconds > 5:
return False
return True
def resize(self, display, controller):
display.phononWidget.resize(display.size())
@ -136,7 +156,8 @@ class PhononController(MediaController):
def update_ui(self, controller, display):
controller.seekSlider.setMaximum(display.mediaObject.totalTime())
if not controller.seekSlider.isSliderDown():
controller.seekSlider.setSliderPosition(display.mediaObject.currentTime())
controller.seekSlider.setSliderPosition( \
display.mediaObject.currentTime())
# if newState == Phonon.Playing \
# and oldState != Phonon.Paused \
# and self.serviceItem.start_time > 0:

49
openlp/plugins/media/lib/vlccontroller.py
View File

@ -25,14 +25,19 @@
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import logging
import sys
from datetime import datetime
try:
import vlc
except:
pass
from PyQt4 import QtCore, QtGui
from openlp.core.lib import Receiver
from openlp.plugins.media.lib import MediaController, MediaState
log = logging.getLogger(__name__)
class VlcController(MediaController):
"""
Specialiced MediaController class
@ -52,6 +57,17 @@ class VlcController(MediaController):
display.vlcWidget.resize(display.size())
display.vlcWidget.raise_()
display.vlcWidget.hide()
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform == "linux2": # for Linux using the X Server
display.vlcMediaPlayer.set_xwindow(int(display.vlcWidget.winId()))
elif sys.platform == "win32": # for Windows
display.vlcMediaPlayer.set_hwnd(int(display.vlcWidget.winId()))
elif sys.platform == "darwin": # for MacOS
display.vlcMediaPlayer.set_agl(int(display.vlcWidget.winId()))
self.hasOwnWidget = True
@staticmethod
@ -80,29 +96,31 @@ class VlcController(MediaController):
u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume):
print "load vid in Vlc Controller"
log.debug(u'load vid in Vlc Controller')
vol = float(volume) / float(10)
# create the media
#display.vlcMedia = display.vlcInstance.media_new(unicode(path))
display.vlcMedia = display.vlcInstance.media_new_path(unicode(path))
# put the media in the media player
display.vlcMediaPlayer.set_media(display.vlcMedia)
# parse the metadata of the file
display.vlcMedia.parse()
if not self.mediaStateWait(display):
return False
return True
# the media player has to be 'connected' to the QFrame
# (otherwise a video would be displayed in it's own window)
# this is platform specific!
# you have to give the id of the QFrame (or similar object) to
# vlc, different platforms have different functions for this
if sys.platform == "linux2": # for Linux using the X Server
display.vlcMediaPlayer.set_xwindow(int(display.vlcWidget.winId()))
elif sys.platform == "win32": # for Windows
display.vlcMediaPlayer.set_hwnd(int(display.vlcWidget.winId()))
elif sys.platform == "darwin": # for MacOS
display.vlcMediaPlayer.set_agl(int(display.vlcWidget.winId()))
def mediaStateWait(self, display):
"""
Wait for the video to change its state
Wait no longer than 5 seconds.
"""
start = datetime.now()
while not display.vlcMedia.is_parsed():
if display.vlcMedia.get_state() == vlc.State.Error:
return False
Receiver.send_message(u'openlp_process_events')
if (datetime.now() - start).seconds > 5:
return False
return True
def resize(self, display, controller):
display.vlcWidget.resize(display.size())
@ -133,7 +151,6 @@ class VlcController(MediaController):
self.state = MediaState.Off
def set_visible(self, display, status):
print display.vlcWidget.isVisible(), status
if self.hasOwnWidget:
display.vlcWidget.setVisible(status)

16
openlp/plugins/media/lib/webkitcontroller.py
View File

@ -25,9 +25,13 @@
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import logging
from PyQt4 import QtCore, QtGui, QtWebKit
from openlp.plugins.media.lib import MediaController, MediaState
log = logging.getLogger(__name__)
class WebkitController(MediaController):
"""
Specialiced MediaController class
@ -70,7 +74,7 @@ class WebkitController(MediaController):
u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume):
print "load vid in Webkit Controller"
log.debug(u'load vid in Webkit Controller')
vol = float(volume) / float(10)
display.webView.setVisible(True)
if path.endswith(u'.swf'):
@ -82,6 +86,7 @@ class WebkitController(MediaController):
(path.replace(u'\\', u'\\\\'), str(vol))
self.isFlash = False
display.frame.evaluateJavaScript(js)
return True
def resize(self, display, controller):
if display == controller.previewDisplay:
@ -117,7 +122,8 @@ class WebkitController(MediaController):
def seek(self, display, seekVal):
if not self.isFlash:
seek = float(seekVal)/1000
display.frame.evaluateJavaScript(u'show_video("seek", null, null, null, "%f");' % (seek))
display.frame.evaluateJavaScript( \
u'show_video("seek", null, null, null, "%f");' % (seek))
def reset(self, display):
if self.isFlash:
@ -132,12 +138,14 @@ class WebkitController(MediaController):
def update_ui(self, controller, display):
if not self.isFlash:
currentTime = display.frame.evaluateJavaScript(u'show_video("currentTime");')
currentTime = display.frame.evaluateJavaScript( \
u'show_video("currentTime");')
length = display.frame.evaluateJavaScript(u'show_video("length");')
if int(currentTime.toFloat()[0]*1000) > 0:
controller.seekSlider.setMaximum(int(length.toFloat()[0]*1000))
if not controller.seekSlider.isSliderDown():
controller.seekSlider.setSliderPosition(int(currentTime.toFloat()[0]*1000))
controller.seekSlider.setSliderPosition( \
int(currentTime.toFloat()[0]*1000))
def get_supported_file_types(self):
pass