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

update

Browse Source
This commit is contained in:
rimach crichter@web.de 2011-06-05 23:10:49 +02:00
parent 4ab7f93044
commit dbce448da1
15 changed files with 1143 additions and 941 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
openlp/core/lib/htmlbuilder.py
View File

@ -183,7 +183,8 @@ sup {
case 'currentTime': case 'currentTime':
return vid.currentTime; return vid.currentTime;
case 'seek': case 'seek':
vid.currentTime = seekVal; // doesnt work curently
//vid.currentTime = seekVal;
break; break;
} }
} }
@ -327,20 +328,22 @@ sup {
} }
} }
function show_flash(state, path){ // http://www.adobe.com/support/flash/publishexport/scriptingwithflash/scriptingwithflash_03.html
function show_flash(state, path, volume, seekVal){
var text = document.getElementById('flash'); var text = document.getElementById('flash');
var flashMovie = getFlashMovieObject("OpenLPFlashMovie"); var flashMovie = getFlashMovieObject("OpenLPFlashMovie");
var src = "src = 'file:///" + path + "'"; var src = "src = 'file:///" + path + "'";
var view_parm = " wmode='opaque'" + var view_parm = " wmode='opaque'" +
" width='" + window.innerWidth + "'" + " width='" + window.innerWidth + "'" +
" height='" + window.innerHeight + "'"; " height='" + window.innerHeight + "'";
var swf_parm = " autostart='false' loop='false' play='false'" + var swf_parm = " name='OpenLPFlashMovie'" +
" hidden='false' swliveconnect='true'" + " autostart='true' loop='false' play='true'" +
" name='OpenLPFlashMovie'>"; " hidden='false' swliveconnect='true' allowscriptaccess='always'" +
" volume='" + volume + "'";
switch(state){ switch(state){
case 'load': case 'load':
text.innerHTML = "<embed " + src + view_parm + swf_parm + ">"; text.innerHTML = "<embed " + src + view_parm + swf_parm + "/>";
flashMovie = getFlashMovieObject("OpenLPFlashMovie"); flashMovie = getFlashMovieObject("OpenLPFlashMovie");
text.style.visibility = 'visible'; text.style.visibility = 'visible';
flashMovie.Play(); flashMovie.Play();
@ -349,28 +352,29 @@ sup {
text.style.visibility = 'visible'; text.style.visibility = 'visible';
flashMovie.Play(); flashMovie.Play();
break; break;
case 'rewind':
ret = 'rewind';
alert(' Wert: ' + flashMovie.TGetProperty("/", 4));
// flashMovie.TotalFrames()
// PercentLoaded()
// GotoFrame()
break;
case 'pause': case 'pause':
flashMovie.StopPlay(); flashMovie.StopPlay();
text.style.visibility = 'hidden'; text.style.visibility = 'hidden';
break; break;
case 'stop': case 'stop':
flashMovie.StopPlay(); flashMovie.StopPlay();
// flashMovie.GotoFrame(0);
text.style.visibility = 'hidden'; text.style.visibility = 'hidden';
tempHtml = text.innerHTML;
text.innerHTML = '';
text.innerHTML = tempHtml;
break; break;
case 'close': case 'close':
flashMovie.StopPlay(); flashMovie.StopPlay();
text.style.visibility = 'hidden'; text.style.visibility = 'hidden';
break;
text.innerHTML = ''; text.innerHTML = '';
break; break;
case 'length':
return flashMovie.TotalFrames();
case 'currentTime':
return flashMovie.CurrentFrame();
case 'seek':
// flashMovie.GotoFrame(seekVal);
break;
} }
} }

6
openlp/core/lib/plugin.py
View File

@ -244,6 +244,12 @@ class Plugin(QtCore.QObject):
""" """
pass pass
def addControllerItems(self, controller, control_panel):
"""
Create items for all controller Panes
"""
pass
def getSettingsTab(self, parent): def getSettingsTab(self, parent):
""" """
Create a tab for the settings window to display the configurable Create a tab for the settings window to display the configurable

5
openlp/core/lib/pluginmanager.py
View File

@ -187,6 +187,11 @@ class PluginManager(object):
if plugin.status is not PluginStatus.Disabled: if plugin.status is not PluginStatus.Disabled:
plugin.addToolsMenuItem(tools_menu) plugin.addToolsMenuItem(tools_menu)
def hook_controller_items(self, controller, control_panel):
for plugin in self.plugins:
if plugin.status is not PluginStatus.Disabled:
plugin.addControllerItems(controller, control_panel)
def initialise_plugins(self): def initialise_plugins(self):
""" """
Loop through all the plugins and give them an opportunity to Loop through all the plugins and give them an opportunity to

5
openlp/core/ui/mainwindow.py
View File

@ -580,6 +580,11 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
self.pluginManager.hook_export_menu(self.FileExportMenu) self.pluginManager.hook_export_menu(self.FileExportMenu)
# Call the hook method to pull in tools menus. # Call the hook method to pull in tools menus.
self.pluginManager.hook_tools_menu(self.ToolsMenu) self.pluginManager.hook_tools_menu(self.ToolsMenu)
# Call the hook method to pull in plugin Controller items
self.pluginManager.hook_controller_items(
self.previewController, self.previewController.getControlPanel())
self.pluginManager.hook_controller_items(
self.liveController, self.liveController.getControlPanel())
# Call the initialise method to setup plugins. # Call the initialise method to setup plugins.
log.info(u'initialise plugins') log.info(u'initialise plugins')
self.pluginManager.initialise_plugins() self.pluginManager.initialise_plugins()

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

@ -73,7 +73,6 @@ class SlideController(QtGui.QWidget):
self.songEditList = [ self.songEditList = [
u'Edit Song', u'Edit Song',
] ]
self.volume = 10
self.timer_id = 0 self.timer_id = 0
self.songEdit = False self.songEdit = False
self.selectedRow = 0 self.selectedRow = 0
@ -224,20 +223,6 @@ class SlideController(QtGui.QWidget):
'Edit and reload song preview'), 'Edit and reload song preview'),
self.onEditSong) self.onEditSong)
self.controllerLayout.addWidget(self.toolbar) self.controllerLayout.addWidget(self.toolbar)
# Build a Media ToolBar
self.mediabar = OpenLPToolbar(self)
self.mediabar.addToolbarButton(
u'Media Start', u':/slides/media_playback_start.png',
translate('OpenLP.SlideController', 'Start playing media'),
self.onMediaPlay)
self.mediabar.addToolbarButton(
u'Media Pause', u':/slides/media_playback_pause.png',
translate('OpenLP.SlideController', 'Start playing media'),
self.onMediaPause)
self.mediabar.addToolbarButton(
u'Media Stop', u':/slides/media_playback_stop.png',
translate('OpenLP.SlideController', 'Start playing media'),
self.onMediaStop)
if self.isLive: if self.isLive:
# Build the Song Toolbar # Build the Song Toolbar
self.songMenu = QtGui.QToolButton(self.toolbar) self.songMenu = QtGui.QToolButton(self.toolbar)
@ -247,22 +232,6 @@ class SlideController(QtGui.QWidget):
self.songMenu.setMenu(QtGui.QMenu( self.songMenu.setMenu(QtGui.QMenu(
translate('OpenLP.SlideController', 'Go To'), self.toolbar)) translate('OpenLP.SlideController', 'Go To'), self.toolbar))
self.toolbar.makeWidgetsInvisible([u'Song Menu']) self.toolbar.makeWidgetsInvisible([u'Song Menu'])
# Build the seekSlider.
self.seekSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
self.seekSlider.setMaximum(1000)
# Build the volumeSlider.
self.volumeSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
self.volumeSlider.setTickInterval(1)
self.volumeSlider.setTickPosition(QtGui.QSlider.TicksAbove)
self.volumeSlider.setMinimum(0)
self.volumeSlider.setMaximum(10)
self.seekSlider.setGeometry(QtCore.QRect(90, 260, 221, 24))
self.seekSlider.setObjectName(u'seekSlider')
self.mediabar.addToolbarWidget(u'Seek Slider', self.seekSlider)
self.volumeSlider.setGeometry(QtCore.QRect(90, 160, 221, 24))
self.volumeSlider.setObjectName(u'volumeSlider')
self.mediabar.addToolbarWidget(u'Audio Volume', self.volumeSlider)
self.controllerLayout.addWidget(self.mediabar)
# Screen preview area # Screen preview area
self.previewFrame = QtGui.QFrame(self.splitter) self.previewFrame = QtGui.QFrame(self.splitter)
self.previewFrame.setGeometry(QtCore.QRect(0, 0, 300, 300 * self.ratio)) self.previewFrame.setGeometry(QtCore.QRect(0, 0, 300, 300 * self.ratio))
@ -302,10 +271,6 @@ 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)
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: 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)
@ -319,7 +284,6 @@ class SlideController(QtGui.QWidget):
QtCore.SIGNAL(u'doubleClicked(QModelIndex)'), QtCore.SIGNAL(u'doubleClicked(QModelIndex)'),
self.onGoLiveClick) self.onGoLiveClick)
self.toolbar.makeWidgetsInvisible(self.songEditList) self.toolbar.makeWidgetsInvisible(self.songEditList)
self.mediabar.setVisible(False)
if self.isLive: if self.isLive:
self.setLiveHotkeys(self) self.setLiveHotkeys(self)
self.__addActionsToWidget(self.previewListWidget) self.__addActionsToWidget(self.previewListWidget)
@ -366,6 +330,19 @@ class SlideController(QtGui.QWidget):
QtCore.SIGNAL(u'slidecontroller_%s_text_request' % self.typePrefix), QtCore.SIGNAL(u'slidecontroller_%s_text_request' % self.typePrefix),
self.onTextRequest) self.onTextRequest)
def getControlPanel(self):
return self.controllerLayout
def sendToPlugins(self, v1=None, v2=None, v3=None, v4=None, v5=None):
"""
This is the generic function to send signal for control widgets,
created from within other plugins
This function is needed to catch the current controller
"""
sender = self.sender().objectName() or self.sender().text()
controller = self
Receiver.send_message('%s' % sender, [controller, v1, v2, v3, v4, v5])
def setPreviewHotkeys(self, parent=None): def setPreviewHotkeys(self, parent=None):
self.previousItem.setObjectName(u'previousItemPreview') self.previousItem.setObjectName(u'previousItemPreview')
self.nextItem.setObjectName(u'nextItemPreview') self.nextItem.setObjectName(u'nextItemPreview')
@ -523,14 +500,9 @@ class SlideController(QtGui.QWidget):
Allows the Preview toolbar to be customised Allows the Preview toolbar to be customised
""" """
self.toolbar.setVisible(True) self.toolbar.setVisible(True)
self.mediabar.setVisible(False)
self.toolbar.makeWidgetsInvisible(self.songEditList) self.toolbar.makeWidgetsInvisible(self.songEditList)
if item.is_capable(ItemCapabilities.AllowsEdit) and item.from_plugin: if item.is_capable(ItemCapabilities.AllowsEdit) and item.from_plugin:
self.toolbar.makeWidgetsVisible(self.songEditList) self.toolbar.makeWidgetsVisible(self.songEditList)
elif item.is_media():
#self.toolbar.setVisible(False)
self.mediabar.setVisible(True)
# self.volumeSlider.setAudioOutput(self.audio)
def refreshServiceItem(self): def refreshServiceItem(self):
""" """
@ -1089,58 +1061,15 @@ class SlideController(QtGui.QWidget):
""" """
log.debug(u'SlideController onMediaStart') log.debug(u'SlideController onMediaStart')
file = os.path.join(item.get_frame_path(), item.get_frame_title()) file = os.path.join(item.get_frame_path(), item.get_frame_title())
Receiver.send_message(u'media_video', [self, file, self.volume, False]) Receiver.send_message(u'media_video', [self, file, False])
self.volumeSlider.setValue(self.volume)
self.slidePreview.hide() self.slidePreview.hide()
def mediaSeek(self):
"""
Respond to the release of Seek Slider
"""
log.debug(u'SlideController mediaSeek')
self.seekPos = self.seekSlider.value()
Receiver.send_message(u'media_seek', [self, self.seekPos])
def mediaVolume(self):
"""
Respond to the release of Volume Slider
"""
log.debug(u'SlideController mediaVolume')
self.volume = self.volumeSlider.value()
Receiver.send_message(u'media_volume', [self, self.volume])
def onMediaPause(self):
"""
Respond to the Pause from the media Toolbar
"""
log.debug(u'SlideController onMediaPause')
Receiver.send_message(u'media_pause', self)
def onMediaPlay(self):
"""
Respond to the Play from the media Toolbar
"""
log.debug(u'SlideController onMediaPlay')
Receiver.send_message(u'media_play', self)
self.slidePreview.hide()
def onMediaStop(self):
"""
Respond to the Stop from the media Toolbar
"""
log.debug(u'SlideController onMediaStop')
Receiver.send_message(u'media_stop', self)
self.slidePreview.clear()
self.slidePreview.show()
def onMediaClose(self): def onMediaClose(self):
""" """
Respond to a request to close the Video Respond to a request to close the Video
""" """
log.debug(u'SlideController onMediaClose') log.debug(u'SlideController onMediaClose')
Receiver.send_message(u'media_reset', self) Receiver.send_message(u'media_reset', self)
self.slidePreview.clear()
self.slidePreview.show() self.slidePreview.show()
def _resetBlank(self): def _resetBlank(self):

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

