forked from openlp/openlp
cleanups, add settings dialog
This commit is contained in:
parent
43a55c7087
commit
578e0fea3f
@ -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(),
|
||||
|
@ -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']
|
||||
|
@ -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)
|
||||
|
@ -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))
|
||||
|
@ -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')
|
||||
|
@ -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:
|
||||
|
@ -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)
|
||||
|
||||
|
@ -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
|
||||
|
Loading…
Reference in New Issue
Block a user