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

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

@ -297,11 +297,11 @@ class SlideController(QtGui.QWidget):
# Signals # Signals
QtCore.QObject.connect(self.previewListWidget, QtCore.QObject.connect(self.previewListWidget,
QtCore.SIGNAL(u'clicked(QModelIndex)'), self.onSlideSelected) QtCore.SIGNAL(u'clicked(QModelIndex)'), self.onSlideSelected)
if self.isLive:
QtCore.QObject.connect(self.seekSlider, QtCore.QObject.connect(self.seekSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaSeek) QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaSeek)
QtCore.QObject.connect(self.volumeSlider, QtCore.QObject.connect(self.volumeSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaVolume) QtCore.SIGNAL(u'sliderMoved(int)'), self.mediaVolume)
if self.isLive:
QtCore.QObject.connect(Receiver.get_receiver(), QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'maindisplay_active'), self.updatePreview) QtCore.SIGNAL(u'maindisplay_active'), self.updatePreview)
QtCore.QObject.connect(Receiver.get_receiver(), 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): class MediaState(object):
""" """
An enumeration for possible States of the Media Player An enumeration for possible States of the Media Player
(copied from Phonon::State (copied partially from Phonon::State)
""" """
Loading = 0 Loading = 0
Stopped = 1 Stopped = 1
@ -50,54 +50,96 @@ class MediaController(object):
""" """
def __init__(self, parent): def __init__(self, parent):
self.parent = parent self.parent = parent
self.isActive = False
self.state = MediaState.Off self.state = MediaState.Off
self.hasOwnWidget = False self.hasOwnWidget = False
def setup(self, display): def setup(self, display):
"""
Create the related widgets for the current display
"""
pass pass
def load(self, display, path, volume): 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): def resize(self, display, controller):
"""
If the main display size or position is changed,
the media widgets should also resized
"""
pass pass
def play(self, display): def play(self, display):
"""
Starts playing of current Media File
"""
pass pass
def pause(self, display): def pause(self, display):
"""
Pause of current Media File
"""
pass pass
def stop(self, display): def stop(self, display):
"""
Stop playing of current Media File
"""
pass pass
def volume(self, display, vol): def volume(self, display, vol):
"""
Change volume of current Media File
"""
pass pass
def seek(self, display, seekVal): def seek(self, display, seekVal):
"""
Change playing position of current Media File
"""
pass pass
def reset(self, display): def reset(self, display):
"""
Remove the current loaded video
"""
pass pass
def set_visible(self, display, status): def set_visible(self, display, status):
"""
Show/Hide the media widgets
"""
pass pass
def update_ui(self, controller, display): def update_ui(self, controller, display):
"""
Do some ui related stuff
(e.g. update the seek slider)
"""
pass pass
@staticmethod @staticmethod
def is_available(): def is_available():
pass """
Check availability of the related backend
"""
return False
def get_supported_file_types(self): def get_supported_file_types(self):
"""
Returns the supported file types for
Audio
Video
Locations
"""
pass pass
from mediaitem import MediaMediaItem from mediaitem import MediaMediaItem
from mediatab import MediaTab from mediatab import MediaTab
from mediacontroller import MediaManager from mediacontroller import MediaManager
from webkitcontroller import WebkitController
#from phononcontroller import PhononController
#from vlccontroller import VlcController
__all__ = ['MediaMediaItem'] __all__ = ['MediaMediaItem']

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