@ -24,9 +24,9 @@
# Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Temple Place, Suite 330, Boston, MA 02111-1307 USA #
############################################################################### ###############################################################################
class MediaBackends(object): class MediaAPIs(object):
""" """
An enumeration for possible Backends. An enumeration for possible APIs.
""" """
Webkit = 0 Webkit = 0
Phonon = 1 Phonon = 1
@ -43,10 +43,32 @@ class MediaState(object):
Paused = 4 Paused = 4
Off = 6 Off = 6
class MediaController(object): class MediaType(object):
""" """
Specialiced MediaController class """
to reflect Features of the related backend Audio = 0
Video = 1
Cd = 3
Dvd = 4
class MediaInfo(object):
"""
This class hold the media related infos
"""
file_info = None
volume = 100
isFlash = False
is_background = False
length = 0
start_time = 0
end_time = 0
media_type = MediaType()
class MediaAPI(object):
"""
Specialiced Media API class
to reflect Features of the related API
""" """
def __init__(self, parent): def __init__(self, parent):
self.parent = parent self.parent = parent
@ -57,19 +79,19 @@ class MediaController(object):
self.audio_extensions_list = [] self.audio_extensions_list = []
self.video_extensions_list = [] self.video_extensions_list = []
def setup(self, display, hasAudio): def setup(self, display):
""" """
Create the related widgets for the current display Create the related widgets for the current display
""" """
pass pass
def load(self, display, path, volume, isBackground): def load(self, display):
""" """
Load a new media file and check if it is valid Load a new media file and check if it is valid
""" """
return True return True
def resize(self, display, controller): def resize(self, display):
""" """
If the main display size or position is changed, If the main display size or position is changed,
the media widgets should also resized the media widgets should also resized
@ -118,7 +140,7 @@ class MediaController(object):
""" """
pass pass
def update_ui(self, controller, display): def update_ui(self, display):
""" """
Do some ui related stuff Do some ui related stuff
(e.g. update the seek slider) (e.g. update the seek slider)
@ -128,7 +150,7 @@ class MediaController(object):
@staticmethod @staticmethod
def is_available(): def is_available():
""" """
Check availability of the related backend Check availability of the related API
""" """
return False return False
@ -143,6 +165,6 @@ class MediaController(object):
from mediaitem import MediaMediaItem from mediaitem import MediaMediaItem
from mediatab import MediaTab from mediatab import MediaTab
from mediacontroller import MediaManager from mediamanager import MediaManager
__all__ = ['MediaMediaItem'] __all__ = ['MediaMediaItem']

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