@ -28,15 +28,10 @@
import logging import logging
import sys, os import sys, os
from PyQt4 import QtCore
#try:
# import vlc
#except:
# pass
from PyQt4 import QtCore, QtGui, QtWebKit 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 openlp.plugins.media.lib import MediaBackends, MediaState
from webkitcontroller import WebkitController from webkitcontroller import WebkitController
from phononcontroller import PhononController from phononcontroller import PhononController
@ -47,30 +42,28 @@ log = logging.getLogger(__name__)
class MediaManager(object): class MediaManager(object):
""" """
The implementation of a Media Manager The implementation of a Media Manager
The idea is to separate the media related implementation into the plugin files The idea is to separate the media related implementation
and unify the access from other parts of code 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 The media manager adds an own class for every type of backend
Currently these are QtWebkit, Phonon and planed Vlc. 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): def __init__(self, parent):
self.parent = parent self.parent = parent
self.backend = {} self.backends = {}
self.curDisplayMediaController = {} self.curDisplayMediaController = {}
#one controller for every backend #Create Backend Controllers
if WebkitController.is_available(): if WebkitController.is_available():
self.backend['webkit'] = WebkitController(self) self.backends['webkit'] = WebkitController(self)
if PhononController.is_available(): if PhononController.is_available():
self.backend['phonon'] = PhononController(self) self.backends['phonon'] = PhononController(self)
if VlcController.is_available(): if VlcController.is_available():
self.backend['vlc'] = VlcController(self) self.backends['vlc'] = VlcController(self)
#Timer for video state #Timer for video state
self.Timer = QtCore.QTimer() self.Timer = QtCore.QTimer()
self.Timer.setInterval(200) self.Timer.setInterval(200)
#signals self.withLivePreview = False
#Signals
QtCore.QObject.connect(self.Timer, QtCore.QObject.connect(self.Timer,
QtCore.SIGNAL("timeout()"), self.video_state) QtCore.SIGNAL("timeout()"), self.video_state)
QtCore.QObject.connect(Receiver.get_receiver(), QtCore.QObject.connect(Receiver.get_receiver(),
@ -108,28 +101,35 @@ class MediaManager(object):
for display in self.curDisplayMediaController.keys(): for display in self.curDisplayMediaController.keys():
if display == self.parent.previewController.previewDisplay or \ if display == self.parent.previewController.previewDisplay or \
display == self.parent.previewController.display: display == self.parent.previewController.display:
self.curDisplayMediaController[display].update_ui(self.parent.previewController, display) self.curDisplayMediaController[display] \
.update_ui(self.parent.previewController, display)
else: else:
self.curDisplayMediaController[display].update_ui(self.parent.liveController, display) self.curDisplayMediaController[display] \
if self.curDisplayMediaController[display].state == MediaState.Playing: .update_ui(self.parent.liveController, display)
if self.curDisplayMediaController[display] \
.state == MediaState.Playing:
isAnyonePlaying = True isAnyonePlaying = True
if not isAnyonePlaying: if not isAnyonePlaying:
self.Timer.stop() self.Timer.stop()
def setup_display(self, display): def setup_display(self, display):
# check controller relevant displays """
if display == self.parent.previewController.previewDisplay or \ After a new display is configured, all media related widget
display == self.parent.liveController.display: will be created too
for backend_typ in self.backend.values(): """
backend_typ.setup(display) if not self.withLivePreview and \
display == self.parent.liveController.previewDisplay:
return
for backend in self.backends.values():
backend.setup(display)
def resize(self, controller): 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 widgets have to be resized
""" """
pass pass
#has to be clarified #TODO
#for display in self.curDisplayMediaController.keys(): #for display in self.curDisplayMediaController.keys():
# self.curDisplayMediaController[display].resize(display, controller) # self.curDisplayMediaController[display].resize(display, controller)
@ -143,29 +143,41 @@ class MediaManager(object):
isBackground = msg[3] isBackground = msg[3]
log.debug(u'video') log.debug(u'video')
vol = float(volume) / float(10) vol = float(volume) / float(10)
isValid = False
#stop running videos #stop running videos
self.video_reset(controller) self.video_reset(controller)
if controller.isLive: if controller.isLive:
# if isBackground:
# We are running a background theme # We are running a background theme
controller.display.override[u'theme'] = u'' controller.display.override[u'theme'] = u''
controller.display.override[u'video'] = True controller.display.override[u'video'] = True
# display = controller.previewDisplay if self.withLivePreview:
# self.check_file_type(display, videoPath, False) display = controller.previewDisplay
# self.curDisplayMediaController[display].load(display, videoPath, volume) if self.check_file_type(display, videoPath, False):
self.curDisplayMediaController[display] \
.load(display, videoPath, volume)
display = controller.display display = controller.display
self.check_file_type(display, videoPath, False) if self.check_file_type(display, videoPath, isBackground):
self.curDisplayMediaController[display].load(display, videoPath, volume) isValid = self.curDisplayMediaController[display] \
.load(display, videoPath, volume)
controller.display.webLoaded = True controller.display.webLoaded = True
else: else:
display = controller.previewDisplay display = controller.previewDisplay
self.check_file_type(display, videoPath, False) self.check_file_type(display, videoPath, isBackground)
self.curDisplayMediaController[display].load(display, videoPath, volume) 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 #check size of all media_widgets
self.resize(controller) self.resize(controller)
#now start playing #now start playing
for display in self.curDisplayMediaController.keys(): print self.curDisplayMediaController[display]
if display.parent == controller: self.video_play(controller)
self.curDisplayMediaController[display].play(display)
def check_file_type(self, display, videoPath, isBackground): def check_file_type(self, display, videoPath, isBackground):
""" """
@ -173,19 +185,19 @@ class MediaManager(object):
from the prioritized backend list from the prioritized backend list
""" """
if videoPath.endswith(u'.swf') or isBackground: if videoPath.endswith(u'.swf') or isBackground:
self.curDisplayMediaController[display] = self.backend['webkit'] self.curDisplayMediaController[display] = self.backends['webkit']
elif videoPath.endswith(u'.wmv'): elif QtCore.QSettings().value(u'media/use webkit',
self.curDisplayMediaController[display] = self.backend['phonon'] 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: else:
self.curDisplayMediaController[display] = self.backend['vlc'] return False
for key in self.backend.keys(): return True
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()
def video_play(self, controller): def video_play(self, controller):
""" """
@ -198,7 +210,6 @@ class MediaManager(object):
# show screen # show screen
if not self.Timer.isActive(): if not self.Timer.isActive():
self.Timer.start() self.Timer.start()
#display.setVisible(True)
def video_pause(self, controller): def video_pause(self, controller):
""" """
@ -258,7 +269,6 @@ class MediaManager(object):
if display.parent == controller: if display.parent == controller:
self.curDisplayMediaController[display].seek(display, seekVal) self.curDisplayMediaController[display].seek(display, seekVal)
def video_reset(self, controller): def video_reset(self, controller):
""" """
Responds to the request to reset a loaded video Responds to the request to reset a loaded video
@ -268,48 +278,49 @@ class MediaManager(object):
if display.parent == controller: if display.parent == controller:
self.curDisplayMediaController[display].reset(display) self.curDisplayMediaController[display].reset(display)
del self.curDisplayMediaController[display] del self.curDisplayMediaController[display]
# if controller.isLive:
#Receiver.send_message(u'maindisplay_active')
def video_hide(self, msg): def video_hide(self, msg):
""" """
Hide the related video Widget Hide the related video Widget
""" """
print "hide"
isLive = msg[1] isLive = msg[1]
if isLive: if isLive:
controller = self.parent.liveController controller = self.parent.liveController
for display in self.curDisplayMediaController.keys(): for display in self.curDisplayMediaController.keys():
if display.parent == controller: 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].pause(display)
self.curDisplayMediaController[display].set_visible(display, False) self.curDisplayMediaController[display] \
.set_visible(display, False)
def video_blank(self, msg): def video_blank(self, msg):
""" """
Blank the related video Widget Blank the related video Widget
""" """
print "blank"
isLive = msg[1] isLive = msg[1]
if isLive: if isLive:
controller = self.parent.liveController controller = self.parent.liveController
for display in self.curDisplayMediaController.keys(): for display in self.curDisplayMediaController.keys():
if display.parent == controller: 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].pause(display)
self.curDisplayMediaController[display].set_visible(display, False) self.curDisplayMediaController[display] \
.set_visible(display, False)
def video_unblank(self, msg): def video_unblank(self, msg):
""" """
Unblank the related video Widget Unblank the related video Widget
""" """
print "unblank"
Receiver.send_message(u'maindisplay_show') Receiver.send_message(u'maindisplay_show')
isLive = msg[1] isLive = msg[1]
if isLive: if isLive:
controller = self.parent.liveController controller = self.parent.liveController
for display in self.curDisplayMediaController.keys(): for display in self.curDisplayMediaController.keys():
if display.parent == controller: 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].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 # # Temple Place, Suite 330, Boston, MA 02111-1307 USA #
############################################################################### ###############################################################################
from datetime import datetime
import logging import logging
import os import os
@ -89,7 +88,6 @@ class MediaMediaItem(MediaManagerItem):
Called to reset the Live backgound with the media selected, Called to reset the Live backgound with the media selected,
""" """
self.resetAction.setVisible(False) self.resetAction.setVisible(False)
#self.parent.liveController.display.resetVideo()
Receiver.send_message(u'media_reset', Receiver.send_message(u'media_reset',
self.parent.liveController) self.parent.liveController)
@ -132,17 +130,6 @@ class MediaMediaItem(MediaManagerItem):
unicode(translate('MediaPlugin.MediaItem', unicode(translate('MediaPlugin.MediaItem',
'The file %s no longer exists.')) % filename) 'The file %s no longer exists.')) % filename)
return False 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 # File too big for processing
if os.path.getsize(filename) <= 52428800: # 50MiB if os.path.getsize(filename) <= 52428800: # 50MiB
# self.mediaObject.play() # self.mediaObject.play()
@ -172,20 +159,6 @@ class MediaMediaItem(MediaManagerItem):
service_item.add_from_command(path, name, frame) service_item.add_from_command(path, name, frame)
return True 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): def initialise(self):
self.listView.clear() self.listView.clear()
self.listView.setIconSize(QtCore.QSize(88, 50)) 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): def setupUi(self):
self.setObjectName(u'MediaTab') self.setObjectName(u'MediaTab')
SettingsTab.setupUi(self) SettingsTab.setupUi(self)
self.mediaModeGroupBox = QtGui.QGroupBox(self.leftColumn) self.mediaLayoutWidget = QtGui.QWidget(self.leftColumn)
self.mediaModeGroupBox.setObjectName(u'mediaModeGroupBox') self.mediaBackendLayout = QtGui.QVBoxLayout(self.mediaLayoutWidget)
self.mediaModeLayout = QtGui.QFormLayout(self.mediaModeGroupBox) self.mediaBackendLayout.setObjectName(u'mediaBackendLayout')
self.mediaModeLayout.setObjectName(u'mediaModeLayout') self.mediaBackendsGroupBox = QtGui.QGroupBox(self.mediaLayoutWidget)
self.usePhononCheckBox = QtGui.QCheckBox(self.mediaModeGroupBox) 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.usePhononCheckBox.setObjectName(u'usePhononCheckBox')
self.mediaModeLayout.addRow(self.usePhononCheckBox) self.mediaBackendsGroupLayout.addWidget(self.usePhononCheckBox)
self.leftLayout.addWidget(self.mediaModeGroupBox) 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.leftLayout.addStretch()
self.rightLayout.addStretch() self.rightLayout.addStretch()
QtCore.QObject.connect(self.usePhononCheckBox, QtCore.QObject.connect(self.usePhononCheckBox,
QtCore.SIGNAL(u'stateChanged(int)'), QtCore.SIGNAL(u'stateChanged(int)'),
self.onUsePhononCheckBoxChanged) 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): def retranslateUi(self):
self.mediaModeGroupBox.setTitle(
translate('MediaPlugin.MediaTab', 'Media Display'))
self.usePhononCheckBox.setText( 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): def onUsePhononCheckBoxChanged(self, check_state):
self.usePhonon = (check_state == QtCore.Qt.Checked) if check_state == QtCore.Qt.Checked:
self.usePhononChanged = True 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): def load(self):
self.useWebkit = QtCore.QSettings().value(
self.settingsSection + u'/use webkit',
QtCore.QVariant(True)).toInt()[0]
self.usePhonon = QtCore.QSettings().value( self.usePhonon = QtCore.QSettings().value(
self.settingsSection + u'/use phonon', self.settingsSection + u'/use phonon',
QtCore.QVariant(True)).toBool() QtCore.QVariant(True)).toInt()[0]
self.usePhononCheckBox.setChecked(self.usePhonon) 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): 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( 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: if oldUsePhonon != self.usePhonon:
QtCore.QSettings().setValue(self.settingsSection + u'/use phonon', QtCore.QSettings().setValue(self.settingsSection + u'/use phonon',
QtCore.QVariant(self.usePhonon)) 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') 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 # # Temple Place, Suite 330, Boston, MA 02111-1307 USA #
############################################################################### ###############################################################################
import logging
from datetime import datetime
from PyQt4 import QtCore, QtGui from PyQt4 import QtCore, QtGui
from PyQt4.phonon import Phonon from PyQt4.phonon import Phonon
from openlp.core.lib import Receiver
from openlp.plugins.media.lib import MediaController, MediaState from openlp.plugins.media.lib import MediaController, MediaState
log = logging.getLogger(__name__)
class PhononController(MediaController): class PhononController(MediaController):
""" """
Specialiced MediaController class Specialiced MediaController class
@ -59,7 +65,8 @@ class PhononController(MediaController):
display.phononWidget.setVisible(False) display.phononWidget.setVisible(False)
display.phononWidget.resize(display.size()) display.phononWidget.resize(display.size())
display.mediaObject = Phonon.MediaObject(display) 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.phononWidget)
Phonon.createPath(display.mediaObject, display.audio) Phonon.createPath(display.mediaObject, display.audio)
display.phononWidget.raise_() display.phononWidget.raise_()
@ -90,14 +97,27 @@ class PhononController(MediaController):
u'video/x-ms-wmv': [u'.wmv']} u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume): def load(self, display, path, volume):
print "load vid in Phonon Controller" log.debug(u'load vid in Phonon Controller')
display.mediaObject.stop()
display.mediaObject.clearQueue()
display.mediaObject.setCurrentSource(Phonon.MediaSource(path)) display.mediaObject.setCurrentSource(Phonon.MediaSource(path))
# Need the timer to trigger set the trigger to 200ms if not self.mediaStateWait(display, Phonon.StoppedState):
# Value taken from web documentation. return False
vol = float(volume) / float(10) vol = float(volume) / float(10)
display.audio.setVolume(vol) 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): def resize(self, display, controller):
display.phononWidget.resize(display.size()) display.phononWidget.resize(display.size())
@ -136,7 +156,8 @@ class PhononController(MediaController):
def update_ui(self, controller, display): def update_ui(self, controller, display):
controller.seekSlider.setMaximum(display.mediaObject.totalTime()) controller.seekSlider.setMaximum(display.mediaObject.totalTime())
if not controller.seekSlider.isSliderDown(): if not controller.seekSlider.isSliderDown():
controller.seekSlider.setSliderPosition(display.mediaObject.currentTime()) controller.seekSlider.setSliderPosition( \
display.mediaObject.currentTime())
# if newState == Phonon.Playing \ # if newState == Phonon.Playing \
# and oldState != Phonon.Paused \ # and oldState != Phonon.Paused \
# and self.serviceItem.start_time > 0: # 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 # # Temple Place, Suite 330, Boston, MA 02111-1307 USA #
############################################################################### ###############################################################################
import logging
import sys import sys
from datetime import datetime
try: try:
import vlc import vlc
except: except:
pass pass
from PyQt4 import QtCore, QtGui from PyQt4 import QtCore, QtGui
from openlp.core.lib import Receiver
from openlp.plugins.media.lib import MediaController, MediaState from openlp.plugins.media.lib import MediaController, MediaState
log = logging.getLogger(__name__)
class VlcController(MediaController): class VlcController(MediaController):
""" """
Specialiced MediaController class Specialiced MediaController class
@ -52,6 +57,17 @@ class VlcController(MediaController):
display.vlcWidget.resize(display.size()) display.vlcWidget.resize(display.size())
display.vlcWidget.raise_() display.vlcWidget.raise_()
display.vlcWidget.hide() 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 self.hasOwnWidget = True
@staticmethod @staticmethod
@ -80,29 +96,31 @@ class VlcController(MediaController):
u'video/x-ms-wmv': [u'.wmv']} u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume): 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) vol = float(volume) / float(10)
# create the media # create the media
#display.vlcMedia = display.vlcInstance.media_new(unicode(path))
display.vlcMedia = display.vlcInstance.media_new_path(unicode(path)) display.vlcMedia = display.vlcInstance.media_new_path(unicode(path))
# put the media in the media player # put the media in the media player
display.vlcMediaPlayer.set_media(display.vlcMedia) display.vlcMediaPlayer.set_media(display.vlcMedia)
# parse the metadata of the file # parse the metadata of the file
display.vlcMedia.parse() display.vlcMedia.parse()
if not self.mediaStateWait(display):
return False
return True
# the media player has to be 'connected' to the QFrame def mediaStateWait(self, display):
# (otherwise a video would be displayed in it's own window) """
# this is platform specific! Wait for the video to change its state
# you have to give the id of the QFrame (or similar object) to Wait no longer than 5 seconds.
# vlc, different platforms have different functions for this """
if sys.platform == "linux2": # for Linux using the X Server start = datetime.now()
display.vlcMediaPlayer.set_xwindow(int(display.vlcWidget.winId())) while not display.vlcMedia.is_parsed():
elif sys.platform == "win32": # for Windows if display.vlcMedia.get_state() == vlc.State.Error:
display.vlcMediaPlayer.set_hwnd(int(display.vlcWidget.winId())) return False
elif sys.platform == "darwin": # for MacOS Receiver.send_message(u'openlp_process_events')
display.vlcMediaPlayer.set_agl(int(display.vlcWidget.winId())) if (datetime.now() - start).seconds > 5:
return False
return True
def resize(self, display, controller): def resize(self, display, controller):
display.vlcWidget.resize(display.size()) display.vlcWidget.resize(display.size())
@ -133,7 +151,6 @@ class VlcController(MediaController):
self.state = MediaState.Off self.state = MediaState.Off
def set_visible(self, display, status): def set_visible(self, display, status):
print display.vlcWidget.isVisible(), status
if self.hasOwnWidget: if self.hasOwnWidget:
display.vlcWidget.setVisible(status) 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 # # Temple Place, Suite 330, Boston, MA 02111-1307 USA #
############################################################################### ###############################################################################
import logging
from PyQt4 import QtCore, QtGui, QtWebKit from PyQt4 import QtCore, QtGui, QtWebKit
from openlp.plugins.media.lib import MediaController, MediaState from openlp.plugins.media.lib import MediaController, MediaState
log = logging.getLogger(__name__)
class WebkitController(MediaController): class WebkitController(MediaController):
""" """
Specialiced MediaController class Specialiced MediaController class
@ -70,7 +74,7 @@ class WebkitController(MediaController):
u'video/x-ms-wmv': [u'.wmv']} u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume): 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) vol = float(volume) / float(10)
display.webView.setVisible(True) display.webView.setVisible(True)
if path.endswith(u'.swf'): if path.endswith(u'.swf'):
@ -82,6 +86,7 @@ class WebkitController(MediaController):
(path.replace(u'\\', u'\\\\'), str(vol)) (path.replace(u'\\', u'\\\\'), str(vol))
self.isFlash = False self.isFlash = False
display.frame.evaluateJavaScript(js) display.frame.evaluateJavaScript(js)
return True
def resize(self, display, controller): def resize(self, display, controller):
if display == controller.previewDisplay: if display == controller.previewDisplay:
@ -117,7 +122,8 @@ class WebkitController(MediaController):
def seek(self, display, seekVal): def seek(self, display, seekVal):
if not self.isFlash: if not self.isFlash:
seek = float(seekVal)/1000 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): def reset(self, display):
if self.isFlash: if self.isFlash:
@ -132,12 +138,14 @@ class WebkitController(MediaController):
def update_ui(self, controller, display): def update_ui(self, controller, display):
if not self.isFlash: 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");') length = display.frame.evaluateJavaScript(u'show_video("length");')
if int(currentTime.toFloat()[0]*1000) > 0: if int(currentTime.toFloat()[0]*1000) > 0:
controller.seekSlider.setMaximum(int(length.toFloat()[0]*1000)) controller.seekSlider.setMaximum(int(length.toFloat()[0]*1000))
if not controller.seekSlider.isSliderDown(): 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): def get_supported_file_types(self):
pass pass