@ -1,356 +0,0 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4
###############################################################################
# OpenLP - Open Source Lyrics Projection #
# --------------------------------------------------------------------------- #
# Copyright (c) 2008-2011 Raoul Snyman #
# Portions copyright (c) 2008-2011 Tim Bentley, Jonathan Corwin, Michael #
# Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, Armin Köhler, #
# Andreas Preikschat, Mattias Põldaru, Christian Richter, Philip Ridout, #
# Maikel Stuivenberg, Martin Thompson, Jon Tibble, Frode Woldsund #
# --------------------------------------------------------------------------- #
# This program is free software; you can redistribute it and/or modify it #
# under the terms of the GNU General Public License as published by the Free #
# Software Foundation; version 2 of the License. #
# #
# This program is distributed in the hope that it will be useful, but WITHOUT #
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or #
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for #
# more details. #
# #
# You should have received a copy of the GNU General Public License along #
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import logging
import sys, os
from PyQt4 import QtCore, QtGui, QtWebKit
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
from vlccontroller import VlcController
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 media manager adds an own class for every type of backend
Currently these are QtWebkit, Phonon and planed Vlc.
"""
def __init__(self, parent):
self.parent = parent
self.backends = {}
self.curDisplayMediaController = {}
#Create Backend Controllers
if WebkitController.is_available():
self.backends[u'Webkit'] = WebkitController(self)
if PhononController.is_available():
self.backends[u'Phonon'] = PhononController(self)
if VlcController.is_available():
self.backends[u'Vlc'] = VlcController(self)
#Timer for video state
self.Timer = QtCore.QTimer()
self.Timer.setInterval(200)
self.withLivePreview = False
#Signals
QtCore.QObject.connect(self.Timer,
QtCore.SIGNAL("timeout()"), self.video_state)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'setup_display'), self.setup_display)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_video'), self.video)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_play'), self.video_play)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_pause'), self.video_pause)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_stop'), self.video_stop)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_seek'), self.video_seek)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_volume'), self.video_volume)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_reset'), self.video_reset)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_hide'), self.video_hide)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_blank'), self.video_blank)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_unblank'), self.video_unblank)
def video_state(self):
"""
Check if there is an assigned media backend and do some
updating stuff (e.g. update the UI)
"""
isAnyonePlaying = False
if len(self.curDisplayMediaController.keys()) == 0:
self.Timer.stop()
else:
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)
else:
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):
"""
After a new display is configured, all media related widget
will be created too
"""
hasAudio = True
if not self.withLivePreview and \
display == self.parent.liveController.previewDisplay:
return
if display == self.parent.previewController.previewDisplay or \
display == self.parent.liveController.previewDisplay:
hasAudio = False
for backend in self.backends.values():
backend.setup(display, hasAudio)
def resize(self, controller):
"""
After Mainwindow changes or Splitter moved all related media
widgets have to be resized
"""
for display in self.curDisplayMediaController.keys():
if display == self.parent.previewController.previewDisplay or \
display == self.parent.liveController.previewDisplay:
display.resize(display.parent.slidePreview.size())
self.curDisplayMediaController[display].resize(display, controller)
def video(self, msg):
"""
Loads and starts a video to run with the option of sound
"""
controller = msg[0]
videoPath = os.path.abspath(msg[1])
volume = msg[2]
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 self.withLivePreview:
display = controller.previewDisplay
if self.check_file_type(display, videoPath, False):
#check size of all media_widgets
self.resize(controller)
self.curDisplayMediaController[display] \
.load(display, videoPath, volume, isBackground)
display = controller.display
if self.check_file_type(display, videoPath, isBackground):
#check size of all media_widgets
self.resize(controller)
isValid = self.curDisplayMediaController[display] \
.load(display, videoPath, volume, isBackground)
else:
display = controller.previewDisplay
if self.check_file_type(display, videoPath, isBackground):
#check size of all media_widgets
self.resize(controller)
isValid = self.curDisplayMediaController[display] \
.load(display, videoPath, volume, isBackground)
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
# controller.display.webLoaded = True
#now start playing
self.video_play(controller)
def check_file_type(self, display, videoPath, isBackground):
"""
Used to choose the right media backend type
from the prioritized backend list
"""
usedBackends = QtCore.QSettings().value(u'media/backends',
QtCore.QVariant(u'Webkit')).toString().split(u',')
media_path = QtCore.QFileInfo(videoPath)
if media_path.isFile():
suffix = u'*.%s' % media_path.suffix()
for title in usedBackends:
backend = self.backends[str(title)]
if suffix in backend.video_extensions_list:
if isBackground:
if backend.canBackground:
self.curDisplayMediaController[display] = backend
return True
else:
self.curDisplayMediaController[display] = backend
return True
return False
# # Special FileType Check
# if videoPath.endswith(u'.swf') or isBackground:
# self.curDisplayMediaController[display] = self.backends[u'Webkit']
# else:
# # search extension in available backends
# # currently only use the first available backend
# self.curDisplayMediaController[display] = self.backends[str(usedBackends[0])]
# return True
def video_play(self, controller):
"""
Responds to the request to play a loaded video
"""
log.debug(u'video_play')
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].play(display)
# show screen
if not self.Timer.isActive():
self.Timer.start()
def video_pause(self, controller):
"""
Responds to the request to pause a loaded video
"""
log.debug(u'videoPause')
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].pause(display)
def video_stop(self, controller):
"""
Responds to the request to stop a loaded video
"""
log.debug(u'video_stop')
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].stop(display)
self.curDisplayMediaController[display].set_visible(display, False)
def video_volume(self, msg):
"""
Changes the volume of a running video
"""
controller = msg[0]
volume = msg[1]
log.debug(u'video_volume %d' % volume)
vol = float(volume) / float(10)
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].volume(display, vol)
def video_finished(self):
"""
Blank the Video when it has finished so the final frame is not left
hanging
"""
display.videoStop()
display.hideDisplay(HideMode.Blank)
display.videoHide = True
def video_tick(self, tick):
"""
Triggered on video tick every 200 milli seconds
"""
if tick > display.serviceItem.end_time * 1000:
display.videoFinished()
def video_seek(self, msg):
"""
Responds to the request to change the seek Slider of a loaded video
"""
log.debug(u'video_seek')
controller = msg[0]
seekVal = msg[1]
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].seek(display, seekVal)
def video_reset(self, controller):
"""
Responds to the request to reset a loaded video
"""
log.debug(u'video_reset')
for display in self.curDisplayMediaController.keys():
if display.parent == controller:
self.curDisplayMediaController[display].reset(display)
del self.curDisplayMediaController[display]
def video_hide(self, msg):
"""
Hide the related video Widget
"""
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:
self.curDisplayMediaController[display].pause(display)
self.curDisplayMediaController[display] \
.set_visible(display, False)
def video_blank(self, msg):
"""
Blank the related video Widget
"""
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:
self.curDisplayMediaController[display].pause(display)
self.curDisplayMediaController[display] \
.set_visible(display, False)
def video_unblank(self, msg):
"""
Unblank the related video Widget
"""
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:
self.curDisplayMediaController[display].play(display)
self.curDisplayMediaController[display] \
.set_visible(display, True)
def get_audio_extensions_list(self):
audio_list = []
for backend in self.backends.values():
for item in backend.audio_extensions_list:
if not item in audio_list:
audio_list.append(item)
return audio_list
def get_video_extensions_list(self):
video_list = []
for backend in self.backends.values():
for item in backend.video_extensions_list:
if not item in video_list:
video_list.append(item)
return video_list

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

@ -137,7 +137,7 @@ class MediaMediaItem(MediaManagerItem):
ItemCapabilities.AllowsVariableStartTime) ItemCapabilities.AllowsVariableStartTime)
service_item.title = unicode(self.plugin.nameStrings[u'singular']) service_item.title = unicode(self.plugin.nameStrings[u'singular'])
service_item.add_capability(ItemCapabilities.RequiresMedia) service_item.add_capability(ItemCapabilities.RequiresMedia)
#Receiver.send_message(u'media_video', [self.parent.liveController, filename, 0, False]) #Receiver.send_message(u'media_video', [self.parent.liveController, filename, False])
# force a non-existent theme # force a non-existent theme
service_item.theme = -1 service_item.theme = -1
frame = u':/media/image_clapperboard.png' frame = u':/media/image_clapperboard.png'

385
openlp/plugins/media/lib/mediamanager.py Normal file
View File

@ -0,0 +1,385 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4
###############################################################################
# OpenLP - Open Source Lyrics Projection #
# --------------------------------------------------------------------------- #
# Copyright (c) 2008-2011 Raoul Snyman #
# Portions copyright (c) 2008-2011 Tim Bentley, Jonathan Corwin, Michael #
# Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, Armin Köhler, #
# Andreas Preikschat, Mattias Põldaru, Christian Richter, Philip Ridout, #
# Maikel Stuivenberg, Martin Thompson, Jon Tibble, Frode Woldsund #
# --------------------------------------------------------------------------- #
# This program is free software; you can redistribute it and/or modify it #
# under the terms of the GNU General Public License as published by the Free #
# Software Foundation; version 2 of the License. #
# #
# This program is distributed in the hope that it will be useful, but WITHOUT #
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or #
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for #
# more details. #
# #
# You should have received a copy of the GNU General Public License along #
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import logging
import sys, os,time
from PyQt4 import QtCore, QtGui, QtWebKit
from openlp.core.lib import OpenLPToolbar, Receiver, translate
from openlp.core.lib.ui import UiStrings, critical_error_message_box
from openlp.plugins.media.lib import MediaAPI, MediaState, MediaInfo
from webkitapi import WebkitAPI
from phononapi import PhononAPI
from vlcapi import VlcAPI
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 media manager adds an own class for every API
Currently these are QtWebkit, Phonon and planed Vlc.
Manager
- different API classes with specialised Access functions
Controller
- have general and API specific control Elements
- have one or more displays (Preview, Live, ...) with different settings
Display
- have API-Specific Display Elements
- have media info for current media
"""
def __init__(self, parent):
self.parent = parent
self.APIs = {}
self.controller = []
self.curDisplayMediaAPI = {}
#Create API Controllers
if WebkitAPI.is_available():
self.APIs[u'Webkit'] = WebkitAPI(self)
if PhononAPI.is_available():
self.APIs[u'Phonon'] = PhononAPI(self)
if VlcAPI.is_available():
self.APIs[u'Vlc'] = VlcAPI(self)
#Timer for video state
self.Timer = QtCore.QTimer()
self.Timer.setInterval(200)
self.withLivePreview = False
#Signals
QtCore.QObject.connect(self.Timer,
QtCore.SIGNAL("timeout()"), self.video_state)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'setup_display'), self.setup_display)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_video'), self.video)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'Media Start'), self.video_play)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'Media Pause'), self.video_pause)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'Media Stop'), self.video_stop)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'seekSlider'), self.video_seek)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'volumeSlider'), self.video_volume)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_reset'), self.video_reset)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_hide'), self.video_hide)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_blank'), self.video_blank)
QtCore.QObject.connect(Receiver.get_receiver(),
QtCore.SIGNAL(u'media_unblank'), self.video_unblank)
def video_state(self):
"""
Check if there is an assigned media API and do some
updating stuff (e.g. update the UI)
"""
isAnyonePlaying = False
if len(self.curDisplayMediaAPI.keys()) == 0:
self.Timer.stop()
else:
for display in self.curDisplayMediaAPI.keys():
self.curDisplayMediaAPI[display].update_ui(display)
if self.curDisplayMediaAPI[display] \
.state == MediaState.Playing:
isAnyonePlaying = True
if not isAnyonePlaying:
self.Timer.stop()
def addControllerItems(self, controller, control_panel):
self.controller.append(controller)
self.setup_generic_controls(controller, control_panel)
for api in self.APIs.values():
api.setup_controls(controller, control_panel)
def setup_generic_controls(self, controller, control_panel):
controller.media_info = MediaInfo()
# Build a Media ToolBar
controller.mediabar = OpenLPToolbar(controller)
controller.mediabar.addToolbarButton(
u'Media Start', u':/slides/media_playback_start.png',
translate('OpenLP.SlideController', 'Start playing media'),
controller.sendToPlugins)
controller.mediabar.addToolbarButton(
u'Media Pause', u':/slides/media_playback_pause.png',
translate('OpenLP.SlideController', 'Start playing media'),
controller.sendToPlugins)
controller.mediabar.addToolbarButton(
u'Media Stop', u':/slides/media_playback_stop.png',
translate('OpenLP.SlideController', 'Start playing media'),
controller.sendToPlugins)
# Build the seekSlider.
controller.seekSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
controller.seekSlider.setMaximum(1000)
# Build the volumeSlider.
controller.volumeSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
controller.volumeSlider.setTickInterval(10)
controller.volumeSlider.setTickPosition(QtGui.QSlider.TicksAbove)
controller.volumeSlider.setMinimum(0)
controller.volumeSlider.setMaximum(100)
controller.volumeSlider.setValue(controller.media_info.volume)
controller.seekSlider.setGeometry(QtCore.QRect(90, 260, 221, 24))
controller.seekSlider.setObjectName(u'seekSlider')
controller.mediabar.addToolbarWidget(u'Seek Slider', controller.seekSlider)
controller.volumeSlider.setGeometry(QtCore.QRect(90, 160, 221, 24))
controller.volumeSlider.setObjectName(u'volumeSlider')
controller.mediabar.addToolbarWidget(u'Audio Volume', controller.volumeSlider)
control_panel.addWidget(controller.mediabar)
controller.mediabar.setVisible(False)
#Signals
QtCore.QObject.connect(controller.seekSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), controller.sendToPlugins)
QtCore.QObject.connect(controller.volumeSlider,
QtCore.SIGNAL(u'sliderMoved(int)'), controller.sendToPlugins)
def setup_display(self, display):
"""
After a new display is configured, all media related widget
will be created too
"""
display.hasAudio = True
if not self.withLivePreview and \
display == self.parent.liveController.previewDisplay:
return
if display == self.parent.previewController.previewDisplay or \
display == self.parent.liveController.previewDisplay:
display.hasAudio = False
for api in self.APIs.values():
api.setup(display)
def set_controls_visible(self, controller, value):
# Generic controls
controller.mediabar.setVisible(value)
# Special controls
# for api in self.APIs.values():
# api.setup_controls(controller, control_panel)
def resize(self, display, api):
"""
After Mainwindow changes or Splitter moved all related media
widgets have to be resized
"""
if display == self.parent.previewController.previewDisplay or \
display == self.parent.liveController.previewDisplay:
display.resize(display.parent.slidePreview.size())
api.resize(display)
def video(self, msg):
"""
Loads and starts a video to run with the option of sound
"""
log.debug(u'video')
controller = msg[0]
isValid = False
# stop running videos
self.video_reset(controller)
controller.media_info = MediaInfo()
controller.media_info.volume = controller.volumeSlider.value()
controller.media_info.file_info = QtCore.QFileInfo(msg[1])
controller.media_info.is_background = msg[2]
if controller.isLive:
if self.withLivePreview:
display = controller.previewDisplay
isValid = self.check_file_type(display)
display = controller.display
isValid = self.check_file_type(display)
else:
display = controller.previewDisplay
isValid = self.check_file_type(display)
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
#now start playing
self.video_play([controller])
# self.video_pause([controller])
# self.video_seek([controller, 0])
# self.video_play([controller])
self.set_controls_visible(controller, True)
def check_file_type(self, display):
"""
Used to choose the right media API type
from the prioritized API list
"""
controller = display.parent
apiSettings = str(QtCore.QSettings().value(u'media/apis',
QtCore.QVariant(u'Webkit')).toString())
usedAPIs = apiSettings.split(u',')
if controller.media_info.file_info.isFile():
suffix = u'*.%s' % controller.media_info.file_info.suffix()
for title in usedAPIs:
api = self.APIs[title]
if suffix in api.video_extensions_list:
if not controller.media_info.is_background or \
controller.media_info.is_background and api.canBackground:
self.resize(display, api)
if api.load(display):
print api
self.curDisplayMediaAPI[display] = api
return True
# no valid api found
return False
def video_play(self, msg):
"""
Responds to the request to play a loaded video
"""
log.debug(u'video_play')
controller = msg[0]
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
self.curDisplayMediaAPI[display].play(display)
# Start Timer for ui updates
if not self.Timer.isActive():
self.Timer.start()
def video_pause(self, msg):
"""
Responds to the request to pause a loaded video
"""
log.debug(u'videoPause')
controller = msg[0]
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
self.curDisplayMediaAPI[display].pause(display)
def video_stop(self, msg):
"""
Responds to the request to stop a loaded video
"""
log.debug(u'video_stop')
controller = msg[0]
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
self.curDisplayMediaAPI[display].stop(display)
self.curDisplayMediaAPI[display].set_visible(display, False)
def video_volume(self, msg):
"""
Changes the volume of a running video
"""
controller = msg[0]
vol = msg[1]
log.debug(u'video_volume %d' % vol)
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
self.curDisplayMediaAPI[display].volume(display, vol)
def video_seek(self, msg):
"""
Responds to the request to change the seek Slider of a loaded video
"""
log.debug(u'video_seek')
controller = msg[0]
seekVal = msg[1]
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
self.curDisplayMediaAPI[display].seek(display, seekVal)
def video_reset(self, controller):
"""
Responds to the request to reset a loaded video
"""
log.debug(u'video_reset')
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
self.curDisplayMediaAPI[display].reset(display)
del self.curDisplayMediaAPI[display]
self.set_controls_visible(controller, False)
def video_hide(self, msg):
"""
Hide the related video Widget
"""
isLive = msg[1]
if isLive:
controller = self.parent.liveController
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
if self.curDisplayMediaAPI[display] \
.state == MediaState.Playing:
self.curDisplayMediaAPI[display].pause(display)
self.curDisplayMediaAPI[display] \
.set_visible(display, False)
def video_blank(self, msg):
"""
Blank the related video Widget
"""
isLive = msg[1]
if isLive:
controller = self.parent.liveController
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
if self.curDisplayMediaAPI[display] \
.state == MediaState.Playing:
self.curDisplayMediaAPI[display].pause(display)
self.curDisplayMediaAPI[display] \
.set_visible(display, False)
def video_unblank(self, msg):
"""
Unblank the related video Widget
"""
Receiver.send_message(u'maindisplay_show')
isLive = msg[1]
if isLive:
controller = self.parent.liveController
for display in self.curDisplayMediaAPI.keys():
if display.parent == controller:
if self.curDisplayMediaAPI[display] \
.state == MediaState.Paused:
self.curDisplayMediaAPI[display].play(display)
self.curDisplayMediaAPI[display] \
.set_visible(display, True)
def get_audio_extensions_list(self):
audio_list = []
for api in self.APIs.values():
for item in api.audio_extensions_list:
if not item in audio_list:
audio_list.append(item)
return audio_list
def get_video_extensions_list(self):
video_list = []
for api in self.APIs.values():
for item in api.video_extensions_list:
if not item in video_list:
video_list.append(item)
return video_list

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

@ -38,52 +38,52 @@ class MediaTab(SettingsTab):
def setupUi(self): def setupUi(self):
self.setObjectName(u'MediaTab') self.setObjectName(u'MediaTab')
SettingsTab.setupUi(self) SettingsTab.setupUi(self)
self.mediaBackendsGroupBox = QtGui.QGroupBox(self.leftColumn) self.mediaAPIsGroupBox = QtGui.QGroupBox(self.leftColumn)
self.mediaBackendsGroupBox.setObjectName(u'mediaBackendsGroupBox') self.mediaAPIsGroupBox.setObjectName(u'mediaAPIsGroupBox')
self.mediaBackendLayout = QtGui.QVBoxLayout(self.mediaBackendsGroupBox) self.mediaApiLayout = QtGui.QVBoxLayout(self.mediaAPIsGroupBox)
self.mediaBackendLayout.setObjectName(u'mediaBackendLayout') self.mediaApiLayout.setObjectName(u'mediaApiLayout')
self.usePhononCheckBox = QtGui.QCheckBox(self.mediaBackendsGroupBox) self.usePhononCheckBox = QtGui.QCheckBox(self.mediaAPIsGroupBox)
self.usePhononCheckBox.setObjectName(u'usePhononCheckBox') self.usePhononCheckBox.setObjectName(u'usePhononCheckBox')
self.mediaBackendLayout.addWidget(self.usePhononCheckBox) self.mediaApiLayout.addWidget(self.usePhononCheckBox)
self.useVlcCheckBox = QtGui.QCheckBox(self.mediaBackendsGroupBox) self.useVlcCheckBox = QtGui.QCheckBox(self.mediaAPIsGroupBox)
self.useVlcCheckBox.setObjectName(u'useVlcCheckBox') self.useVlcCheckBox.setObjectName(u'useVlcCheckBox')
self.mediaBackendLayout.addWidget(self.useVlcCheckBox) self.mediaApiLayout.addWidget(self.useVlcCheckBox)
self.leftLayout.addWidget(self.mediaBackendsGroupBox) self.leftLayout.addWidget(self.mediaAPIsGroupBox)
self.backendOrderGroupBox = QtGui.QGroupBox(self.leftColumn) self.apiOrderGroupBox = QtGui.QGroupBox(self.leftColumn)
self.backendOrderGroupBox.setObjectName(u'backendOrderGroupBox') self.apiOrderGroupBox.setObjectName(u'apiOrderGroupBox')
self.backendOrderLayout = QtGui.QVBoxLayout(self.backendOrderGroupBox) self.apiOrderLayout = QtGui.QVBoxLayout(self.apiOrderGroupBox)
self.backendOrderLayout.setObjectName(u'backendOrderLayout') self.apiOrderLayout.setObjectName(u'apiOrderLayout')
self.backendOrderlistWidget = QtGui.QListWidget( \ self.apiOrderlistWidget = QtGui.QListWidget( \
self.backendOrderGroupBox) self.apiOrderGroupBox)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum,
QtGui.QSizePolicy.Expanding) QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0) sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0) sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.backendOrderlistWidget. \ sizePolicy.setHeightForWidth(self.apiOrderlistWidget. \
sizePolicy().hasHeightForWidth()) sizePolicy().hasHeightForWidth())
self.backendOrderlistWidget.setSizePolicy(sizePolicy) self.apiOrderlistWidget.setSizePolicy(sizePolicy)
self.backendOrderlistWidget.setVerticalScrollBarPolicy( \ self.apiOrderlistWidget.setVerticalScrollBarPolicy( \
QtCore.Qt.ScrollBarAsNeeded) QtCore.Qt.ScrollBarAsNeeded)
self.backendOrderlistWidget.setHorizontalScrollBarPolicy( \ self.apiOrderlistWidget.setHorizontalScrollBarPolicy( \
QtCore.Qt.ScrollBarAlwaysOff) QtCore.Qt.ScrollBarAlwaysOff)
self.backendOrderlistWidget.setEditTriggers( \ self.apiOrderlistWidget.setEditTriggers( \
QtGui.QAbstractItemView.NoEditTriggers) QtGui.QAbstractItemView.NoEditTriggers)
self.backendOrderlistWidget.setObjectName(u'backendOrderlistWidget') self.apiOrderlistWidget.setObjectName(u'apiOrderlistWidget')
self.backendOrderLayout.addWidget(self.backendOrderlistWidget) self.apiOrderLayout.addWidget(self.apiOrderlistWidget)
self.orderingButtonsWidget = QtGui.QWidget(self.backendOrderGroupBox) self.orderingButtonsWidget = QtGui.QWidget(self.apiOrderGroupBox)
self.orderingButtonsWidget.setObjectName(u'orderingButtonsWidget') self.orderingButtonsWidget.setObjectName(u'orderingButtonsWidget')
self.orderingButtonLayout = QtGui.QHBoxLayout(self.orderingButtonsWidget) self.orderingButtonLayout = QtGui.QHBoxLayout(self.orderingButtonsWidget)
self.orderingButtonLayout.setObjectName(u'orderingButtonLayout') self.orderingButtonLayout.setObjectName(u'orderingButtonLayout')
self.orderingDownButton = QtGui.QPushButton(self.orderingButtonsWidget) self.orderingDownButton = QtGui.QPushButton(self.orderingButtonsWidget)
self.orderingDownButton.setObjectName(u'orderingDownButton') self.orderingDownButton.setObjectName(u'orderingDownButton')
self.orderingButtonLayout.addWidget(self.orderingDownButton) self.orderingButtonLayout.addWidget(self.orderingDownButton)
self.orderingUpButton = QtGui.QPushButton(self.backendOrderGroupBox) self.orderingUpButton = QtGui.QPushButton(self.apiOrderGroupBox)
self.orderingUpButton.setObjectName(u'orderingUpButton') self.orderingUpButton.setObjectName(u'orderingUpButton')
self.orderingButtonLayout.addWidget(self.orderingUpButton) self.orderingButtonLayout.addWidget(self.orderingUpButton)
self.backendOrderLayout.addWidget(self.orderingButtonsWidget) self.apiOrderLayout.addWidget(self.orderingButtonsWidget)
self.leftLayout.addWidget(self.backendOrderGroupBox) self.leftLayout.addWidget(self.apiOrderGroupBox)
self.leftLayout.addStretch() self.leftLayout.addStretch()
self.rightLayout.addStretch() self.rightLayout.addStretch()
QtCore.QObject.connect(self.usePhononCheckBox, QtCore.QObject.connect(self.usePhononCheckBox,
@ -98,14 +98,14 @@ class MediaTab(SettingsTab):
QtCore.SIGNAL(u'pressed()'), self.onOrderingDownButtonPressed) QtCore.SIGNAL(u'pressed()'), self.onOrderingDownButtonPressed)
def retranslateUi(self): def retranslateUi(self):
self.mediaBackendsGroupBox.setTitle( self.mediaAPIsGroupBox.setTitle(
translate('MediaPlugin.MediaTab', 'Media Backends')) translate('MediaPlugin.MediaTab', 'Media APIs'))
self.usePhononCheckBox.setText( self.usePhononCheckBox.setText(
translate('MediaPlugin.MediaTab', 'use Phonon')) translate('MediaPlugin.MediaTab', 'use Phonon'))
self.useVlcCheckBox.setText( self.useVlcCheckBox.setText(
translate('MediaPlugin.MediaTab', 'use Vlc')) translate('MediaPlugin.MediaTab', 'use Vlc'))
self.backendOrderGroupBox.setTitle( self.apiOrderGroupBox.setTitle(
translate('MediaPlugin.MediaTab', 'Backends Order')) translate('MediaPlugin.MediaTab', 'API Order'))
self.orderingDownButton.setText( self.orderingDownButton.setText(
translate('MediaPlugin.MediaTab', 'Down')) translate('MediaPlugin.MediaTab', 'Down'))
self.orderingUpButton.setText( self.orderingUpButton.setText(
@ -114,61 +114,61 @@ class MediaTab(SettingsTab):
def onUsePhononCheckBoxChanged(self, check_state): def onUsePhononCheckBoxChanged(self, check_state):
if check_state == QtCore.Qt.Checked: if check_state == QtCore.Qt.Checked:
self.usePhonon = True self.usePhonon = True
if u'Phonon' not in self.usedBackends: if u'Phonon' not in self.usedAPIs:
self.usedBackends.append(u'Phonon') self.usedAPIs.append(u'Phonon')
else: else:
self.usePhonon = False self.usePhonon = False
self.usedBackends.takeAt(self.usedBackends.indexOf(u'Phonon')) self.usedAPIs.takeAt(self.usedAPIs.indexOf(u'Phonon'))
self.updateBackendList() self.updateApiList()
def onUseVlcCheckBoxChanged(self, check_state): def onUseVlcCheckBoxChanged(self, check_state):
if check_state == QtCore.Qt.Checked: if check_state == QtCore.Qt.Checked:
self.useVlc = True self.useVlc = True
if u'Vlc' not in self.usedBackends: if u'Vlc' not in self.usedAPIs:
self.usedBackends.append(u'Vlc') self.usedAPIs.append(u'Vlc')
else: else:
self.useVlc = False self.useVlc = False
self.usedBackends.takeAt(self.usedBackends.indexOf(u'Vlc')) self.usedAPIs.takeAt(self.usedAPIs.indexOf(u'Vlc'))
self.updateBackendList() self.updateApiList()
def updateBackendList(self): def updateApiList(self):
self.backendOrderlistWidget.clear() self.apiOrderlistWidget.clear()
for backend in self.usedBackends: for api in self.usedAPIs:
self.backendOrderlistWidget.addItem(backend) self.apiOrderlistWidget.addItem(api)
def onOrderingUpButtonPressed(self): def onOrderingUpButtonPressed(self):
currentRow = self.backendOrderlistWidget.currentRow() currentRow = self.apiOrderlistWidget.currentRow()
if currentRow > 0: if currentRow > 0:
item = self.backendOrderlistWidget.takeItem(currentRow) item = self.apiOrderlistWidget.takeItem(currentRow)
self.backendOrderlistWidget.insertItem(currentRow-1, item) self.apiOrderlistWidget.insertItem(currentRow-1, item)
self.backendOrderlistWidget.setCurrentRow(currentRow-1) self.apiOrderlistWidget.setCurrentRow(currentRow-1)
self.usedBackends.move(currentRow, currentRow-1) self.usedAPIs.move(currentRow, currentRow-1)
def onOrderingDownButtonPressed(self): def onOrderingDownButtonPressed(self):
currentRow = self.backendOrderlistWidget.currentRow() currentRow = self.apiOrderlistWidget.currentRow()
if currentRow < self.backendOrderlistWidget.count()-1: if currentRow < self.apiOrderlistWidget.count()-1:
item = self.backendOrderlistWidget.takeItem(currentRow) item = self.apiOrderlistWidget.takeItem(currentRow)
self.backendOrderlistWidget.insertItem(currentRow+1, item) self.apiOrderlistWidget.insertItem(currentRow+1, item)
self.backendOrderlistWidget.setCurrentRow(currentRow+1) self.apiOrderlistWidget.setCurrentRow(currentRow+1)
self.usedBackends.move(currentRow, currentRow+1) self.usedAPIs.move(currentRow, currentRow+1)
def load(self): def load(self):
self.usedBackends = QtCore.QSettings().value( self.usedAPIs = QtCore.QSettings().value(
self.settingsSection + u'/backends', self.settingsSection + u'/apis',
QtCore.QVariant(u'Webkit')).toString().split(u',') QtCore.QVariant(u'Webkit')).toString().split(u',')
self.useWebkit = u'Webkit' in self.usedBackends self.useWebkit = u'Webkit' in self.usedAPIs
self.usePhonon = u'Phonon' in self.usedBackends self.usePhonon = u'Phonon' in self.usedAPIs
self.useVlc = u'Vlc' in self.usedBackends self.useVlc = u'Vlc' in self.usedAPIs
self.usePhononCheckBox.setChecked(self.usePhonon) self.usePhononCheckBox.setChecked(self.usePhonon)
self.useVlcCheckBox.setChecked(self.useVlc) self.useVlcCheckBox.setChecked(self.useVlc)
self.updateBackendList() self.updateApiList()
def save(self): def save(self):
oldBackendString = QtCore.QSettings().value( oldApiString = QtCore.QSettings().value(
self.settingsSection + u'/backends', self.settingsSection + u'/apis',
QtCore.QVariant(u'Webkit')).toString() QtCore.QVariant(u'Webkit')).toString()
newBackendString = self.usedBackends.join(u',') newApiString = self.usedAPIs.join(u',')
if oldBackendString != newBackendString: if oldApiString != newApiString:
QtCore.QSettings().setValue(self.settingsSection + u'/backends', QtCore.QSettings().setValue(self.settingsSection + u'/apis',
QtCore.QVariant(newBackendString)) QtCore.QVariant(newApiString))
Receiver.send_message(u'config_screen_changed') Receiver.send_message(u'config_screen_changed')

54
openlp/plugins/media/lib/phononcontroller.py → openlp/plugins/media/lib/phononapi.py
View File

@ -33,18 +33,18 @@ from PyQt4 import QtCore, QtGui
from PyQt4.phonon import Phonon from PyQt4.phonon import Phonon
from openlp.core.lib import Receiver from openlp.core.lib import Receiver
from openlp.plugins.media.lib import MediaController, MediaState from openlp.plugins.media.lib import MediaAPI, MediaState
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
class PhononController(MediaController): class PhononAPI(MediaAPI):
""" """
Specialiced MediaController class Specialiced MediaAPI class
to reflect Features of the Phonon backend to reflect Features of the Phonon API
""" """
def __init__(self, parent): def __init__(self, parent):
MediaController.__init__(self, parent) MediaAPI.__init__(self, parent)
self.parent = parent self.parent = parent
self.additional_extensions = { self.additional_extensions = {
u'audio/ac3': [u'.ac3'], u'audio/ac3': [u'.ac3'],
@ -59,6 +59,7 @@ class PhononController(MediaController):
u'video/x-flv': [u'.flv'], u'video/x-flv': [u'.flv'],
u'video/x-matroska': [u'.mpv', u'.mkv'], u'video/x-matroska': [u'.mpv', u'.mkv'],
u'video/x-wmv': [u'.wmv'], u'video/x-wmv': [u'.wmv'],
u'video/x-mpg': [u'.mpg'],
u'video/x-ms-wmv': [u'.wmv']} u'video/x-ms-wmv': [u'.wmv']}
mimetypes.init() mimetypes.init()
for mimetype in Phonon.BackendCapabilities.availableMimeTypes(): for mimetype in Phonon.BackendCapabilities.availableMimeTypes():
@ -90,7 +91,10 @@ class PhononController(MediaController):
log.info(u'MediaPlugin: %s additional extensions: %s' % (mimetype, log.info(u'MediaPlugin: %s additional extensions: %s' % (mimetype,
u' '.join(self.additional_extensions[mimetype]))) u' '.join(self.additional_extensions[mimetype])))
def setup(self, display, hasAudio): def setup_controls(self, controller, control_panel):
pass
def setup(self, display):
display.phononWidget = Phonon.VideoWidget(display) display.phononWidget = Phonon.VideoWidget(display)
display.phononWidget.setVisible(False) display.phononWidget.setVisible(False)
display.phononWidget.resize(display.size()) display.phononWidget.resize(display.size())
@ -126,13 +130,18 @@ class PhononController(MediaController):
u'video/x-wmv': [u'.wmv'], u'video/x-wmv': [u'.wmv'],
u'video/x-ms-wmv': [u'.wmv']} u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume, isBackground): def load(self, display):
log.debug(u'load vid in Phonon Controller') log.debug(u'load vid in Phonon Controller')
controller = display.parent
volume = controller.media_info.volume
path = controller.media_info.file_info.absoluteFilePath()
display.mediaObject.setCurrentSource(Phonon.MediaSource(path)) display.mediaObject.setCurrentSource(Phonon.MediaSource(path))
if not self.mediaStateWait(display, Phonon.StoppedState): if not self.mediaStateWait(display, Phonon.StoppedState):
return False return False
vol = float(volume) / float(10) vol = float(volume) / float(10)
display.audio.setVolume(vol) display.audio.setVolume(vol)
#self.info.start_time = 10000
#self.info.end_time = 20000
return True return True
def mediaStateWait(self, display, mediaState): def mediaStateWait(self, display, mediaState):
@ -149,12 +158,13 @@ class PhononController(MediaController):
return False return False
return True return True
def resize(self, display, controller): def resize(self, display):
display.phononWidget.resize(display.size()) display.phononWidget.resize(display.size())
def play(self, display): def play(self, display):
self.set_visible(display, True) #self.set_visible(display, True)
vol = float(display.parent.volume) / float(10) controller = display.parent
vol = float(controller.media_info.volume) / float(10)
display.audio.setVolume(vol) display.audio.setVolume(vol)
display.mediaObject.play() display.mediaObject.play()
self.state = MediaState.Playing self.state = MediaState.Playing
@ -168,6 +178,8 @@ class PhononController(MediaController):
self.state = MediaState.Stopped self.state = MediaState.Stopped
def volume(self, display, vol): def volume(self, display, vol):
# 1.0 is the highest value
vol = float(vol) / float(100)
display.audio.setVolume(vol) display.audio.setVolume(vol)
def seek(self, display, seekVal): def seek(self, display, seekVal):
@ -183,16 +195,20 @@ class PhononController(MediaController):
if self.hasOwnWidget: if self.hasOwnWidget:
display.phononWidget.setVisible(status) display.phononWidget.setVisible(status)
def update_ui(self, controller, display): def update_ui(self, display):
controller.seekSlider.setMaximum(display.mediaObject.totalTime()) controller = display.parent
if display.serviceItem.end_time > 0: controller.media_info.length = display.mediaObject.totalTime()
if display.mediaObject.currentTime() > \ controller.seekSlider.setMaximum(controller.media_info.length)
display.serviceItem.end_time: if controller.media_info.start_time > 0:
self.stop(display)
if display.serviceItem.start_time > 0:
if display.mediaObject.currentTime() < \ if display.mediaObject.currentTime() < \
display.serviceItem.start_time: controller.media_info.start_time:
self.seek(display, self.serviceItem.start_time * 1000) self.seek(display, controller.media_info.start_time)
self.set_visible(display, True)
if controller.media_info.end_time > 0:
if display.mediaObject.currentTime() > \
controller.media_info.end_time:
self.stop(display)
self.set_visible(display, False)
if not controller.seekSlider.isSliderDown(): if not controller.seekSlider.isSliderDown():
controller.seekSlider.setSliderPosition( \ controller.seekSlider.setSliderPosition( \
display.mediaObject.currentTime()) display.mediaObject.currentTime())

789
openlp/plugins/media/lib/vlc.py
View File

File diff suppressed because it is too large Load Diff

48
openlp/plugins/media/lib/vlccontroller.py → openlp/plugins/media/lib/vlcapi.py
View File

@ -26,7 +26,7 @@
############################################################################### ###############################################################################
import logging import logging
import sys import sys, os
from datetime import datetime from datetime import datetime
try: try:
import vlc import vlc
@ -34,17 +34,17 @@ except:
pass pass
from PyQt4 import QtCore, QtGui from PyQt4 import QtCore, QtGui
from openlp.core.lib import Receiver from openlp.core.lib import Receiver
from openlp.plugins.media.lib import MediaController, MediaState from openlp.plugins.media.lib import MediaAPI, MediaState
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
class VlcController(MediaController): class VlcAPI(MediaAPI):
""" """
Specialiced MediaController class Specialiced MediaAPI class
to reflect Features of the Vlc backend to reflect Features of the Vlc API
""" """
def __init__(self, parent): def __init__(self, parent):
MediaController.__init__(self, parent) MediaAPI.__init__(self, parent)
self.parent = parent self.parent = parent
self.video_extensions_list = [ self.video_extensions_list = [
u'*.3gp' u'*.3gp'
@ -70,10 +70,13 @@ class VlcController(MediaController):
, u'*.iso' , u'*.iso'
] ]
def setup(self, display, hasAudio): def setup_controls(self, controller, control_panel):
pass
def setup(self, display):
display.vlcWidget = QtGui.QFrame(display) display.vlcWidget = QtGui.QFrame(display)
# creating a basic vlc instance # creating a basic vlc instance
if hasAudio: if display.hasAudio:
display.vlcInstance = vlc.Instance() display.vlcInstance = vlc.Instance()
else: else:
display.vlcInstance = vlc.Instance('--no-audio') display.vlcInstance = vlc.Instance('--no-audio')
@ -121,26 +124,28 @@ class VlcController(MediaController):
u'video/x-wmv': [u'.wmv'], u'video/x-wmv': [u'.wmv'],
u'video/x-ms-wmv': [u'.wmv']} u'video/x-ms-wmv': [u'.wmv']}
def load(self, display, path, volume, isBackground): def load(self, display):
log.debug(u'load vid in Vlc Controller') log.debug(u'load vid in Vlc Controller')
vol = float(volume) / float(10) controller = display.parent
volume = controller.media_info.volume
file_path = str(
controller.media_info.file_info.absoluteFilePath().toUtf8())
path = os.path.normcase(file_path)
# create the media # create the media
display.vlcMedia = display.vlcInstance.media_new_path(unicode(path)) display.vlcMedia = display.vlcInstance.media_new_path(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 return True
def mediaStateWait(self, display): def mediaStateWait(self, display, mediaState):
""" """
Wait for the video to change its state Wait for the video to change its state
Wait no longer than 5 seconds. Wait no longer than 5 seconds.
""" """
start = datetime.now() start = datetime.now()
while not display.vlcMedia.is_parsed(): while not mediaState == display.vlcMedia.get_state():
if display.vlcMedia.get_state() == vlc.State.Error: if display.vlcMedia.get_state() == vlc.State.Error:
return False return False
Receiver.send_message(u'openlp_process_events') Receiver.send_message(u'openlp_process_events')
@ -148,24 +153,26 @@ class VlcController(MediaController):
return False return False
return True return True
def resize(self, display, controller): def resize(self, display):
display.vlcWidget.resize(display.size()) display.vlcWidget.resize(display.size())
def play(self, display): def play(self, display):
self.set_visible(display, True) self.set_visible(display, True)
display.vlcMediaPlayer.play() display.vlcMediaPlayer.play()
self.state = MediaState.Playing if self.mediaStateWait(display, vlc.State.Playing):
self.state = MediaState.Playing
def pause(self, display): def pause(self, display):
display.vlcMediaPlayer.pause() display.vlcMediaPlayer.pause()
self.state = MediaState.Paused if self.mediaStateWait(display, vlc.State.Paused):
self.state = MediaState.Paused
def stop(self, display): def stop(self, display):
display.vlcMediaPlayer.stop() display.vlcMediaPlayer.stop()
self.state = MediaState.Stopped self.state = MediaState.Stopped
def volume(self, display, vol): def volume(self, display, vol):
pass display.vlcMediaPlayer.audio_set_volume(vol)
def seek(self, display, seekVal): def seek(self, display, seekVal):
if display.vlcMediaPlayer.is_seekable(): if display.vlcMediaPlayer.is_seekable():
@ -180,7 +187,8 @@ class VlcController(MediaController):
if self.hasOwnWidget: if self.hasOwnWidget:
display.vlcWidget.setVisible(status) display.vlcWidget.setVisible(status)
def update_ui(self, controller, display): def update_ui(self, display):
controller = display.parent
controller.seekSlider.setMaximum(1000) controller.seekSlider.setMaximum(1000)
if not controller.seekSlider.isSliderDown(): if not controller.seekSlider.isSliderDown():
currentPos = display.vlcMediaPlayer.get_position() * 1000 currentPos = display.vlcMediaPlayer.get_position() * 1000

100
openlp/plugins/media/lib/webkitcontroller.py → openlp/plugins/media/lib/webkitapi.py
View File

@ -28,20 +28,21 @@
import logging import logging
from PyQt4 import QtCore, QtGui, QtWebKit from PyQt4 import QtCore, QtGui, QtWebKit
from openlp.plugins.media.lib import MediaController, MediaState
from openlp.core.lib import OpenLPToolbar, translate
from openlp.plugins.media.lib import MediaAPI, MediaState
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
class WebkitController(MediaController): class WebkitAPI(MediaAPI):
""" """
Specialiced MediaController class Specialiced MediaAPI class
to reflect Features of the QtWebkit backend to reflect Features of the QtWebkit API
""" """
def __init__(self, parent): def __init__(self, parent):
MediaController.__init__(self, parent) MediaAPI.__init__(self, parent)
self.parent = parent self.parent = parent
self.isFlash = False
self.canBackground = True self.canBackground = True
self.video_extensions_list = [ self.video_extensions_list = [
u'*.3gp' u'*.3gp'
@ -68,7 +69,11 @@ class WebkitController(MediaController):
, u'*.swf', u'*.mpg', u'*.wmv', u'*.mpeg', u'*.avi' , u'*.swf', u'*.mpg', u'*.wmv', u'*.mpeg', u'*.avi'
] ]
def setup(self, display, hasAudio): def setup_controls(self, controller, control_panel):
# no special controls
pass
def setup(self, display):
display.webView.raise_() display.webView.raise_()
self.hasOwnWidget = False self.hasOwnWidget = False
@ -79,68 +84,83 @@ class WebkitController(MediaController):
def get_supported_file_types(self): def get_supported_file_types(self):
pass pass
def load(self, display, path, volume, isBackground): def load(self, display):
log.debug(u'load vid in Webkit Controller') log.debug(u'load vid in Webkit Controller')
vol = float(volume) / float(10) controller = display.parent
if isBackground: volume = controller.media_info.volume
vol = float(volume) / float(100)
path = controller.media_info.file_info.absoluteFilePath()
if controller.media_info.is_background:
loop = u'true' loop = u'true'
else: else:
loop = u'false' loop = u'false'
display.webView.setVisible(True) display.webView.setVisible(True)
if path.endswith(u'.swf'): if controller.media_info.file_info.suffix() == u'swf':
controller.media_info.isFlash = True
js = u'show_flash("load","%s");' % \ js = u'show_flash("load","%s");' % \
(path.replace(u'\\', u'\\\\')) (path.replace(u'\\', u'\\\\'))
self.isFlash = True
else: else:
js = u'show_video("init", "%s", %s, %s);' % \ js = u'show_video("init", "%s", %s, %s);' % \
(path.replace(u'\\', u'\\\\'), str(vol), loop) (path.replace(u'\\', u'\\\\'), str(vol), loop)
self.isFlash = False
display.frame.evaluateJavaScript(js) display.frame.evaluateJavaScript(js)
return True return True
def resize(self, display, controller): def resize(self, display):
controller = display.parent
if display == controller.previewDisplay: if display == controller.previewDisplay:
display.webView.resize(display.size()) display.webView.resize(display.size())
def play(self, display): def play(self, display):
display.override[u'theme'] = u'' controller = display.parent
display.override[u'video'] = True #display.override[u'theme'] = u''
#display.override[u'video'] = True
display.webLoaded = True display.webLoaded = True
self.set_visible(display, True) self.set_visible(display, True)
if self.isFlash: if controller.media_info.isFlash:
display.frame.evaluateJavaScript(u'show_flash("play","");') display.frame.evaluateJavaScript(u'show_flash("play");')
else: else:
display.frame.evaluateJavaScript(u'show_video("play");') display.frame.evaluateJavaScript(u'show_video("play");')
self.state = MediaState.Playing self.state = MediaState.Playing
def pause(self, display): def pause(self, display):
if self.isFlash: controller = display.parent
display.frame.evaluateJavaScript(u'show_flash("pause","");') if controller.media_info.isFlash:
display.frame.evaluateJavaScript(u'show_flash("pause");')
else: else:
display.frame.evaluateJavaScript(u'show_video("pause");') display.frame.evaluateJavaScript(u'show_video("pause");')
self.state = MediaState.Paused self.state = MediaState.Paused
def stop(self, display): def stop(self, display):
if self.isFlash: controller = display.parent
display.frame.evaluateJavaScript(u'show_flash("stop","");') if controller.media_info.isFlash:
display.frame.evaluateJavaScript(u'show_flash("stop");')
else: else:
display.frame.evaluateJavaScript(u'show_video("stop");') display.frame.evaluateJavaScript(u'show_video("stop");')
self.state = MediaState.Stopped self.state = MediaState.Stopped
def volume(self, display, vol): def volume(self, display, vol):
if not self.isFlash: controller = display.parent
# 1.0 is the highest value
vol = float(vol) / float(100)
if not controller.media_info.isFlash:
display.frame.evaluateJavaScript(u'show_video(null, null, %s);' % display.frame.evaluateJavaScript(u'show_video(null, null, %s);' %
str(vol)) str(vol))
def seek(self, display, seekVal): def seek(self, display, seekVal):
if not self.isFlash: controller = display.parent
if controller.media_info.isFlash:
seek = seekVal
display.frame.evaluateJavaScript( \
u'show_flash("seek", null, null, "%s");' % (seek))
else:
seek = float(seekVal)/1000 seek = float(seekVal)/1000
display.frame.evaluateJavaScript( \ display.frame.evaluateJavaScript( \
u'show_video("seek", null, null, null, "%f");' % (seek)) u'show_video("seek", null, null, null, "%f");' % (seek))
def reset(self, display): def reset(self, display):
if self.isFlash: controller = display.parent
display.frame.evaluateJavaScript(u'show_flash("close","");') if controller.media_info.isFlash:
display.frame.evaluateJavaScript(u'show_flash("close");')
else: else:
display.frame.evaluateJavaScript(u'show_video("close");') display.frame.evaluateJavaScript(u'show_video("close");')
self.state = MediaState.Off self.state = MediaState.Off
@ -149,16 +169,26 @@ class WebkitController(MediaController):
if self.hasOwnWidget: if self.hasOwnWidget:
display.webView.setVisible(status) display.webView.setVisible(status)
def update_ui(self, controller, display): def update_ui(self, display):
if not self.isFlash: controller = display.parent
if controller.media_info.isFlash:
currentTime = display.frame.evaluateJavaScript( \ currentTime = display.frame.evaluateJavaScript( \
u'show_video("currentTime");') u'show_flash("currentTime");').toInt()[0]
length = display.frame.evaluateJavaScript(u'show_video("length");') length = display.frame.evaluateJavaScript( \
if int(currentTime.toFloat()[0]*1000) > 0: u'show_flash("length");').toInt()[0]
controller.seekSlider.setMaximum(int(length.toFloat()[0]*1000)) else:
if not controller.seekSlider.isSliderDown(): (currentTime, ok) = display.frame.evaluateJavaScript( \
controller.seekSlider.setSliderPosition( \ u'show_video("currentTime");').toFloat()
int(currentTime.toFloat()[0]*1000)) if ok:
currentTime = int(currentTime*1000)
(length, ok) = display.frame.evaluateJavaScript( \
u'show_video("length");').toFloat()
if ok:
length = int(length*1000)
if currentTime > 0:
controller.seekSlider.setMaximum(length)
if not controller.seekSlider.isSliderDown():
controller.seekSlider.setSliderPosition(currentTime)
def get_supported_file_types(self): def get_supported_file_types(self):
pass pass

3
openlp/plugins/media/mediaplugin.py
View File

@ -53,6 +53,9 @@ class MediaPlugin(Plugin):
'<br />The media plugin provides playback of audio and video.') '<br />The media plugin provides playback of audio and video.')
return about_text return about_text
def addControllerItems(self, controller, control_panel):
self.mediaManager.addControllerItems(controller, control_panel)
def setPluginTextStrings(self): def setPluginTextStrings(self):
""" """
Called to define all translatable texts of the plugin Called to define all translatable texts of the plugin