forked from openlp/openlp
r1749
This commit is contained in:
commit
2dad85f4c5
243
openlp.pyw
243
openlp.pyw
|
@ -25,254 +25,15 @@
|
|||
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
|
||||
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
|
||||
###############################################################################
|
||||
import os
|
||||
import sys
|
||||
import logging
|
||||
|
||||
# Import uuid now, to avoid the rare bug described in the support system:
|
||||
# http://support.openlp.org/issues/102
|
||||
# If https://bugs.gentoo.org/show_bug.cgi?id=317557 is fixed, the import can be
|
||||
# removed.
|
||||
import uuid
|
||||
from optparse import OptionParser
|
||||
from traceback import format_exception
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
from openlp.core import main
|
||||
|
||||
from openlp.core.lib import Receiver, check_directory_exists
|
||||
from openlp.core.lib.ui import UiStrings
|
||||
from openlp.core.resources import qInitResources
|
||||
from openlp.core.ui.mainwindow import MainWindow
|
||||
from openlp.core.ui.firsttimelanguageform import FirstTimeLanguageForm
|
||||
from openlp.core.ui.firsttimeform import FirstTimeForm
|
||||
from openlp.core.ui.exceptionform import ExceptionForm
|
||||
from openlp.core.ui import SplashScreen, ScreenList
|
||||
from openlp.core.utils import AppLocation, LanguageManager, VersionThread, \
|
||||
get_application_version, DelayStartThread
|
||||
|
||||
log = logging.getLogger()
|
||||
|
||||
application_stylesheet = u"""
|
||||
QMainWindow::separator
|
||||
{
|
||||
border: none;
|
||||
}
|
||||
|
||||
QDockWidget::title
|
||||
{
|
||||
border: 1px solid palette(dark);
|
||||
padding-left: 5px;
|
||||
padding-top: 2px;
|
||||
margin: 1px 0;
|
||||
}
|
||||
|
||||
QToolBar
|
||||
{
|
||||
border: none;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
}
|
||||
"""
|
||||
|
||||
class OpenLP(QtGui.QApplication):
|
||||
"""
|
||||
The core application class. This class inherits from Qt's QApplication
|
||||
class in order to provide the core of the application.
|
||||
"""
|
||||
|
||||
args = []
|
||||
|
||||
def exec_(self):
|
||||
"""
|
||||
Override exec method to allow the shared memory to be released on exit
|
||||
"""
|
||||
QtGui.QApplication.exec_()
|
||||
self.sharedMemory.detach()
|
||||
|
||||
def run(self, args):
|
||||
"""
|
||||
Run the OpenLP application.
|
||||
"""
|
||||
# On Windows, the args passed into the constructor are
|
||||
# ignored. Not very handy, so set the ones we want to use.
|
||||
self.args.extend(args)
|
||||
# provide a listener for widgets to reqest a screen update.
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'openlp_process_events'), self.processEvents)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'cursor_busy'), self.setBusyCursor)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'cursor_normal'), self.setNormalCursor)
|
||||
# Decide how many screens we have and their size
|
||||
screens = ScreenList(self.desktop())
|
||||
# First time checks in settings
|
||||
has_run_wizard = QtCore.QSettings().value(
|
||||
u'general/has run wizard', QtCore.QVariant(False)).toBool()
|
||||
if not has_run_wizard:
|
||||
if FirstTimeForm(screens).exec_() == QtGui.QDialog.Accepted:
|
||||
QtCore.QSettings().setValue(u'general/has run wizard',
|
||||
QtCore.QVariant(True))
|
||||
if os.name == u'nt':
|
||||
self.setStyleSheet(application_stylesheet)
|
||||
show_splash = QtCore.QSettings().value(
|
||||
u'general/show splash', QtCore.QVariant(True)).toBool()
|
||||
if show_splash:
|
||||
self.splash = SplashScreen()
|
||||
self.splash.show()
|
||||
# make sure Qt really display the splash screen
|
||||
self.processEvents()
|
||||
# start the main app window
|
||||
self.mainWindow = MainWindow(self.clipboard(), self.args)
|
||||
self.mainWindow.show()
|
||||
if show_splash:
|
||||
# now kill the splashscreen
|
||||
self.splash.finish(self.mainWindow)
|
||||
log.debug(u'Splashscreen closed')
|
||||
# make sure Qt really display the splash screen
|
||||
self.processEvents()
|
||||
self.mainWindow.repaint()
|
||||
self.processEvents()
|
||||
if not has_run_wizard:
|
||||
self.mainWindow.firstTime()
|
||||
update_check = QtCore.QSettings().value(
|
||||
u'general/update check', QtCore.QVariant(True)).toBool()
|
||||
if update_check:
|
||||
VersionThread(self.mainWindow).start()
|
||||
Receiver.send_message(u'maindisplay_blank_check')
|
||||
self.mainWindow.appStartup()
|
||||
DelayStartThread(self.mainWindow).start()
|
||||
return self.exec_()
|
||||
|
||||
def isAlreadyRunning(self):
|
||||
"""
|
||||
Look to see if OpenLP is already running and ask if a 2nd copy
|
||||
is to be started.
|
||||
"""
|
||||
self.sharedMemory = QtCore.QSharedMemory('OpenLP')
|
||||
if self.sharedMemory.attach():
|
||||
status = QtGui.QMessageBox.critical(None,
|
||||
UiStrings().Error, UiStrings().OpenLPStart,
|
||||
QtGui.QMessageBox.StandardButtons(
|
||||
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No))
|
||||
if status == QtGui.QMessageBox.No:
|
||||
return True
|
||||
return False
|
||||
else:
|
||||
self.sharedMemory.create(1)
|
||||
return False
|
||||
|
||||
def hookException(self, exctype, value, traceback):
|
||||
if not hasattr(self, u'mainWindow'):
|
||||
log.exception(''.join(format_exception(exctype, value, traceback)))
|
||||
return
|
||||
if not hasattr(self, u'exceptionForm'):
|
||||
self.exceptionForm = ExceptionForm(self.mainWindow)
|
||||
self.exceptionForm.exceptionTextEdit.setPlainText(
|
||||
''.join(format_exception(exctype, value, traceback)))
|
||||
self.setNormalCursor()
|
||||
self.exceptionForm.exec_()
|
||||
|
||||
def setBusyCursor(self):
|
||||
"""
|
||||
Sets the Busy Cursor for the Application
|
||||
"""
|
||||
self.setOverrideCursor(QtCore.Qt.BusyCursor)
|
||||
self.processEvents()
|
||||
|
||||
def setNormalCursor(self):
|
||||
"""
|
||||
Sets the Normal Cursor for the Application
|
||||
"""
|
||||
self.restoreOverrideCursor()
|
||||
|
||||
def event(self, event):
|
||||
"""
|
||||
Enables direct file opening on OS X
|
||||
"""
|
||||
if event.type() == QtCore.QEvent.FileOpen:
|
||||
file_name = event.file()
|
||||
log.debug(u'Got open file event for %s!', file_name)
|
||||
self.args.insert(0, unicode(file_name))
|
||||
return True
|
||||
else:
|
||||
return QtGui.QApplication.event(self, event)
|
||||
|
||||
def main():
|
||||
"""
|
||||
The main function which parses command line options and then runs
|
||||
the PyQt4 Application.
|
||||
"""
|
||||
# Set up command line options.
|
||||
usage = 'Usage: %prog [options] [qt-options]'
|
||||
parser = OptionParser(usage=usage)
|
||||
parser.add_option('-e', '--no-error-form', dest='no_error_form',
|
||||
action='store_true', help='Disable the error notification form.')
|
||||
parser.add_option('-l', '--log-level', dest='loglevel',
|
||||
default='warning', metavar='LEVEL', help='Set logging to LEVEL '
|
||||
'level. Valid values are "debug", "info", "warning".')
|
||||
parser.add_option('-p', '--portable', dest='portable',
|
||||
action='store_true', help='Specify if this should be run as a '
|
||||
'portable app, off a USB flash drive (not implemented).')
|
||||
parser.add_option('-d', '--dev-version', dest='dev_version',
|
||||
action='store_true', help='Ignore the version file and pull the '
|
||||
'version directly from Bazaar')
|
||||
parser.add_option('-s', '--style', dest='style',
|
||||
help='Set the Qt4 style (passed directly to Qt4).')
|
||||
# Set up logging
|
||||
log_path = AppLocation.get_directory(AppLocation.CacheDir)
|
||||
check_directory_exists(log_path)
|
||||
filename = os.path.join(log_path, u'openlp.log')
|
||||
logfile = logging.FileHandler(filename, u'w')
|
||||
logfile.setFormatter(logging.Formatter(
|
||||
u'%(asctime)s %(name)-55s %(levelname)-8s %(message)s'))
|
||||
log.addHandler(logfile)
|
||||
logging.addLevelName(15, u'Timer')
|
||||
# Parse command line options and deal with them.
|
||||
(options, args) = parser.parse_args()
|
||||
qt_args = []
|
||||
if options.loglevel.lower() in ['d', 'debug']:
|
||||
log.setLevel(logging.DEBUG)
|
||||
print 'Logging to:', filename
|
||||
elif options.loglevel.lower() in ['w', 'warning']:
|
||||
log.setLevel(logging.WARNING)
|
||||
else:
|
||||
log.setLevel(logging.INFO)
|
||||
if options.style:
|
||||
qt_args.extend(['-style', options.style])
|
||||
# Throw the rest of the arguments at Qt, just in case.
|
||||
qt_args.extend(args)
|
||||
# Initialise the resources
|
||||
qInitResources()
|
||||
# Now create and actually run the application.
|
||||
app = OpenLP(qt_args)
|
||||
# Instance check
|
||||
if app.isAlreadyRunning():
|
||||
sys.exit()
|
||||
app.setOrganizationName(u'OpenLP')
|
||||
app.setOrganizationDomain(u'openlp.org')
|
||||
app.setApplicationName(u'OpenLP')
|
||||
app.setApplicationVersion(get_application_version()[u'version'])
|
||||
# First time checks in settings
|
||||
if not QtCore.QSettings().value(u'general/has run wizard',
|
||||
QtCore.QVariant(False)).toBool():
|
||||
if not FirstTimeLanguageForm().exec_():
|
||||
# if cancel then stop processing
|
||||
sys.exit()
|
||||
if sys.platform == u'darwin':
|
||||
OpenLP.addLibraryPath(QtGui.QApplication.applicationDirPath()
|
||||
+ "/qt4_plugins")
|
||||
# i18n Set Language
|
||||
language = LanguageManager.get_language()
|
||||
app_translator, default_translator = \
|
||||
LanguageManager.get_translator(language)
|
||||
if not app_translator.isEmpty():
|
||||
app.installTranslator(app_translator)
|
||||
if not default_translator.isEmpty():
|
||||
app.installTranslator(default_translator)
|
||||
else:
|
||||
log.debug(u'Could not find default_translator.')
|
||||
if not options.no_error_form:
|
||||
sys.excepthook = app.hookException
|
||||
sys.exit(app.run(qt_args))
|
||||
|
||||
if __name__ == u'__main__':
|
||||
"""
|
||||
|
|
|
@ -27,3 +27,9 @@
|
|||
"""
|
||||
The :mod:`openlp` module contains all the project produced OpenLP functionality
|
||||
"""
|
||||
|
||||
import core
|
||||
import plugins
|
||||
|
||||
__all__ = [u'core', u'plugins']
|
||||
|
||||
|
|
|
@ -24,9 +24,268 @@
|
|||
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
|
||||
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
|
||||
###############################################################################
|
||||
|
||||
"""
|
||||
The :mod:`core` module provides all core application functions
|
||||
|
||||
All the core functions of the OpenLP application including the GUI, settings,
|
||||
logging and a plugin framework are contained within the openlp.core module.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import logging
|
||||
from optparse import OptionParser
|
||||
from traceback import format_exception
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from openlp.core.lib import Receiver, check_directory_exists
|
||||
from openlp.core.lib.ui import UiStrings
|
||||
from openlp.core.resources import qInitResources
|
||||
from openlp.core.ui.mainwindow import MainWindow
|
||||
from openlp.core.ui.firsttimelanguageform import FirstTimeLanguageForm
|
||||
from openlp.core.ui.firsttimeform import FirstTimeForm
|
||||
from openlp.core.ui.exceptionform import ExceptionForm
|
||||
from openlp.core.ui import SplashScreen, ScreenList
|
||||
from openlp.core.utils import AppLocation, LanguageManager, VersionThread, \
|
||||
get_application_version, DelayStartThread
|
||||
|
||||
|
||||
__all__ = [u'OpenLP', u'main']
|
||||
|
||||
|
||||
log = logging.getLogger()
|
||||
application_stylesheet = u"""
|
||||
QMainWindow::separator
|
||||
{
|
||||
border: none;
|
||||
}
|
||||
|
||||
QDockWidget::title
|
||||
{
|
||||
border: 1px solid palette(dark);
|
||||
padding-left: 5px;
|
||||
padding-top: 2px;
|
||||
margin: 1px 0;
|
||||
}
|
||||
|
||||
QToolBar
|
||||
{
|
||||
border: none;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
class OpenLP(QtGui.QApplication):
|
||||
"""
|
||||
The core application class. This class inherits from Qt's QApplication
|
||||
class in order to provide the core of the application.
|
||||
"""
|
||||
|
||||
args = []
|
||||
|
||||
def exec_(self):
|
||||
"""
|
||||
Override exec method to allow the shared memory to be released on exit
|
||||
"""
|
||||
QtGui.QApplication.exec_()
|
||||
self.sharedMemory.detach()
|
||||
|
||||
def run(self, args, testing=False):
|
||||
"""
|
||||
Run the OpenLP application.
|
||||
"""
|
||||
# On Windows, the args passed into the constructor are
|
||||
# ignored. Not very handy, so set the ones we want to use.
|
||||
self.args.extend(args)
|
||||
# provide a listener for widgets to reqest a screen update.
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'openlp_process_events'), self.processEvents)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'cursor_busy'), self.setBusyCursor)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'cursor_normal'), self.setNormalCursor)
|
||||
# Decide how many screens we have and their size
|
||||
screens = ScreenList(self.desktop())
|
||||
# First time checks in settings
|
||||
has_run_wizard = QtCore.QSettings().value(
|
||||
u'general/has run wizard', QtCore.QVariant(False)).toBool()
|
||||
if not has_run_wizard:
|
||||
if FirstTimeForm(screens).exec_() == QtGui.QDialog.Accepted:
|
||||
QtCore.QSettings().setValue(u'general/has run wizard',
|
||||
QtCore.QVariant(True))
|
||||
if os.name == u'nt':
|
||||
self.setStyleSheet(application_stylesheet)
|
||||
show_splash = QtCore.QSettings().value(
|
||||
u'general/show splash', QtCore.QVariant(True)).toBool()
|
||||
if show_splash:
|
||||
self.splash = SplashScreen()
|
||||
self.splash.show()
|
||||
# make sure Qt really display the splash screen
|
||||
self.processEvents()
|
||||
# start the main app window
|
||||
self.mainWindow = MainWindow(self.clipboard(), self.args)
|
||||
self.mainWindow.show()
|
||||
if show_splash:
|
||||
# now kill the splashscreen
|
||||
self.splash.finish(self.mainWindow)
|
||||
log.debug(u'Splashscreen closed')
|
||||
# make sure Qt really display the splash screen
|
||||
self.processEvents()
|
||||
self.mainWindow.repaint()
|
||||
self.processEvents()
|
||||
if not has_run_wizard:
|
||||
self.mainWindow.firstTime()
|
||||
update_check = QtCore.QSettings().value(
|
||||
u'general/update check', QtCore.QVariant(True)).toBool()
|
||||
if update_check:
|
||||
VersionThread(self.mainWindow).start()
|
||||
Receiver.send_message(u'maindisplay_blank_check')
|
||||
self.mainWindow.appStartup()
|
||||
DelayStartThread(self.mainWindow).start()
|
||||
# Skip exec_() for gui tests
|
||||
if not testing:
|
||||
return self.exec_()
|
||||
|
||||
def isAlreadyRunning(self):
|
||||
"""
|
||||
Look to see if OpenLP is already running and ask if a 2nd copy
|
||||
is to be started.
|
||||
"""
|
||||
self.sharedMemory = QtCore.QSharedMemory('OpenLP')
|
||||
if self.sharedMemory.attach():
|
||||
status = QtGui.QMessageBox.critical(None,
|
||||
UiStrings().Error, UiStrings().OpenLPStart,
|
||||
QtGui.QMessageBox.StandardButtons(
|
||||
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No))
|
||||
if status == QtGui.QMessageBox.No:
|
||||
return True
|
||||
return False
|
||||
else:
|
||||
self.sharedMemory.create(1)
|
||||
return False
|
||||
|
||||
def hookException(self, exctype, value, traceback):
|
||||
if not hasattr(self, u'mainWindow'):
|
||||
log.exception(''.join(format_exception(exctype, value, traceback)))
|
||||
return
|
||||
if not hasattr(self, u'exceptionForm'):
|
||||
self.exceptionForm = ExceptionForm(self.mainWindow)
|
||||
self.exceptionForm.exceptionTextEdit.setPlainText(
|
||||
''.join(format_exception(exctype, value, traceback)))
|
||||
self.setNormalCursor()
|
||||
self.exceptionForm.exec_()
|
||||
|
||||
def setBusyCursor(self):
|
||||
"""
|
||||
Sets the Busy Cursor for the Application
|
||||
"""
|
||||
self.setOverrideCursor(QtCore.Qt.BusyCursor)
|
||||
self.processEvents()
|
||||
|
||||
def setNormalCursor(self):
|
||||
"""
|
||||
Sets the Normal Cursor for the Application
|
||||
"""
|
||||
self.restoreOverrideCursor()
|
||||
|
||||
def event(self, event):
|
||||
"""
|
||||
Enables direct file opening on OS X
|
||||
"""
|
||||
if event.type() == QtCore.QEvent.FileOpen:
|
||||
file_name = event.file()
|
||||
log.debug(u'Got open file event for %s!', file_name)
|
||||
self.args.insert(0, unicode(file_name))
|
||||
return True
|
||||
else:
|
||||
return QtGui.QApplication.event(self, event)
|
||||
|
||||
|
||||
def main(args=None):
|
||||
"""
|
||||
The main function which parses command line options and then runs
|
||||
the PyQt4 Application.
|
||||
"""
|
||||
# Set up command line options.
|
||||
usage = 'Usage: %prog [options] [qt-options]'
|
||||
parser = OptionParser(usage=usage)
|
||||
parser.add_option('-e', '--no-error-form', dest='no_error_form',
|
||||
action='store_true', help='Disable the error notification form.')
|
||||
parser.add_option('-l', '--log-level', dest='loglevel',
|
||||
default='warning', metavar='LEVEL', help='Set logging to LEVEL '
|
||||
'level. Valid values are "debug", "info", "warning".')
|
||||
parser.add_option('-p', '--portable', dest='portable',
|
||||
action='store_true', help='Specify if this should be run as a '
|
||||
'portable app, off a USB flash drive (not implemented).')
|
||||
parser.add_option('-d', '--dev-version', dest='dev_version',
|
||||
action='store_true', help='Ignore the version file and pull the '
|
||||
'version directly from Bazaar')
|
||||
parser.add_option('-s', '--style', dest='style',
|
||||
help='Set the Qt4 style (passed directly to Qt4).')
|
||||
parser.add_option('--testing', dest='testing',
|
||||
action='store_true', help='Run by testing framework')
|
||||
# Set up logging
|
||||
log_path = AppLocation.get_directory(AppLocation.CacheDir)
|
||||
check_directory_exists(log_path)
|
||||
filename = os.path.join(log_path, u'openlp.log')
|
||||
logfile = logging.FileHandler(filename, u'w')
|
||||
logfile.setFormatter(logging.Formatter(
|
||||
u'%(asctime)s %(name)-55s %(levelname)-8s %(message)s'))
|
||||
log.addHandler(logfile)
|
||||
# Parse command line options and deal with them.
|
||||
# Use args supplied programatically if possible.
|
||||
(options, args) = parser.parse_args(args) if args else parser.parse_args()
|
||||
qt_args = []
|
||||
if options.loglevel.lower() in ['d', 'debug']:
|
||||
log.setLevel(logging.DEBUG)
|
||||
print 'Logging to:', filename
|
||||
elif options.loglevel.lower() in ['w', 'warning']:
|
||||
log.setLevel(logging.WARNING)
|
||||
else:
|
||||
log.setLevel(logging.INFO)
|
||||
if options.style:
|
||||
qt_args.extend(['-style', options.style])
|
||||
# Throw the rest of the arguments at Qt, just in case.
|
||||
qt_args.extend(args)
|
||||
# Initialise the resources
|
||||
qInitResources()
|
||||
# Now create and actually run the application.
|
||||
app = OpenLP(qt_args)
|
||||
app.setOrganizationName(u'OpenLP')
|
||||
app.setOrganizationDomain(u'openlp.org')
|
||||
app.setApplicationName(u'OpenLP')
|
||||
app.setApplicationVersion(get_application_version()[u'version'])
|
||||
# Instance check
|
||||
if not options.testing:
|
||||
# Instance check
|
||||
if app.isAlreadyRunning():
|
||||
sys.exit()
|
||||
# First time checks in settings
|
||||
if not QtCore.QSettings().value(u'general/has run wizard',
|
||||
QtCore.QVariant(False)).toBool():
|
||||
if not FirstTimeLanguageForm().exec_():
|
||||
# if cancel then stop processing
|
||||
sys.exit()
|
||||
# i18n Set Language
|
||||
language = LanguageManager.get_language()
|
||||
app_translator, default_translator = \
|
||||
LanguageManager.get_translator(language)
|
||||
if not app_translator.isEmpty():
|
||||
app.installTranslator(app_translator)
|
||||
if not default_translator.isEmpty():
|
||||
app.installTranslator(default_translator)
|
||||
else:
|
||||
log.debug(u'Could not find default_translator.')
|
||||
if not options.no_error_form:
|
||||
sys.excepthook = app.hookException
|
||||
# Do not run method app.exec_() when running gui tests
|
||||
if options.testing:
|
||||
app.run(qt_args, testing=True)
|
||||
# For gui tests we need access to window intances and their components
|
||||
return app
|
||||
else:
|
||||
sys.exit(app.run(qt_args))
|
||||
|
|
|
@ -36,6 +36,13 @@ from PyQt4 import QtCore, QtGui
|
|||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
class MediaType(object):
|
||||
"""
|
||||
An enumeration class for types of media.
|
||||
"""
|
||||
Audio = 1
|
||||
Video = 2
|
||||
|
||||
def translate(context, text, comment=None,
|
||||
encoding=QtCore.QCoreApplication.CodecForTr, n=-1,
|
||||
translate=QtCore.QCoreApplication.translate):
|
||||
|
@ -137,7 +144,7 @@ def image_to_byte(image):
|
|||
# convert to base64 encoding so does not get missed!
|
||||
return byte_array.toBase64()
|
||||
|
||||
def resize_image(image_path, width, height, background=QtCore.Qt.black):
|
||||
def resize_image(image_path, width, height, background):
|
||||
"""
|
||||
Resize an image to fit on the current screen.
|
||||
|
||||
|
@ -241,9 +248,7 @@ from settingsmanager import SettingsManager
|
|||
from plugin import PluginStatus, StringContent, Plugin
|
||||
from pluginmanager import PluginManager
|
||||
from settingstab import SettingsTab
|
||||
from serviceitem import ServiceItem
|
||||
from serviceitem import ServiceItemType
|
||||
from serviceitem import ItemCapabilities
|
||||
from serviceitem import ServiceItem, ServiceItemType, ItemCapabilities
|
||||
from htmlbuilder import build_html, build_lyrics_format_css, \
|
||||
build_lyrics_outline_css
|
||||
from toolbar import OpenLPToolbar
|
||||
|
|
|
@ -31,11 +31,13 @@ import logging
|
|||
import os
|
||||
|
||||
from PyQt4 import QtCore
|
||||
from sqlalchemy import create_engine, MetaData
|
||||
from sqlalchemy.exc import InvalidRequestError
|
||||
from sqlalchemy.orm import scoped_session, sessionmaker
|
||||
from sqlalchemy import Table, MetaData, Column, types, create_engine
|
||||
from sqlalchemy.exc import SQLAlchemyError, InvalidRequestError, DBAPIError
|
||||
from sqlalchemy.orm import scoped_session, sessionmaker, mapper
|
||||
from sqlalchemy.pool import NullPool
|
||||
|
||||
from openlp.core.lib import translate
|
||||
from openlp.core.lib.ui import critical_error_message_box
|
||||
from openlp.core.utils import AppLocation, delete_file
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
@ -59,6 +61,64 @@ def init_db(url, auto_flush=True, auto_commit=False):
|
|||
autocommit=auto_commit, bind=engine))
|
||||
return session, metadata
|
||||
|
||||
|
||||
def upgrade_db(url, upgrade):
|
||||
"""
|
||||
Upgrade a database.
|
||||
|
||||
``url``
|
||||
The url of the database to upgrade.
|
||||
|
||||
``upgrade``
|
||||
The python module that contains the upgrade instructions.
|
||||
"""
|
||||
session, metadata = init_db(url)
|
||||
|
||||
class Metadata(BaseModel):
|
||||
"""
|
||||
Provides a class for the metadata table.
|
||||
"""
|
||||
pass
|
||||
load_changes = True
|
||||
try:
|
||||
tables = upgrade.upgrade_setup(metadata)
|
||||
except (SQLAlchemyError, DBAPIError):
|
||||
load_changes = False
|
||||
metadata_table = Table(u'metadata', metadata,
|
||||
Column(u'key', types.Unicode(64), primary_key=True),
|
||||
Column(u'value', types.UnicodeText(), default=None)
|
||||
)
|
||||
metadata_table.create(checkfirst=True)
|
||||
mapper(Metadata, metadata_table)
|
||||
version_meta = session.query(Metadata).get(u'version')
|
||||
if version_meta is None:
|
||||
version_meta = Metadata.populate(key=u'version', value=u'0')
|
||||
version = 0
|
||||
else:
|
||||
version = int(version_meta.value)
|
||||
if version > upgrade.__version__:
|
||||
return version, upgrade.__version__
|
||||
version += 1
|
||||
if load_changes:
|
||||
while hasattr(upgrade, u'upgrade_%d' % version):
|
||||
log.debug(u'Running upgrade_%d', version)
|
||||
try:
|
||||
getattr(upgrade, u'upgrade_%d' % version) \
|
||||
(session, metadata, tables)
|
||||
version_meta.value = unicode(version)
|
||||
except (SQLAlchemyError, DBAPIError):
|
||||
log.exception(u'Could not run database upgrade script '
|
||||
'"upgrade_%s", upgrade process has been halted.', version)
|
||||
break
|
||||
version += 1
|
||||
else:
|
||||
version_meta = Metadata.populate(key=u'version',
|
||||
value=int(upgrade.__version__))
|
||||
session.add(version_meta)
|
||||
session.commit()
|
||||
return int(version_meta.value), upgrade.__version__
|
||||
|
||||
|
||||
def delete_database(plugin_name, db_file_name=None):
|
||||
"""
|
||||
Remove a database file from the system.
|
||||
|
@ -79,6 +139,7 @@ def delete_database(plugin_name, db_file_name=None):
|
|||
AppLocation.get_section_data_path(plugin_name), plugin_name)
|
||||
return delete_file(db_file_path)
|
||||
|
||||
|
||||
class BaseModel(object):
|
||||
"""
|
||||
BaseModel provides a base object with a set of generic functions
|
||||
|
@ -93,12 +154,12 @@ class BaseModel(object):
|
|||
instance.__setattr__(key, value)
|
||||
return instance
|
||||
|
||||
|
||||
class Manager(object):
|
||||
"""
|
||||
Provide generic object persistence management
|
||||
"""
|
||||
def __init__(self, plugin_name, init_schema, db_file_name=None):
|
||||
def __init__(self, plugin_name, init_schema, db_file_name=None,
|
||||
upgrade_mod=None):
|
||||
"""
|
||||
Runs the initialisation process that includes creating the connection
|
||||
to the database and the tables if they don't exist.
|
||||
|
@ -109,6 +170,9 @@ class Manager(object):
|
|||
``init_schema``
|
||||
The init_schema function for this database
|
||||
|
||||
``upgrade_schema``
|
||||
The upgrade_schema function for this database
|
||||
|
||||
``db_file_name``
|
||||
The file name to use for this database. Defaults to None resulting
|
||||
in the plugin_name being used.
|
||||
|
@ -134,7 +198,28 @@ class Manager(object):
|
|||
unicode(settings.value(u'db hostname').toString()),
|
||||
unicode(settings.value(u'db database').toString()))
|
||||
settings.endGroup()
|
||||
self.session = init_schema(self.db_url)
|
||||
if upgrade_mod:
|
||||
db_ver, up_ver = upgrade_db(self.db_url, upgrade_mod)
|
||||
if db_ver > up_ver:
|
||||
critical_error_message_box(
|
||||
translate('OpenLP.Manager', 'Database Error'),
|
||||
unicode(translate('OpenLP.Manager', 'The database being '
|
||||
'loaded was created in a more recent version of '
|
||||
'OpenLP. The database is version %d, while OpenLP '
|
||||
'expects version %d. The database will not be loaded.'
|
||||
'\n\nDatabase: %s')) % \
|
||||
(db_ver, up_ver, self.db_url)
|
||||
)
|
||||
return
|
||||
try:
|
||||
self.session = init_schema(self.db_url)
|
||||
except (SQLAlchemyError, DBAPIError):
|
||||
log.exception(u'Error loading database: %s', self.db_url)
|
||||
critical_error_message_box(
|
||||
translate('OpenLP.Manager', 'Database Error'),
|
||||
unicode(translate('OpenLP.Manager', 'OpenLP cannot load your '
|
||||
'database.\n\nDatabase: %s')) % self.db_url
|
||||
)
|
||||
|
||||
def save_object(self, object_instance, commit=True):
|
||||
"""
|
||||
|
|
|
@ -36,7 +36,7 @@ import Queue
|
|||
|
||||
from PyQt4 import QtCore
|
||||
|
||||
from openlp.core.lib import resize_image, image_to_byte
|
||||
from openlp.core.lib import resize_image, image_to_byte, Receiver
|
||||
from openlp.core.ui import ScreenList
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
@ -100,12 +100,14 @@ class Image(object):
|
|||
variables ``image`` and ``image_bytes`` to ``None`` and add the image object
|
||||
to the queue of images to process.
|
||||
"""
|
||||
def __init__(self, name='', path=''):
|
||||
def __init__(self, name, path, source, background):
|
||||
self.name = name
|
||||
self.path = path
|
||||
self.image = None
|
||||
self.image_bytes = None
|
||||
self.priority = Priority.Normal
|
||||
self.source = source
|
||||
self.background = background
|
||||
|
||||
|
||||
class PriorityQueue(Queue.PriorityQueue):
|
||||
|
@ -151,6 +153,8 @@ class ImageManager(QtCore.QObject):
|
|||
self._cache = {}
|
||||
self._imageThread = ImageThread(self)
|
||||
self._conversion_queue = PriorityQueue()
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'config_updated'), self.process_updates)
|
||||
|
||||
def update_display(self):
|
||||
"""
|
||||
|
@ -162,12 +166,42 @@ class ImageManager(QtCore.QObject):
|
|||
self.height = current_screen[u'size'].height()
|
||||
# Mark the images as dirty for a rebuild by setting the image and byte
|
||||
# stream to None.
|
||||
self._conversion_queue = PriorityQueue()
|
||||
for key, image in self._cache.iteritems():
|
||||
image.priority = Priority.Normal
|
||||
image.image = None
|
||||
image.image_bytes = None
|
||||
self._conversion_queue.put((image.priority, image))
|
||||
self._reset_image(image)
|
||||
|
||||
def update_images(self, image_type, background):
|
||||
"""
|
||||
Border has changed so update all the images affected.
|
||||
"""
|
||||
log.debug(u'update_images')
|
||||
# Mark the images as dirty for a rebuild by setting the image and byte
|
||||
# stream to None.
|
||||
for key, image in self._cache.iteritems():
|
||||
if image.source == image_type:
|
||||
image.background = background
|
||||
self._reset_image(image)
|
||||
|
||||
def update_image(self, name, image_type, background):
|
||||
"""
|
||||
Border has changed so update the image affected.
|
||||
"""
|
||||
log.debug(u'update_images')
|
||||
# Mark the images as dirty for a rebuild by setting the image and byte
|
||||
# stream to None.
|
||||
for key, image in self._cache.iteritems():
|
||||
if image.source == image_type and image.name == name:
|
||||
image.background = background
|
||||
self._reset_image(image)
|
||||
|
||||
def _reset_image(self, image):
|
||||
image.image = None
|
||||
image.image_bytes = None
|
||||
self._conversion_queue.modify_priority(image, Priority.Normal)
|
||||
|
||||
def process_updates(self):
|
||||
"""
|
||||
Flush the queue to updated any data to update
|
||||
"""
|
||||
# We want only one thread.
|
||||
if not self._imageThread.isRunning():
|
||||
self._imageThread.start()
|
||||
|
@ -215,13 +249,13 @@ class ImageManager(QtCore.QObject):
|
|||
self._conversion_queue.remove(self._cache[name])
|
||||
del self._cache[name]
|
||||
|
||||
def add_image(self, name, path):
|
||||
def add_image(self, name, path, source, background):
|
||||
"""
|
||||
Add image to cache if it is not already there.
|
||||
"""
|
||||
log.debug(u'add_image %s:%s' % (name, path))
|
||||
if not name in self._cache:
|
||||
image = Image(name, path)
|
||||
image = Image(name, path, source, background)
|
||||
self._cache[name] = image
|
||||
self._conversion_queue.put((image.priority, image))
|
||||
else:
|
||||
|
@ -247,7 +281,8 @@ class ImageManager(QtCore.QObject):
|
|||
image = self._conversion_queue.get()[1]
|
||||
# Generate the QImage for the image.
|
||||
if image.image is None:
|
||||
image.image = resize_image(image.path, self.width, self.height)
|
||||
image.image = resize_image(image.path, self.width, self.height,
|
||||
image.background)
|
||||
# Set the priority to Lowest and stop here as we need to process
|
||||
# more important images first.
|
||||
if image.priority == Priority.Normal:
|
||||
|
|
|
@ -111,7 +111,7 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
self.requiredIcons()
|
||||
self.setupUi()
|
||||
self.retranslateUi()
|
||||
self.auto_select_id = -1
|
||||
self.autoSelectId = -1
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'%s_service_load' % self.plugin.name),
|
||||
self.serviceLoad)
|
||||
|
@ -376,18 +376,23 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
The files to be loaded
|
||||
"""
|
||||
names = []
|
||||
fullList = []
|
||||
for count in range(0, self.listView.count()):
|
||||
names.append(self.listView.item(count).text())
|
||||
newFiles = []
|
||||
names.append(unicode(self.listView.item(count).text()))
|
||||
fullList.append(unicode(self.listView.item(count).
|
||||
data(QtCore.Qt.UserRole).toString()))
|
||||
duplicatesFound = False
|
||||
filesAdded = False
|
||||
for file in files:
|
||||
filename = os.path.split(unicode(file))[1]
|
||||
if filename in names:
|
||||
duplicatesFound = True
|
||||
else:
|
||||
newFiles.append(file)
|
||||
if newFiles:
|
||||
self.loadList(newFiles)
|
||||
filesAdded = True
|
||||
fullList.append(file)
|
||||
if fullList and filesAdded:
|
||||
self.listView.clear()
|
||||
self.loadList(fullList)
|
||||
lastDir = os.path.split(unicode(files[0]))[0]
|
||||
SettingsManager.set_last_dir(self.settingsSection, lastDir)
|
||||
SettingsManager.set_list(self.settingsSection,
|
||||
|
@ -396,7 +401,7 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
critical_error_message_box(
|
||||
UiStrings().Duplicate,
|
||||
unicode(translate('OpenLP.MediaManagerItem',
|
||||
'Duplicate files found on import and ignored.')))
|
||||
'Duplicate files were found on import and were ignored.')))
|
||||
|
||||
def contextMenu(self, point):
|
||||
item = self.listView.itemAt(point)
|
||||
|
@ -485,7 +490,8 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
"""
|
||||
pass
|
||||
|
||||
def generateSlideData(self, serviceItem, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, serviceItem, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
raise NotImplementedError(u'MediaManagerItem.generateSlideData needs '
|
||||
u'to be defined by the plugin')
|
||||
|
||||
|
@ -506,7 +512,7 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
if QtCore.QSettings().value(u'advanced/single click preview',
|
||||
QtCore.QVariant(False)).toBool() and self.quickPreviewAllowed \
|
||||
and self.listView.selectedIndexes() \
|
||||
and self.auto_select_id == -1:
|
||||
and self.autoSelectId == -1:
|
||||
self.onPreviewClick(True)
|
||||
|
||||
def onPreviewClick(self, keepFocus=False):
|
||||
|
@ -539,12 +545,12 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
else:
|
||||
self.goLive()
|
||||
|
||||
def goLive(self, item_id=None):
|
||||
def goLive(self, item_id=None, remote=False):
|
||||
log.debug(u'%s Live requested', self.plugin.name)
|
||||
item = None
|
||||
if item_id:
|
||||
item = self.createItemFromId(item_id)
|
||||
serviceItem = self.buildServiceItem(item)
|
||||
serviceItem = self.buildServiceItem(item, remote=remote)
|
||||
if serviceItem:
|
||||
if not item_id:
|
||||
serviceItem.from_plugin = True
|
||||
|
@ -574,8 +580,8 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
for item in items:
|
||||
self.addToService(item)
|
||||
|
||||
def addToService(self, item=None, replace=None):
|
||||
serviceItem = self.buildServiceItem(item, True)
|
||||
def addToService(self, item=None, replace=None, remote=False):
|
||||
serviceItem = self.buildServiceItem(item, True, remote=remote)
|
||||
if serviceItem:
|
||||
serviceItem.from_plugin = False
|
||||
self.plugin.serviceManager.addServiceItem(serviceItem,
|
||||
|
@ -608,13 +614,13 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
unicode(translate('OpenLP.MediaManagerItem',
|
||||
'You must select a %s service item.')) % self.title)
|
||||
|
||||
def buildServiceItem(self, item=None, xmlVersion=False):
|
||||
def buildServiceItem(self, item=None, xmlVersion=False, remote=False):
|
||||
"""
|
||||
Common method for generating a service item
|
||||
"""
|
||||
serviceItem = ServiceItem(self.plugin)
|
||||
serviceItem.add_icon(self.plugin.icon_path)
|
||||
if self.generateSlideData(serviceItem, item, xmlVersion):
|
||||
if self.generateSlideData(serviceItem, item, xmlVersion, remote):
|
||||
return serviceItem
|
||||
else:
|
||||
return None
|
||||
|
@ -626,7 +632,7 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
"""
|
||||
pass
|
||||
|
||||
def check_search_result(self):
|
||||
def checkSearchResult(self):
|
||||
"""
|
||||
Checks if the listView is empty and adds a "No Search Results" item.
|
||||
"""
|
||||
|
@ -662,15 +668,15 @@ class MediaManagerItem(QtGui.QWidget):
|
|||
item_id = (item.data(QtCore.Qt.UserRole)).toInt()[0]
|
||||
return item_id
|
||||
|
||||
def save_auto_select_id(self):
|
||||
def saveAutoSelectId(self):
|
||||
"""
|
||||
Sorts out, what item to select after loading a list.
|
||||
"""
|
||||
# The item to select has not been set.
|
||||
if self.auto_select_id == -1:
|
||||
if self.autoSelectId == -1:
|
||||
item = self.listView.currentItem()
|
||||
if item:
|
||||
self.auto_select_id = item.data(QtCore.Qt.UserRole).toInt()[0]
|
||||
self.autoSelectId = item.data(QtCore.Qt.UserRole).toInt()[0]
|
||||
|
||||
def search(self, string):
|
||||
"""
|
||||
|
|
|
@ -368,3 +368,4 @@ class Plugin(QtCore.QObject):
|
|||
after this has been set.
|
||||
"""
|
||||
self.textStrings[name] = {u'title': title, u'tooltip': tooltip}
|
||||
|
||||
|
|
|
@ -27,7 +27,7 @@
|
|||
|
||||
import logging
|
||||
|
||||
from PyQt4 import QtCore, QtWebKit
|
||||
from PyQt4 import QtGui, QtCore, QtWebKit
|
||||
|
||||
from openlp.core.lib import ServiceItem, expand_tags, \
|
||||
build_lyrics_format_css, build_lyrics_outline_css, Receiver, \
|
||||
|
@ -166,7 +166,8 @@ class Renderer(object):
|
|||
# if No file do not update cache
|
||||
if self.theme_data.background_filename:
|
||||
self.imageManager.add_image(self.theme_data.theme_name,
|
||||
self.theme_data.background_filename)
|
||||
self.theme_data.background_filename, u'theme',
|
||||
QtGui.QColor(self.theme_data.background_border_color))
|
||||
return self._rect, self._rect_footer
|
||||
|
||||
def generate_preview(self, theme_data, force_page=False):
|
||||
|
@ -221,21 +222,56 @@ class Renderer(object):
|
|||
if item.is_capable(ItemCapabilities.NoLineBreaks):
|
||||
line_end = u' '
|
||||
# Bibles
|
||||
if item.is_capable(ItemCapabilities.AllowsWordSplit):
|
||||
if item.is_capable(ItemCapabilities.CanWordSplit):
|
||||
pages = self._paginate_slide_words(text.split(u'\n'), line_end)
|
||||
else:
|
||||
# Clean up line endings.
|
||||
lines = self._lines_split(text)
|
||||
pages = self._paginate_slide(lines, line_end)
|
||||
if len(pages) > 1:
|
||||
# Songs and Custom
|
||||
if item.is_capable(ItemCapabilities.AllowsVirtualSplit):
|
||||
# Do not forget the line breaks!
|
||||
slides = text.split(u'[---]')
|
||||
pages = []
|
||||
for slide in slides:
|
||||
lines = slide.strip(u'\n').split(u'\n')
|
||||
# Songs and Custom
|
||||
if item.is_capable(ItemCapabilities.CanSoftBreak) and \
|
||||
len(pages) > 1 and u'[---]' in text:
|
||||
pages = []
|
||||
while True:
|
||||
slides = text.split(u'\n[---]\n', 2)
|
||||
# If there are (at least) two occurrences of [---] we use
|
||||
# the first two slides (and neglect the last for now).
|
||||
if len(slides) == 3:
|
||||
html_text = expand_tags(u'\n'.join(slides[:2]))
|
||||
# We check both slides to determine if the virtual break is
|
||||
# needed (there is only one virtual break).
|
||||
else:
|
||||
html_text = expand_tags(u'\n'.join(slides))
|
||||
html_text = html_text.replace(u'\n', u'<br>')
|
||||
if self._text_fits_on_slide(html_text):
|
||||
# The first two virtual slides fit (as a whole) on one
|
||||
# slide. Replace the first occurrence of [---].
|
||||
text = text.replace(u'\n[---]', u'', 1)
|
||||
else:
|
||||
# The first virtual slide fits, which means we have to
|
||||
# render the first virtual slide.
|
||||
text_contains_break = u'[---]' in text
|
||||
if text_contains_break:
|
||||
text_to_render, text = text.split(u'\n[---]\n', 1)
|
||||
else:
|
||||
text_to_render = text
|
||||
text = u''
|
||||
lines = text_to_render.strip(u'\n').split(u'\n')
|
||||
slides = self._paginate_slide(lines, line_end)
|
||||
if len(slides) > 1 and text:
|
||||
# Add all slides apart from the last one the list.
|
||||
pages.extend(slides[:-1])
|
||||
if text_contains_break:
|
||||
text = slides[-1] + u'\n[---]\n' + text
|
||||
else:
|
||||
text = slides[-1] + u'\n'+ text
|
||||
text = text.replace(u'<br>', u'\n')
|
||||
else:
|
||||
pages.extend(slides)
|
||||
if u'[---]' not in text:
|
||||
lines = text.strip(u'\n').split(u'\n')
|
||||
pages.extend(self._paginate_slide(lines, line_end))
|
||||
break
|
||||
new_pages = []
|
||||
for page in pages:
|
||||
while page.endswith(u'<br>'):
|
||||
|
@ -341,7 +377,7 @@ class Renderer(object):
|
|||
separator = u'<br>'
|
||||
html_lines = map(expand_tags, lines)
|
||||
# Text too long so go to next page.
|
||||
if self._text_fits_on_slide(separator.join(html_lines)):
|
||||
if not self._text_fits_on_slide(separator.join(html_lines)):
|
||||
html_text, previous_raw = self._binary_chop(formatted,
|
||||
previous_html, previous_raw, html_lines, lines, separator, u'')
|
||||
else:
|
||||
|
@ -374,18 +410,18 @@ class Renderer(object):
|
|||
line = line.strip()
|
||||
html_line = expand_tags(line)
|
||||
# Text too long so go to next page.
|
||||
if self._text_fits_on_slide(previous_html + html_line):
|
||||
if not self._text_fits_on_slide(previous_html + html_line):
|
||||
# Check if there was a verse before the current one and append
|
||||
# it, when it fits on the page.
|
||||
if previous_html:
|
||||
if not self._text_fits_on_slide(previous_html):
|
||||
if self._text_fits_on_slide(previous_html):
|
||||
formatted.append(previous_raw)
|
||||
previous_html = u''
|
||||
previous_raw = u''
|
||||
# Now check if the current verse will fit, if it does
|
||||
# not we have to start to process the verse word by
|
||||
# word.
|
||||
if not self._text_fits_on_slide(html_line):
|
||||
if self._text_fits_on_slide(html_line):
|
||||
previous_html = html_line + line_end
|
||||
previous_raw = line + line_end
|
||||
continue
|
||||
|
@ -442,7 +478,7 @@ class Renderer(object):
|
|||
highest_index = len(html_list) - 1
|
||||
index = int(highest_index / 2)
|
||||
while True:
|
||||
if self._text_fits_on_slide(
|
||||
if not self._text_fits_on_slide(
|
||||
previous_html + separator.join(html_list[:index + 1]).strip()):
|
||||
# We know that it does not fit, so change/calculate the
|
||||
# new index and highest_index accordingly.
|
||||
|
@ -465,8 +501,8 @@ class Renderer(object):
|
|||
else:
|
||||
continue
|
||||
# Check if the remaining elements fit on the slide.
|
||||
if not self._text_fits_on_slide(
|
||||
separator.join(html_list[index + 1:]).strip()):
|
||||
if self._text_fits_on_slide(
|
||||
separator.join(html_list[index + 1:]).strip()):
|
||||
previous_html = separator.join(
|
||||
html_list[index + 1:]).strip() + line_end
|
||||
previous_raw = separator.join(
|
||||
|
@ -488,11 +524,11 @@ class Renderer(object):
|
|||
returned, otherwise ``False``.
|
||||
|
||||
``text``
|
||||
The text to check. It can contain HTML tags.
|
||||
The text to check. It may contain HTML tags.
|
||||
"""
|
||||
self.web_frame.evaluateJavaScript(u'show_text("%s")' %
|
||||
text.replace(u'\\', u'\\\\').replace(u'\"', u'\\\"'))
|
||||
return self.web_frame.contentsSize().height() > self.page_height
|
||||
return self.web_frame.contentsSize().height() <= self.page_height
|
||||
|
||||
def _words_split(self, line):
|
||||
"""
|
||||
|
|
|
@ -52,20 +52,21 @@ class ItemCapabilities(object):
|
|||
"""
|
||||
Provides an enumeration of a serviceitem's capabilities
|
||||
"""
|
||||
AllowsPreview = 1
|
||||
AllowsEdit = 2
|
||||
AllowsMaintain = 3
|
||||
CanPreview = 1
|
||||
CanEdit = 2
|
||||
CanMaintain = 3
|
||||
RequiresMedia = 4
|
||||
AllowsLoop = 5
|
||||
AllowsAdditions = 6
|
||||
CanLoop = 5
|
||||
CanAppend = 6
|
||||
NoLineBreaks = 7
|
||||
OnLoadUpdate = 8
|
||||
AddIfNewItem = 9
|
||||
ProvidesOwnDisplay = 10
|
||||
AllowsDetailedTitleDisplay = 11
|
||||
AllowsVariableStartTime = 12
|
||||
AllowsVirtualSplit = 13
|
||||
AllowsWordSplit = 14
|
||||
HasDetailedTitleDisplay = 11
|
||||
HasVariableStartTime = 12
|
||||
CanSoftBreak = 13
|
||||
CanWordSplit = 14
|
||||
HasBackgroundAudio = 15
|
||||
|
||||
|
||||
class ServiceItem(object):
|
||||
|
@ -115,6 +116,8 @@ class ServiceItem(object):
|
|||
self.end_time = 0
|
||||
self.media_length = 0
|
||||
self.from_service = False
|
||||
self.image_border = u'#000000'
|
||||
self.background_audio = []
|
||||
self._new_item()
|
||||
|
||||
def _new_item(self):
|
||||
|
@ -158,7 +161,7 @@ class ServiceItem(object):
|
|||
"""
|
||||
The render method is what generates the frames for the screen and
|
||||
obtains the display information from the renderemanager.
|
||||
At this point all the slides are build for the given
|
||||
At this point all the slides are built for the given
|
||||
display size.
|
||||
"""
|
||||
log.debug(u'Render called')
|
||||
|
@ -195,7 +198,7 @@ class ServiceItem(object):
|
|||
self.foot_text = \
|
||||
u'<br>'.join([footer for footer in self.raw_footer if footer])
|
||||
|
||||
def add_from_image(self, path, title):
|
||||
def add_from_image(self, path, title, background=None):
|
||||
"""
|
||||
Add an image slide to the service item.
|
||||
|
||||
|
@ -205,9 +208,12 @@ class ServiceItem(object):
|
|||
``title``
|
||||
A title for the slide in the service item.
|
||||
"""
|
||||
if background:
|
||||
self.image_border = background
|
||||
self.service_item_type = ServiceItemType.Image
|
||||
self._raw_frames.append({u'title': title, u'path': path})
|
||||
self.renderer.imageManager.add_image(title, path)
|
||||
self.renderer.imageManager.add_image(title, path, u'image',
|
||||
self.image_border)
|
||||
self._new_item()
|
||||
|
||||
def add_from_text(self, title, raw_slide, verse_tag=None):
|
||||
|
@ -268,7 +274,8 @@ class ServiceItem(object):
|
|||
u'xml_version': self.xml_version,
|
||||
u'start_time': self.start_time,
|
||||
u'end_time': self.end_time,
|
||||
u'media_length': self.media_length
|
||||
u'media_length': self.media_length,
|
||||
u'background_audio': self.background_audio
|
||||
}
|
||||
service_data = []
|
||||
if self.service_item_type == ServiceItemType.Text:
|
||||
|
@ -316,6 +323,8 @@ class ServiceItem(object):
|
|||
self.end_time = header[u'end_time']
|
||||
if u'media_length' in header:
|
||||
self.media_length = header[u'media_length']
|
||||
if u'background_audio' in header:
|
||||
self.background_audio = header[u'background_audio']
|
||||
if self.service_item_type == ServiceItemType.Text:
|
||||
for slide in serviceitem[u'serviceitem'][u'data']:
|
||||
self._raw_frames.append(slide)
|
||||
|
@ -337,7 +346,7 @@ class ServiceItem(object):
|
|||
if self.is_text():
|
||||
return self.title
|
||||
else:
|
||||
if ItemCapabilities.AllowsDetailedTitleDisplay in self.capabilities:
|
||||
if ItemCapabilities.HasDetailedTitleDisplay in self.capabilities:
|
||||
return self._raw_frames[0][u'title']
|
||||
elif len(self._raw_frames) > 1:
|
||||
return self.title
|
||||
|
@ -355,6 +364,8 @@ class ServiceItem(object):
|
|||
"""
|
||||
self._uuid = other._uuid
|
||||
self.notes = other.notes
|
||||
if self.is_capable(ItemCapabilities.HasBackgroundAudio):
|
||||
log.debug(self.background_audio)
|
||||
|
||||
def __eq__(self, other):
|
||||
"""
|
||||
|
|
|
@ -44,6 +44,7 @@ BLANK_THEME_XML = \
|
|||
<name> </name>
|
||||
<background type="image">
|
||||
<filename></filename>
|
||||
<borderColor>#000000</borderColor>
|
||||
</background>
|
||||
<background type="gradient">
|
||||
<startColor>#000000</startColor>
|
||||
|
@ -282,7 +283,7 @@ class ThemeXML(object):
|
|||
# Create direction element
|
||||
self.child_element(background, u'direction', unicode(direction))
|
||||
|
||||
def add_background_image(self, filename):
|
||||
def add_background_image(self, filename, borderColor):
|
||||
"""
|
||||
Add a image background.
|
||||
|
||||
|
@ -294,6 +295,8 @@ class ThemeXML(object):
|
|||
self.theme.appendChild(background)
|
||||
# Create Filename element
|
||||
self.child_element(background, u'filename', filename)
|
||||
# Create endColor element
|
||||
self.child_element(background, u'borderColor', unicode(borderColor))
|
||||
|
||||
def add_font(self, name, color, size, override, fonttype=u'main',
|
||||
bold=u'False', italics=u'False', line_adjustment=0,
|
||||
|
@ -597,7 +600,7 @@ class ThemeXML(object):
|
|||
self.background_direction)
|
||||
else:
|
||||
filename = os.path.split(self.background_filename)[1]
|
||||
self.add_background_image(filename)
|
||||
self.add_background_image(filename, self.background_border_color)
|
||||
self.add_font(self.font_main_name,
|
||||
self.font_main_color,
|
||||
self.font_main_size,
|
||||
|
|
|
@ -116,7 +116,7 @@ class Ui_AboutDialog(object):
|
|||
u'Scott "sguerrieri" Guerrieri',
|
||||
u'Matthias "matthub" Hub', u'Meinert "m2j" Jordan',
|
||||
u'Armin "orangeshirt" K\xf6hler', u'Joshua "milleja46" Miller',
|
||||
u'Stevan "StevanP" Pettit', u'Mattias "mahfiaz" P\xf5ldaru',
|
||||
u'Stevan "ElderP" Pettit', u'Mattias "mahfiaz" P\xf5ldaru',
|
||||
u'Christian "crichter" Richter', u'Philip "Phill" Ridout',
|
||||
u'Simon "samscudder" Scudder', u'Jeffrey "whydoubt" Smith',
|
||||
u'Maikel Stuivenberg', u'Frode "frodus" Woldsund']
|
||||
|
@ -125,7 +125,7 @@ class Ui_AboutDialog(object):
|
|||
packagers = ['Thomas "tabthorpe" Abthorpe (FreeBSD)',
|
||||
u'Tim "TRB143" Bentley (Fedora)',
|
||||
u'Matthias "matthub" Hub (Mac OS X)',
|
||||
u'Stevan "StevanP" Pettit (Windows)',
|
||||
u'Stevan "ElderP" Pettit (Windows)',
|
||||
u'Raoul "superfly" Snyman (Ubuntu)']
|
||||
translators = {
|
||||
u'af': [u'Johan "nuvolari" Mynhardt'],
|
||||
|
|
|
@ -28,7 +28,9 @@
|
|||
import io
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import urllib
|
||||
import urllib2
|
||||
from tempfile import gettempdir
|
||||
from ConfigParser import SafeConfigParser
|
||||
|
||||
|
@ -60,8 +62,13 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
files = self.webAccess.read()
|
||||
self.config.readfp(io.BytesIO(files))
|
||||
self.updateScreenListCombo()
|
||||
self.downloadCanceled = False
|
||||
self.downloading = unicode(translate('OpenLP.FirstTimeWizard',
|
||||
'Downloading %s...'))
|
||||
QtCore.QObject.connect(self.cancelButton,QtCore.SIGNAL('clicked()'),
|
||||
self.onCancelButtonClicked)
|
||||
QtCore.QObject.connect(self.noInternetFinishButton,
|
||||
QtCore.SIGNAL('clicked()'), self.onNoInternetFinishButtonClicked)
|
||||
QtCore.QObject.connect(self,
|
||||
QtCore.SIGNAL(u'currentIdChanged(int)'), self.onCurrentIdChanged)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
|
@ -80,6 +87,10 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
"""
|
||||
self.restart()
|
||||
check_directory_exists(os.path.join(gettempdir(), u'openlp'))
|
||||
self.noInternetFinishButton.setVisible(False)
|
||||
# Check if this is a re-run of the wizard.
|
||||
self.hasRunWizard = QtCore.QSettings().value(
|
||||
u'general/has run wizard', QtCore.QVariant(False)).toBool()
|
||||
# Sort out internet access for downloads
|
||||
if self.webAccess:
|
||||
songs = self.config.get(u'songs', u'languages')
|
||||
|
@ -120,7 +131,7 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
title = self.config.get(u'theme_%s' % theme, u'title')
|
||||
filename = self.config.get(u'theme_%s' % theme, u'filename')
|
||||
screenshot = self.config.get(u'theme_%s' % theme, u'screenshot')
|
||||
urllib.urlretrieve(u'%s/%s' % (self.web, screenshot),
|
||||
urllib.urlretrieve(u'%s%s' % (self.web, screenshot),
|
||||
os.path.join(gettempdir(), u'openlp', screenshot))
|
||||
item = QtGui.QListWidgetItem(title, self.themesListWidget)
|
||||
item.setData(QtCore.Qt.UserRole,
|
||||
|
@ -135,6 +146,7 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
"""
|
||||
Determine the next page in the Wizard to go to.
|
||||
"""
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
if self.currentId() == FirstTimePage.Plugins:
|
||||
if not self.webAccess:
|
||||
return FirstTimePage.NoInternet
|
||||
|
@ -151,16 +163,24 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
"""
|
||||
Detects Page changes and updates as approprate.
|
||||
"""
|
||||
if pageId == FirstTimePage.Defaults:
|
||||
# Keep track of the page we are at. Pressing "Cancel" causes pageId
|
||||
# to be a -1.
|
||||
if pageId != -1:
|
||||
self.lastId = pageId
|
||||
if pageId == FirstTimePage.Plugins:
|
||||
# Set the no internet page text.
|
||||
if self.hasRunWizard:
|
||||
self.noInternetLabel.setText(self.noInternetText)
|
||||
else:
|
||||
self.noInternetLabel.setText(self.noInternetText +
|
||||
self.cancelWizardText)
|
||||
elif pageId == FirstTimePage.Defaults:
|
||||
self.themeComboBox.clear()
|
||||
for iter in xrange(self.themesListWidget.count()):
|
||||
item = self.themesListWidget.item(iter)
|
||||
if item.checkState() == QtCore.Qt.Checked:
|
||||
self.themeComboBox.addItem(item.text())
|
||||
# Check if this is a re-run of the wizard.
|
||||
self.has_run_wizard = QtCore.QSettings().value(
|
||||
u'general/has run wizard', QtCore.QVariant(False)).toBool()
|
||||
if self.has_run_wizard:
|
||||
if self.hasRunWizard:
|
||||
# Add any existing themes to list.
|
||||
for theme in self.parent().themeManagerContents.getThemes():
|
||||
index = self.themeComboBox.findText(theme)
|
||||
|
@ -172,12 +192,21 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
# Pre-select the current default theme.
|
||||
index = self.themeComboBox.findText(default_theme)
|
||||
self.themeComboBox.setCurrentIndex(index)
|
||||
elif pageId == FirstTimePage.NoInternet:
|
||||
self.backButton.setVisible(False)
|
||||
self.nextButton.setVisible(False)
|
||||
self.noInternetFinishButton.setVisible(True)
|
||||
if self.hasRunWizard:
|
||||
self.cancelButton.setVisible(False)
|
||||
elif pageId == FirstTimePage.Progress:
|
||||
Receiver.send_message(u'cursor_busy')
|
||||
self._preWizard()
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
self._performWizard()
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
self._postWizard()
|
||||
Receiver.send_message(u'cursor_normal')
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
|
||||
def updateScreenListCombo(self):
|
||||
"""
|
||||
|
@ -188,6 +217,53 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
self.displayComboBox.addItems(self.screens.get_screen_list())
|
||||
self.displayComboBox.setCurrentIndex(self.displayComboBox.count() - 1)
|
||||
|
||||
def onCancelButtonClicked(self):
|
||||
"""
|
||||
Process the pressing of the cancel button.
|
||||
"""
|
||||
if self.lastId == FirstTimePage.NoInternet or \
|
||||
(self.lastId <= FirstTimePage.Plugins and \
|
||||
not self.hasRunWizard):
|
||||
QtCore.QCoreApplication.exit()
|
||||
sys.exit()
|
||||
self.downloadCanceled = True
|
||||
Receiver.send_message(u'cursor_normal')
|
||||
|
||||
def onNoInternetFinishButtonClicked(self):
|
||||
"""
|
||||
Process the pressing of the "Finish" button on the No Internet page.
|
||||
"""
|
||||
Receiver.send_message(u'cursor_busy')
|
||||
self._performWizard()
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
Receiver.send_message(u'cursor_normal')
|
||||
QtCore.QSettings().setValue(u'general/has run wizard',
|
||||
QtCore.QVariant(True))
|
||||
self.close()
|
||||
|
||||
def urlGetFile(self, url, fpath):
|
||||
""""
|
||||
Download a file given a URL. The file is retrieved in chunks, giving
|
||||
the ability to cancel the download at any point.
|
||||
"""
|
||||
block_count = 0
|
||||
block_size = 4096
|
||||
urlfile = urllib2.urlopen(url)
|
||||
filesize = urlfile.headers["Content-Length"]
|
||||
filename = open(fpath, "wb")
|
||||
# Download until finished or canceled.
|
||||
while not self.downloadCanceled:
|
||||
data = urlfile.read(block_size)
|
||||
if not data:
|
||||
break
|
||||
filename.write(data)
|
||||
block_count += 1
|
||||
self._downloadProgress(block_count, block_size, filesize)
|
||||
filename.close()
|
||||
# Delete file if canceled, it may be a partial file.
|
||||
if self.downloadCanceled:
|
||||
os.remove(fpath)
|
||||
|
||||
def _getFileSize(self, url):
|
||||
site = urllib.urlopen(url)
|
||||
meta = site.info()
|
||||
|
@ -197,7 +273,7 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
increment = (count * block_size) - self.previous_size
|
||||
self._incrementProgressBar(None, increment)
|
||||
self.previous_size = count * block_size
|
||||
|
||||
|
||||
def _incrementProgressBar(self, status_text, increment=1):
|
||||
"""
|
||||
Update the wizard progress page.
|
||||
|
@ -219,6 +295,8 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
Prepare the UI for the process.
|
||||
"""
|
||||
self.max_progress = 0
|
||||
self.finishButton.setVisible(False)
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
# Loop through the songs list and increase for each selected item
|
||||
for i in xrange(self.songsListWidget.count()):
|
||||
item = self.songsListWidget.item(i)
|
||||
|
@ -242,7 +320,6 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
filename = item.data(QtCore.Qt.UserRole).toString()
|
||||
size = self._getFileSize(u'%s%s' % (self.web, filename))
|
||||
self.max_progress += size
|
||||
self.finishButton.setVisible(False)
|
||||
if self.max_progress:
|
||||
# Add on 2 for plugins status setting plus a "finished" point.
|
||||
self.max_progress = self.max_progress + 2
|
||||
|
@ -266,7 +343,7 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
"""
|
||||
if self.max_progress:
|
||||
self.progressBar.setValue(self.progressBar.maximum())
|
||||
if self.has_run_wizard:
|
||||
if self.hasRunWizard:
|
||||
self.progressLabel.setText(translate('OpenLP.FirstTimeWizard',
|
||||
'Download complete.'
|
||||
' Click the finish button to return to OpenLP.'))
|
||||
|
@ -275,7 +352,7 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
'Download complete.'
|
||||
' Click the finish button to start OpenLP.'))
|
||||
else:
|
||||
if self.has_run_wizard:
|
||||
if self.hasRunWizard:
|
||||
self.progressLabel.setText(translate('OpenLP.FirstTimeWizard',
|
||||
'Click the finish button to return to OpenLP.'))
|
||||
else:
|
||||
|
@ -304,42 +381,42 @@ class FirstTimeForm(QtGui.QWizard, Ui_FirstTimeWizard):
|
|||
self._setPluginStatus(self.customCheckBox, u'custom/status')
|
||||
self._setPluginStatus(self.songUsageCheckBox, u'songusage/status')
|
||||
self._setPluginStatus(self.alertCheckBox, u'alerts/status')
|
||||
# Build directories for downloads
|
||||
songs_destination = os.path.join(unicode(gettempdir()), u'openlp')
|
||||
bibles_destination = AppLocation.get_section_data_path(u'bibles')
|
||||
themes_destination = AppLocation.get_section_data_path(u'themes')
|
||||
# Download songs
|
||||
for i in xrange(self.songsListWidget.count()):
|
||||
item = self.songsListWidget.item(i)
|
||||
if item.checkState() == QtCore.Qt.Checked:
|
||||
filename = item.data(QtCore.Qt.UserRole).toString()
|
||||
self._incrementProgressBar(self.downloading % filename, 0)
|
||||
self.previous_size = 0
|
||||
destination = os.path.join(songs_destination, unicode(filename))
|
||||
urllib.urlretrieve(u'%s%s' % (self.web, filename), destination,
|
||||
self._downloadProgress)
|
||||
# Download Bibles
|
||||
bibles_iterator = QtGui.QTreeWidgetItemIterator(self.biblesTreeWidget)
|
||||
while bibles_iterator.value():
|
||||
item = bibles_iterator.value()
|
||||
if item.parent() and item.checkState(0) == QtCore.Qt.Checked:
|
||||
bible = unicode(item.data(0, QtCore.Qt.UserRole).toString())
|
||||
self._incrementProgressBar(self.downloading % bible, 0)
|
||||
self.previous_size = 0
|
||||
urllib.urlretrieve(u'%s%s' % (self.web, bible),
|
||||
os.path.join(bibles_destination, bible),
|
||||
self._downloadProgress)
|
||||
bibles_iterator += 1
|
||||
# Download themes
|
||||
for i in xrange(self.themesListWidget.count()):
|
||||
item = self.themesListWidget.item(i)
|
||||
if item.checkState() == QtCore.Qt.Checked:
|
||||
theme = unicode(item.data(QtCore.Qt.UserRole).toString())
|
||||
self._incrementProgressBar(self.downloading % theme, 0)
|
||||
self.previous_size = 0
|
||||
urllib.urlretrieve(u'%s%s' % (self.web, theme),
|
||||
os.path.join(themes_destination, theme),
|
||||
self._downloadProgress)
|
||||
if self.webAccess:
|
||||
# Build directories for downloads
|
||||
songs_destination = os.path.join(unicode(gettempdir()), u'openlp')
|
||||
bibles_destination = AppLocation.get_section_data_path(u'bibles')
|
||||
themes_destination = AppLocation.get_section_data_path(u'themes')
|
||||
# Download songs
|
||||
for i in xrange(self.songsListWidget.count()):
|
||||
item = self.songsListWidget.item(i)
|
||||
if item.checkState() == QtCore.Qt.Checked:
|
||||
filename = item.data(QtCore.Qt.UserRole).toString()
|
||||
self._incrementProgressBar(self.downloading % filename, 0)
|
||||
self.previous_size = 0
|
||||
destination = os.path.join(songs_destination,
|
||||
unicode(filename))
|
||||
self.urlGetFile(u'%s%s' % (self.web, filename), destination)
|
||||
# Download Bibles
|
||||
bibles_iterator = QtGui.QTreeWidgetItemIterator(
|
||||
self.biblesTreeWidget)
|
||||
while bibles_iterator.value():
|
||||
item = bibles_iterator.value()
|
||||
if item.parent() and item.checkState(0) == QtCore.Qt.Checked:
|
||||
bible = unicode(item.data(0, QtCore.Qt.UserRole).toString())
|
||||
self._incrementProgressBar(self.downloading % bible, 0)
|
||||
self.previous_size = 0
|
||||
self.urlGetFile(u'%s%s' % (self.web, bible),
|
||||
os.path.join(bibles_destination, bible))
|
||||
bibles_iterator += 1
|
||||
# Download themes
|
||||
for i in xrange(self.themesListWidget.count()):
|
||||
item = self.themesListWidget.item(i)
|
||||
if item.checkState() == QtCore.Qt.Checked:
|
||||
theme = unicode(item.data(QtCore.Qt.UserRole).toString())
|
||||
self._incrementProgressBar(self.downloading % theme, 0)
|
||||
self.previous_size = 0
|
||||
self.urlGetFile(u'%s%s' % (self.web, theme),
|
||||
os.path.join(themes_destination, theme))
|
||||
# Set Default Display
|
||||
if self.displayComboBox.currentIndex() != -1:
|
||||
QtCore.QSettings().setValue(u'General/monitor',
|
||||
|
|
|
@ -51,8 +51,10 @@ class Ui_FirstTimeWizard(object):
|
|||
FirstTimeWizard.setWizardStyle(QtGui.QWizard.ModernStyle)
|
||||
FirstTimeWizard.setOptions(QtGui.QWizard.IndependentPages |
|
||||
QtGui.QWizard.NoBackButtonOnStartPage |
|
||||
QtGui.QWizard.NoBackButtonOnLastPage)
|
||||
QtGui.QWizard.NoBackButtonOnLastPage |
|
||||
QtGui.QWizard.HaveCustomButton1)
|
||||
self.finishButton = self.button(QtGui.QWizard.FinishButton)
|
||||
self.noInternetFinishButton = self.button(QtGui.QWizard.CustomButton1)
|
||||
self.cancelButton = self.button(QtGui.QWizard.CancelButton)
|
||||
self.nextButton = self.button(QtGui.QWizard.NextButton)
|
||||
self.backButton = self.button(QtGui.QWizard.BackButton)
|
||||
|
@ -189,9 +191,7 @@ class Ui_FirstTimeWizard(object):
|
|||
self.progressBar.setObjectName(u'progressBar')
|
||||
self.progressLayout.addWidget(self.progressBar)
|
||||
FirstTimeWizard.setPage(FirstTimePage.Progress, self.progressPage)
|
||||
|
||||
self.retranslateUi(FirstTimeWizard)
|
||||
QtCore.QMetaObject.connectSlotsByName(FirstTimeWizard)
|
||||
|
||||
def retranslateUi(self, FirstTimeWizard):
|
||||
FirstTimeWizard.setWindowTitle(translate(
|
||||
|
@ -230,14 +230,17 @@ class Ui_FirstTimeWizard(object):
|
|||
self.noInternetPage.setSubTitle(translate(
|
||||
'OpenLP.FirstTimeWizard',
|
||||
'Unable to detect an Internet connection.'))
|
||||
self.noInternetLabel.setText(translate('OpenLP.FirstTimeWizard',
|
||||
self.noInternetText = translate('OpenLP.FirstTimeWizard',
|
||||
'No Internet connection was found. The First Time Wizard needs an '
|
||||
'Internet connection in order to be able to download sample '
|
||||
'songs, Bibles and themes.\n\nTo re-run the First Time Wizard and '
|
||||
'import this sample data at a later stage, press the cancel '
|
||||
'button now, check your Internet connection, and restart OpenLP.'
|
||||
'\n\nTo cancel the First Time Wizard completely, press the finish '
|
||||
'button now.'))
|
||||
'songs, Bibles and themes. Press the Finish button now to start '
|
||||
'OpenLP with initial settings and no sample data.\n\nTo re-run the '
|
||||
'First Time Wizard and import this sample data at a later time, '
|
||||
'check your Internet connection and re-run this wizard by '
|
||||
'selecting "Tools/Re-run First Time Wizard" from OpenLP.')
|
||||
self.cancelWizardText = translate('OpenLP.FirstTimeWizard',
|
||||
'\n\nTo cancel the First Time Wizard completely (and not start '
|
||||
'OpenLP), press the Cancel button now.')
|
||||
self.songsPage.setTitle(translate('OpenLP.FirstTimeWizard',
|
||||
'Sample Songs'))
|
||||
self.songsPage.setSubTitle(translate('OpenLP.FirstTimeWizard',
|
||||
|
@ -260,3 +263,5 @@ class Ui_FirstTimeWizard(object):
|
|||
'Select default theme:'))
|
||||
self.progressLabel.setText(translate('OpenLP.FirstTimeWizard',
|
||||
'Starting configuration process...'))
|
||||
FirstTimeWizard.setButtonText(QtGui.QWizard.CustomButton1,
|
||||
translate('OpenLP.FirstTimeWizard', 'Finish'))
|
||||
|
|
|
@ -170,6 +170,15 @@ class GeneralTab(SettingsTab):
|
|||
self.customHeightValueEdit.setMaximum(9999)
|
||||
self.displayLayout.addWidget(self.customHeightValueEdit, 4, 3)
|
||||
self.rightLayout.addWidget(self.displayGroupBox)
|
||||
# Background audio
|
||||
self.audioGroupBox = QtGui.QGroupBox(self.rightColumn)
|
||||
self.audioGroupBox.setObjectName(u'audioGroupBox')
|
||||
self.audioLayout = QtGui.QVBoxLayout(self.audioGroupBox)
|
||||
self.audioLayout.setObjectName(u'audioLayout')
|
||||
self.startPausedCheckBox = QtGui.QCheckBox(self.audioGroupBox)
|
||||
self.startPausedCheckBox.setObjectName(u'startPausedCheckBox')
|
||||
self.audioLayout.addWidget(self.startPausedCheckBox)
|
||||
self.rightLayout.addWidget(self.audioGroupBox)
|
||||
self.rightLayout.addStretch()
|
||||
# Signals and slots
|
||||
QtCore.QObject.connect(self.overrideCheckBox,
|
||||
|
@ -243,6 +252,10 @@ class GeneralTab(SettingsTab):
|
|||
self.customYLabel.setText(translate('OpenLP.GeneralTab', 'Y'))
|
||||
self.customHeightLabel.setText(translate('OpenLP.GeneralTab', 'Height'))
|
||||
self.customWidthLabel.setText(translate('OpenLP.GeneralTab', 'Width'))
|
||||
self.audioGroupBox.setTitle(
|
||||
translate('OpenLP.GeneralTab', 'Background Audio'))
|
||||
self.startPausedCheckBox.setText(
|
||||
translate('OpenLP.GeneralTab', 'Start background audio paused'))
|
||||
|
||||
def load(self):
|
||||
"""
|
||||
|
@ -290,6 +303,8 @@ class GeneralTab(SettingsTab):
|
|||
QtCore.QVariant(self.screens.current[u'size'].height())).toInt()[0])
|
||||
self.customWidthValueEdit.setValue(settings.value(u'width',
|
||||
QtCore.QVariant(self.screens.current[u'size'].width())).toInt()[0])
|
||||
self.startPausedCheckBox.setChecked(settings.value(
|
||||
u'audio start paused', QtCore.QVariant(True)).toBool())
|
||||
settings.endGroup()
|
||||
self.customXValueEdit.setEnabled(self.overrideCheckBox.isChecked())
|
||||
self.customYValueEdit.setEnabled(self.overrideCheckBox.isChecked())
|
||||
|
@ -341,6 +356,8 @@ class GeneralTab(SettingsTab):
|
|||
QtCore.QVariant(self.customWidthValueEdit.value()))
|
||||
settings.setValue(u'override position',
|
||||
QtCore.QVariant(self.overrideCheckBox.isChecked()))
|
||||
settings.setValue(u'audio start paused',
|
||||
QtCore.QVariant(self.startPausedCheckBox.isChecked()))
|
||||
settings.endGroup()
|
||||
# On save update the screens as well
|
||||
self.postSetUp(True)
|
||||
|
|
|
@ -62,6 +62,10 @@ class MainDisplay(QtGui.QGraphicsView):
|
|||
self.override = {}
|
||||
self.retranslateUi()
|
||||
self.mediaObject = None
|
||||
if live:
|
||||
self.audioPlayer = AudioPlayer(self)
|
||||
else:
|
||||
self.audioPlayer = None
|
||||
self.firstTime = True
|
||||
self.setStyleSheet(u'border: 0px; margin: 0px; padding: 0px;')
|
||||
self.setWindowFlags(QtCore.Qt.FramelessWindowHint | QtCore.Qt.Tool |
|
||||
|
@ -228,11 +232,11 @@ class MainDisplay(QtGui.QGraphicsView):
|
|||
shrinkItem.setVisible(False)
|
||||
self.setGeometry(self.screen[u'size'])
|
||||
|
||||
def directImage(self, name, path):
|
||||
def directImage(self, name, path, background):
|
||||
"""
|
||||
API for replacement backgrounds so Images are added directly to cache
|
||||
"""
|
||||
self.imageManager.add_image(name, path)
|
||||
self.imageManager.add_image(name, path, u'image', background)
|
||||
if hasattr(self, u'serviceItem'):
|
||||
self.override[u'image'] = name
|
||||
self.override[u'theme'] = self.serviceItem.themedata.theme_name
|
||||
|
@ -587,61 +591,76 @@ class AudioPlayer(QtCore.QObject):
|
|||
"""
|
||||
log.debug(u'AudioPlayer Initialisation started')
|
||||
QtCore.QObject.__init__(self, parent)
|
||||
self.message = None
|
||||
self.currentIndex = -1
|
||||
self.playlist = []
|
||||
self.mediaObject = Phonon.MediaObject()
|
||||
self.audioObject = Phonon.AudioOutput(Phonon.VideoCategory)
|
||||
Phonon.createPath(self.mediaObject, self.audioObject)
|
||||
QtCore.QObject.connect(self.mediaObject,
|
||||
QtCore.SIGNAL(u'aboutToFinish()'), self.onAboutToFinish)
|
||||
|
||||
def setup(self):
|
||||
"""
|
||||
Sets up the Audio Player for use
|
||||
"""
|
||||
log.debug(u'AudioPlayer Setup')
|
||||
|
||||
def close(self):
|
||||
def __del__(self):
|
||||
"""
|
||||
Shutting down so clean up connections
|
||||
"""
|
||||
self.onMediaStop()
|
||||
self.stop()
|
||||
for path in self.mediaObject.outputPaths():
|
||||
path.disconnect()
|
||||
QtCore.QObject.__del__(self)
|
||||
|
||||
def onMediaQueue(self, message):
|
||||
def onAboutToFinish(self):
|
||||
"""
|
||||
Set up a video to play from the serviceitem.
|
||||
Just before the audio player finishes the current track, queue the next
|
||||
item in the playlist, if there is one.
|
||||
"""
|
||||
log.debug(u'AudioPlayer Queue new media message %s' % message)
|
||||
mfile = os.path.join(message[0].get_frame_path(),
|
||||
message[0].get_frame_title())
|
||||
self.mediaObject.setCurrentSource(Phonon.MediaSource(mfile))
|
||||
self.onMediaPlay()
|
||||
self.currentIndex += 1
|
||||
if len(self.playlist) > self.currentIndex:
|
||||
self.mediaObject.enqueue(self.playlist[self.currentIndex])
|
||||
|
||||
def onMediaPlay(self):
|
||||
def connectVolumeSlider(self, slider):
|
||||
slider.setAudioOutput(self.audioObject)
|
||||
|
||||
def reset(self):
|
||||
"""
|
||||
We want to play the play so start it
|
||||
Reset the audio player, clearing the playlist and the queue.
|
||||
"""
|
||||
log.debug(u'AudioPlayer _play called')
|
||||
self.currentIndex = -1
|
||||
self.playlist = []
|
||||
self.stop()
|
||||
self.mediaObject.clear()
|
||||
|
||||
def play(self):
|
||||
"""
|
||||
We want to play the file so start it
|
||||
"""
|
||||
log.debug(u'AudioPlayer.play() called')
|
||||
if self.currentIndex == -1:
|
||||
self.onAboutToFinish()
|
||||
self.mediaObject.play()
|
||||
|
||||
def onMediaPause(self):
|
||||
def pause(self):
|
||||
"""
|
||||
Pause the Audio
|
||||
"""
|
||||
log.debug(u'AudioPlayer Media paused by user')
|
||||
log.debug(u'AudioPlayer.pause() called')
|
||||
self.mediaObject.pause()
|
||||
|
||||
def onMediaStop(self):
|
||||
def stop(self):
|
||||
"""
|
||||
Stop the Audio and clean up
|
||||
"""
|
||||
log.debug(u'AudioPlayer Media stopped by user')
|
||||
self.message = None
|
||||
log.debug(u'AudioPlayer.stop() called')
|
||||
self.mediaObject.stop()
|
||||
self.onMediaFinish()
|
||||
|
||||
def onMediaFinish(self):
|
||||
def addToPlaylist(self, filenames):
|
||||
"""
|
||||
Clean up the Object queue
|
||||
Add another file to the playlist.
|
||||
|
||||
``filename``
|
||||
The file to add to the playlist.
|
||||
"""
|
||||
log.debug(u'AudioPlayer Reached end of media playlist')
|
||||
self.mediaObject.clearQueue()
|
||||
if not isinstance(filenames, list):
|
||||
filenames = [filenames]
|
||||
for filename in filenames:
|
||||
self.playlist.append(Phonon.MediaSource(filename))
|
||||
|
||||
|
|
|
@ -30,11 +30,13 @@ import os
|
|||
import sys
|
||||
import shutil
|
||||
from tempfile import gettempdir
|
||||
from datetime import datetime
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from openlp.core.lib import Renderer, build_icon, OpenLPDockWidget, \
|
||||
PluginManager, Receiver, translate, ImageManager, PluginStatus
|
||||
PluginManager, Receiver, translate, ImageManager, PluginStatus, \
|
||||
SettingsManager
|
||||
from openlp.core.lib.ui import UiStrings, base_action, checkable_action, \
|
||||
icon_action, shortcut_action
|
||||
from openlp.core.ui import AboutForm, SettingsForm, ServiceManager, \
|
||||
|
@ -214,7 +216,7 @@ class Ui_MainWindow(object):
|
|||
self.mediaManagerDock.isVisible(), UiStrings().View)
|
||||
self.viewThemeManagerItem = shortcut_action(mainWindow,
|
||||
u'viewThemeManagerItem', [QtGui.QKeySequence(u'F10')],
|
||||
self.toggleThemeManager, u':/system/system_thememanager.png',
|
||||
self.toggleThemeManager, u':/system/system_thememanager.png',
|
||||
self.themeManagerDock.isVisible(), UiStrings().View)
|
||||
self.viewServiceManagerItem = shortcut_action(mainWindow,
|
||||
u'viewServiceManagerItem', [QtGui.QKeySequence(u'F9')],
|
||||
|
@ -284,6 +286,10 @@ class Ui_MainWindow(object):
|
|||
self.settingsConfigureItem = icon_action(mainWindow,
|
||||
u'settingsConfigureItem', u':/system/system_settings.png',
|
||||
category=UiStrings().Settings)
|
||||
self.settingsImportItem = base_action(mainWindow,
|
||||
u'settingsImportItem', category=UiStrings().Settings)
|
||||
self.settingsExportItem = base_action(mainWindow,
|
||||
u'settingsExportItem', category=UiStrings().Settings)
|
||||
action_list.add_category(UiStrings().Help, CategoryOrder.standardMenu)
|
||||
self.aboutItem = shortcut_action(mainWindow, u'aboutItem',
|
||||
[QtGui.QKeySequence(u'Ctrl+F1')], self.onAboutItemClicked,
|
||||
|
@ -301,10 +307,10 @@ class Ui_MainWindow(object):
|
|||
u':/system/system_online_help.png', category=UiStrings().Help)
|
||||
self.webSiteItem = base_action(
|
||||
mainWindow, u'webSiteItem', category=UiStrings().Help)
|
||||
add_actions(self.fileImportMenu,
|
||||
(self.importThemeItem, self.importLanguageItem))
|
||||
add_actions(self.fileExportMenu,
|
||||
(self.exportThemeItem, self.exportLanguageItem))
|
||||
add_actions(self.fileImportMenu, (self.settingsImportItem, None,
|
||||
self.importThemeItem, self.importLanguageItem))
|
||||
add_actions(self.fileExportMenu, (self.settingsExportItem, None,
|
||||
self.exportThemeItem, self.exportLanguageItem))
|
||||
add_actions(self.fileMenu, (self.fileNewItem, self.fileOpenItem,
|
||||
self.fileSaveItem, self.fileSaveAsItem,
|
||||
self.recentFilesMenu.menuAction(), None,
|
||||
|
@ -357,6 +363,7 @@ class Ui_MainWindow(object):
|
|||
self.importLanguageItem.setVisible(False)
|
||||
self.exportLanguageItem.setVisible(False)
|
||||
self.setLockPanel(panelLocked)
|
||||
self.settingsImported = False
|
||||
|
||||
def retranslateUi(self, mainWindow):
|
||||
"""
|
||||
|
@ -420,6 +427,15 @@ class Ui_MainWindow(object):
|
|||
translate('OpenLP.MainWindow', 'Configure &Formatting Tags...'))
|
||||
self.settingsConfigureItem.setText(
|
||||
translate('OpenLP.MainWindow', '&Configure OpenLP...'))
|
||||
self.settingsExportItem.setStatusTip(translate('OpenLP.MainWindow',
|
||||
'Export OpenLP settings to a specified *.config file'))
|
||||
self.settingsExportItem.setText(
|
||||
translate('OpenLP.MainWindow', 'Settings'))
|
||||
self.settingsImportItem.setStatusTip(translate('OpenLP.MainWindow',
|
||||
'Import OpenLP settings from a specified *.config file previously '
|
||||
'exported on this or another machine'))
|
||||
self.settingsImportItem.setText(
|
||||
translate('OpenLP.MainWindow', 'Settings'))
|
||||
self.viewMediaManagerItem.setText(
|
||||
translate('OpenLP.MainWindow', '&Media Manager'))
|
||||
self.viewMediaManagerItem.setToolTip(
|
||||
|
@ -523,8 +539,13 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
# (not for use by plugins)
|
||||
self.uiSettingsSection = u'user interface'
|
||||
self.generalSettingsSection = u'general'
|
||||
self.serviceSettingsSection = u'servicemanager'
|
||||
self.advancedlSettingsSection = u'advanced'
|
||||
self.shortcutsSettingsSection = u'shortcuts'
|
||||
self.servicemanagerSettingsSection = u'servicemanager'
|
||||
self.songsSettingsSection = u'songs'
|
||||
self.themesSettingsSection = u'themes'
|
||||
self.displayTagsSection = u'displayTags'
|
||||
self.headerSection = u'SettingsImport'
|
||||
self.serviceNotSaved = False
|
||||
self.aboutForm = AboutForm(self)
|
||||
self.settingsForm = SettingsForm(self, self)
|
||||
|
@ -573,6 +594,10 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
QtCore.SIGNAL(u'triggered()'), self.onSettingsConfigureItemClicked)
|
||||
QtCore.QObject.connect(self.settingsShortcutsItem,
|
||||
QtCore.SIGNAL(u'triggered()'), self.onSettingsShortcutsItemClicked)
|
||||
QtCore.QObject.connect(self.settingsImportItem,
|
||||
QtCore.SIGNAL(u'triggered()'), self.onSettingsImportItemClicked)
|
||||
QtCore.QObject.connect(self.settingsExportItem,
|
||||
QtCore.SIGNAL(u'triggered()'), self.onSettingsExportItemClicked)
|
||||
# i18n set signals for languages
|
||||
self.languageGroup.triggered.connect(LanguageManager.set_language)
|
||||
QtCore.QObject.connect(self.modeDefaultItem,
|
||||
|
@ -751,22 +776,25 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
return
|
||||
Receiver.send_message(u'cursor_busy')
|
||||
screens = ScreenList.get_instance()
|
||||
if FirstTimeForm(screens, self).exec_() == QtGui.QDialog.Accepted:
|
||||
self.firstTime()
|
||||
for plugin in self.pluginManager.plugins:
|
||||
self.activePlugin = plugin
|
||||
oldStatus = self.activePlugin.status
|
||||
self.activePlugin.setStatus()
|
||||
if oldStatus != self.activePlugin.status:
|
||||
if self.activePlugin.status == PluginStatus.Active:
|
||||
self.activePlugin.toggleStatus(PluginStatus.Active)
|
||||
self.activePlugin.appStartup()
|
||||
else:
|
||||
self.activePlugin.toggleStatus(PluginStatus.Inactive)
|
||||
self.themeManagerContents.configUpdated()
|
||||
self.themeManagerContents.loadThemes(True)
|
||||
Receiver.send_message(u'theme_update_global',
|
||||
self.themeManagerContents.global_theme)
|
||||
FirstTimeForm(screens, self).exec_()
|
||||
self.firstTime()
|
||||
for plugin in self.pluginManager.plugins:
|
||||
self.activePlugin = plugin
|
||||
oldStatus = self.activePlugin.status
|
||||
self.activePlugin.setStatus()
|
||||
if oldStatus != self.activePlugin.status:
|
||||
if self.activePlugin.status == PluginStatus.Active:
|
||||
self.activePlugin.toggleStatus(PluginStatus.Active)
|
||||
self.activePlugin.appStartup()
|
||||
else:
|
||||
self.activePlugin.toggleStatus(PluginStatus.Inactive)
|
||||
self.themeManagerContents.configUpdated()
|
||||
self.themeManagerContents.loadThemes(True)
|
||||
Receiver.send_message(u'theme_update_global',
|
||||
self.themeManagerContents.global_theme)
|
||||
# Check if any Bibles downloaded. If there are, they will be
|
||||
# processed.
|
||||
Receiver.send_message(u'bibles_load_list', True)
|
||||
|
||||
def blankCheck(self):
|
||||
"""
|
||||
|
@ -868,6 +896,171 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
if self.shortcutForm.exec_():
|
||||
self.shortcutForm.save()
|
||||
|
||||
def onSettingsImportItemClicked(self):
|
||||
"""
|
||||
Import settings from an export INI file
|
||||
"""
|
||||
answer = QtGui.QMessageBox.critical(self,
|
||||
translate('OpenLP.MainWindow', 'Import settings?'),
|
||||
translate('OpenLP.MainWindow',
|
||||
'Are you sure you want to import settings?\n\n'
|
||||
'Importing settings will make permanent changes to your current '
|
||||
'OpenLP configuration.\n\n'
|
||||
'Importing incorrect settings may cause erratic behaviour or '
|
||||
'OpenLP to terminate abnormally.'),
|
||||
QtGui.QMessageBox.StandardButtons(
|
||||
QtGui.QMessageBox.Yes |
|
||||
QtGui.QMessageBox.No),
|
||||
QtGui.QMessageBox.No)
|
||||
if answer == QtGui.QMessageBox.No:
|
||||
return
|
||||
import_file_name = unicode(QtGui.QFileDialog.getOpenFileName(self,
|
||||
translate('OpenLP.MainWindow', 'Open File'),
|
||||
'',
|
||||
translate('OpenLP.MainWindow',
|
||||
'OpenLP Export Settings Files (*.conf)')))
|
||||
if not import_file_name:
|
||||
return
|
||||
setting_sections = []
|
||||
# Add main sections.
|
||||
setting_sections.extend([self.generalSettingsSection])
|
||||
setting_sections.extend([self.advancedlSettingsSection])
|
||||
setting_sections.extend([self.uiSettingsSection])
|
||||
setting_sections.extend([self.shortcutsSettingsSection])
|
||||
setting_sections.extend([self.servicemanagerSettingsSection])
|
||||
setting_sections.extend([self.themesSettingsSection])
|
||||
setting_sections.extend([self.displayTagsSection])
|
||||
setting_sections.extend([self.headerSection])
|
||||
# Add plugin sections.
|
||||
for plugin in self.pluginManager.plugins:
|
||||
setting_sections.extend([plugin.name])
|
||||
settings = QtCore.QSettings()
|
||||
import_settings = QtCore.QSettings(import_file_name,
|
||||
QtCore.QSettings.IniFormat)
|
||||
import_keys = import_settings.allKeys()
|
||||
for section_key in import_keys:
|
||||
# We need to handle the really bad files.
|
||||
try:
|
||||
section, key = section_key.split(u'/')
|
||||
except ValueError:
|
||||
section = u'unknown'
|
||||
key = u''
|
||||
# Switch General back to lowercase.
|
||||
if section == u'General':
|
||||
section = u'general'
|
||||
section_key = section + "/" + key
|
||||
# Make sure it's a valid section for us.
|
||||
if not section in setting_sections:
|
||||
QtGui.QMessageBox.critical(self,
|
||||
translate('OpenLP.MainWindow', 'Import settings'),
|
||||
translate('OpenLP.MainWindow',
|
||||
'The file you selected does appear to be a valid OpenLP '
|
||||
'settings file.\n\n'
|
||||
'Section [%s] is not valid \n\n'
|
||||
'Processing has terminated and no changed have been made.'
|
||||
% section),
|
||||
QtGui.QMessageBox.StandardButtons(
|
||||
QtGui.QMessageBox.Ok))
|
||||
return
|
||||
# We have a good file, import it.
|
||||
for section_key in import_keys:
|
||||
value = import_settings.value(section_key)
|
||||
settings.setValue(u'%s' % (section_key) ,
|
||||
QtCore.QVariant(value))
|
||||
now = datetime.now()
|
||||
settings.beginGroup(self.headerSection)
|
||||
settings.setValue( u'file_imported' , QtCore.QVariant(import_file_name))
|
||||
settings.setValue(u'file_date_imported',
|
||||
now.strftime("%Y-%m-%d %H:%M"))
|
||||
settings.endGroup()
|
||||
settings.sync()
|
||||
# We must do an immediate restart or current configuration will
|
||||
# overwrite what was just imported when application terminates
|
||||
# normally. We need to exit without saving configuration.
|
||||
QtGui.QMessageBox.information(self,
|
||||
translate('OpenLP.MainWindow', 'Import settings'),
|
||||
translate('OpenLP.MainWindow',
|
||||
'OpenLP will now close. Imported settings will '
|
||||
'be applied the next time you start OpenLP.'),
|
||||
QtGui.QMessageBox.StandardButtons(
|
||||
QtGui.QMessageBox.Ok))
|
||||
self.settingsImported = True
|
||||
self.cleanUp()
|
||||
QtCore.QCoreApplication.exit()
|
||||
|
||||
def onSettingsExportItemClicked(self):
|
||||
"""
|
||||
Export settings to a .conf file in INI format
|
||||
"""
|
||||
export_file_name = unicode(QtGui.QFileDialog.getSaveFileName(self,
|
||||
translate('OpenLP.MainWindow', 'Export Settings File'), '',
|
||||
translate('OpenLP.MainWindow',
|
||||
'OpenLP Export Settings File (*.conf)')))
|
||||
if not export_file_name:
|
||||
return
|
||||
# Make sure it's a .conf file.
|
||||
if not export_file_name.endswith(u'conf'):
|
||||
export_file_name = export_file_name + u'.conf'
|
||||
temp_file = os.path.join(unicode(gettempdir()),
|
||||
u'openlp', u'exportConf.tmp')
|
||||
self.saveSettings()
|
||||
setting_sections = []
|
||||
# Add main sections.
|
||||
setting_sections.extend([self.generalSettingsSection])
|
||||
setting_sections.extend([self.advancedlSettingsSection])
|
||||
setting_sections.extend([self.uiSettingsSection])
|
||||
setting_sections.extend([self.shortcutsSettingsSection])
|
||||
setting_sections.extend([self.servicemanagerSettingsSection])
|
||||
setting_sections.extend([self.themesSettingsSection])
|
||||
setting_sections.extend([self.displayTagsSection])
|
||||
# Add plugin sections.
|
||||
for plugin in self.pluginManager.plugins:
|
||||
setting_sections.extend([plugin.name])
|
||||
# Delete old files if found.
|
||||
if os.path.exists(temp_file):
|
||||
os.remove(temp_file)
|
||||
if os.path.exists(export_file_name):
|
||||
os.remove(export_file_name)
|
||||
settings = QtCore.QSettings()
|
||||
settings.remove(self.headerSection)
|
||||
# Get the settings.
|
||||
keys = settings.allKeys()
|
||||
export_settings = QtCore.QSettings(temp_file,
|
||||
QtCore.QSettings.IniFormat)
|
||||
# Add a header section.
|
||||
# This is to insure it's our conf file for import.
|
||||
now = datetime.now()
|
||||
application_version = get_application_version()
|
||||
# Write INI format using Qsettings.
|
||||
# Write our header.
|
||||
export_settings.beginGroup(self.headerSection)
|
||||
export_settings.setValue(u'Make_Changes', u'At_Own_RISK')
|
||||
export_settings.setValue(u'type', u'OpenLP_settings_export')
|
||||
export_settings.setValue(u'file_date_created',
|
||||
now.strftime("%Y-%m-%d %H:%M"))
|
||||
export_settings.setValue(u'version', application_version[u'full'])
|
||||
export_settings.endGroup()
|
||||
# Write all the sections and keys.
|
||||
for section_key in keys:
|
||||
section, key = section_key.split(u'/')
|
||||
key_value = settings.value(section_key)
|
||||
export_settings.setValue(section_key, key_value)
|
||||
export_settings.sync()
|
||||
# Temp CONF file has been written. Blanks in keys are now '%20'.
|
||||
# Read the temp file and output the user's CONF file with blanks to
|
||||
# make it more readable.
|
||||
temp_conf = open(temp_file, u'r')
|
||||
export_conf = open(export_file_name, u'w')
|
||||
for file_record in temp_conf:
|
||||
# Get rid of any invalid entries.
|
||||
if file_record.find(u'@Invalid()') == -1:
|
||||
file_record = file_record.replace(u'%20', u' ')
|
||||
export_conf.write(file_record)
|
||||
temp_conf.close()
|
||||
export_conf.close()
|
||||
os.remove(temp_file)
|
||||
return
|
||||
|
||||
def onModeDefaultItemClicked(self):
|
||||
"""
|
||||
Put OpenLP into "Default" view mode.
|
||||
|
@ -920,6 +1113,9 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
"""
|
||||
Hook to close the main window and display windows on exit
|
||||
"""
|
||||
# If we just did a settings import, close without saving changes.
|
||||
if self.settingsImported:
|
||||
event.accept()
|
||||
if self.serviceManagerContents.isModified():
|
||||
ret = self.serviceManagerContents.saveModifiedService()
|
||||
if ret == QtGui.QMessageBox.Save:
|
||||
|
@ -1095,6 +1291,9 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
"""
|
||||
log.debug(u'Loading QSettings')
|
||||
settings = QtCore.QSettings()
|
||||
# Remove obsolete entries.
|
||||
settings.remove(u'custom slide')
|
||||
settings.remove(u'service')
|
||||
settings.beginGroup(self.generalSettingsSection)
|
||||
self.recentFiles = settings.value(u'recent files').toStringList()
|
||||
settings.endGroup()
|
||||
|
@ -1117,6 +1316,9 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
|
|||
"""
|
||||
Save the main window settings.
|
||||
"""
|
||||
# Exit if we just did a settings import.
|
||||
if self.settingsImported:
|
||||
return
|
||||
log.debug(u'Saving QSettings')
|
||||
settings = QtCore.QSettings()
|
||||
settings.beginGroup(self.generalSettingsSection)
|
||||
|
|
|
@ -31,7 +31,7 @@ import os
|
|||
from PyQt4 import QtCore, QtGui
|
||||
from lxml import html
|
||||
|
||||
from openlp.core.lib import translate, get_text_file_string
|
||||
from openlp.core.lib import translate, get_text_file_string, Receiver
|
||||
from openlp.core.lib.ui import UiStrings
|
||||
from openlp.core.ui.printservicedialog import Ui_PrintServiceDialog, ZoomSize
|
||||
from openlp.core.utils import AppLocation
|
||||
|
@ -327,12 +327,14 @@ class PrintServiceForm(QtGui.QDialog, Ui_PrintServiceDialog):
|
|||
"""
|
||||
Copies the display text to the clipboard as plain text
|
||||
"""
|
||||
self.update_song_usage()
|
||||
self.mainWindow.clipboard.setText(self.document.toPlainText())
|
||||
|
||||
def copyHtmlText(self):
|
||||
"""
|
||||
Copies the display text to the clipboard as Html
|
||||
"""
|
||||
self.update_song_usage()
|
||||
self.mainWindow.clipboard.setText(self.document.toHtml())
|
||||
|
||||
def printServiceOrder(self):
|
||||
|
@ -341,6 +343,7 @@ class PrintServiceForm(QtGui.QDialog, Ui_PrintServiceDialog):
|
|||
"""
|
||||
if not self.printDialog.exec_():
|
||||
return
|
||||
self.update_song_usage()
|
||||
# Print the document.
|
||||
self.document.print_(self.printer)
|
||||
|
||||
|
@ -397,3 +400,9 @@ class PrintServiceForm(QtGui.QDialog, Ui_PrintServiceDialog):
|
|||
settings.setValue(u'print notes',
|
||||
QtCore.QVariant(self.notesCheckBox.isChecked()))
|
||||
settings.endGroup()
|
||||
|
||||
def update_song_usage(self):
|
||||
for index, item in enumerate(self.serviceManager.serviceItems):
|
||||
# Trigger Audit requests
|
||||
Receiver.send_message(u'print_service_started',
|
||||
[item[u'service_item']])
|
||||
|
|
|
@ -28,6 +28,7 @@ import cgi
|
|||
import cPickle
|
||||
import logging
|
||||
import os
|
||||
import shutil
|
||||
import zipfile
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
@ -290,7 +291,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
QtCore.SIGNAL(u'service_item_update'), self.serviceItemUpdate)
|
||||
# Last little bits of setting up
|
||||
self.service_theme = unicode(QtCore.QSettings().value(
|
||||
self.mainwindow.serviceSettingsSection + u'/service theme',
|
||||
self.mainwindow.servicemanagerSettingsSection + u'/service theme',
|
||||
QtCore.QVariant(u'')).toString())
|
||||
self.servicePath = AppLocation.get_section_data_path(u'servicemanager')
|
||||
# build the drag and drop context menu
|
||||
|
@ -371,7 +372,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
self.mainwindow.setServiceModified(self.isModified(),
|
||||
self.shortFileName())
|
||||
QtCore.QSettings(). \
|
||||
setValue(u'service/last file',QtCore.QVariant(fileName))
|
||||
setValue(u'servicemanager/last file',QtCore.QVariant(fileName))
|
||||
|
||||
def fileName(self):
|
||||
"""
|
||||
|
@ -429,14 +430,15 @@ class ServiceManager(QtGui.QWidget):
|
|||
self.mainwindow,
|
||||
translate('OpenLP.ServiceManager', 'Open File'),
|
||||
SettingsManager.get_last_dir(
|
||||
self.mainwindow.serviceSettingsSection),
|
||||
self.mainwindow.servicemanagerSettingsSection),
|
||||
translate('OpenLP.ServiceManager',
|
||||
'OpenLP Service Files (*.osz)')))
|
||||
if not fileName:
|
||||
return False
|
||||
else:
|
||||
fileName = loadFile
|
||||
SettingsManager.set_last_dir(self.mainwindow.serviceSettingsSection,
|
||||
SettingsManager.set_last_dir(
|
||||
self.mainwindow.servicemanagerSettingsSection,
|
||||
split_filename(fileName)[0])
|
||||
self.loadFile(fileName)
|
||||
|
||||
|
@ -461,7 +463,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
self.setFileName(u'')
|
||||
self.setModified(False)
|
||||
QtCore.QSettings(). \
|
||||
setValue(u'service/last file',QtCore.QVariant(u''))
|
||||
setValue(u'servicemanager/last file',QtCore.QVariant(u''))
|
||||
|
||||
def saveFile(self):
|
||||
"""
|
||||
|
@ -470,22 +472,34 @@ class ServiceManager(QtGui.QWidget):
|
|||
if not self.fileName():
|
||||
return self.saveFileAs()
|
||||
path_file_name = unicode(self.fileName())
|
||||
(path, file_name) = os.path.split(path_file_name)
|
||||
(basename, extension) = os.path.splitext(file_name)
|
||||
service_file_name = basename + '.osd'
|
||||
path, file_name = os.path.split(path_file_name)
|
||||
basename, extension = os.path.splitext(file_name)
|
||||
service_file_name = '%s.osd' % basename
|
||||
log.debug(u'ServiceManager.saveFile - %s' % path_file_name)
|
||||
SettingsManager.set_last_dir(self.mainwindow.serviceSettingsSection,
|
||||
SettingsManager.set_last_dir(
|
||||
self.mainwindow.servicemanagerSettingsSection,
|
||||
path)
|
||||
service = []
|
||||
write_list = []
|
||||
audio_files = []
|
||||
total_size = 0
|
||||
Receiver.send_message(u'cursor_busy')
|
||||
# Number of items + 1 to zip it
|
||||
self.mainwindow.displayProgressBar(len(self.serviceItems) + 1)
|
||||
for item in self.serviceItems:
|
||||
self.mainwindow.incrementProgressBar()
|
||||
service.append({u'serviceitem':
|
||||
item[u'service_item'].get_service_repr()})
|
||||
service_item = item[u'service_item'].get_service_repr()
|
||||
# Get all the audio files, and ready them for embedding in the
|
||||
# service file.
|
||||
if len(service_item[u'header'][u'background_audio']) > 0:
|
||||
for i, filename in \
|
||||
enumerate(service_item[u'header'][u'background_audio']):
|
||||
new_file = os.path.join(u'audio', item[u'service_item']._uuid,
|
||||
os.path.split(filename)[1])
|
||||
audio_files.append((filename, new_file))
|
||||
service_item[u'header'][u'background_audio'][i] = new_file
|
||||
# Add the service item to the service.
|
||||
service.append({u'serviceitem': service_item})
|
||||
if not item[u'service_item'].uses_file():
|
||||
continue
|
||||
skipMissing = False
|
||||
|
@ -539,6 +553,8 @@ class ServiceManager(QtGui.QWidget):
|
|||
# Finally add all the listed media files.
|
||||
for path_from in write_list:
|
||||
zip.write(path_from, path_from.encode(u'utf-8'))
|
||||
for path_from, path_to in audio_files:
|
||||
zip.write(path_from, path_to.encode(u'utf-8'))
|
||||
except IOError:
|
||||
log.exception(u'Failed to save service to disk')
|
||||
success = False
|
||||
|
@ -562,7 +578,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
fileName = unicode(QtGui.QFileDialog.getSaveFileName(self.mainwindow,
|
||||
UiStrings().SaveService,
|
||||
SettingsManager.get_last_dir(
|
||||
self.mainwindow.serviceSettingsSection),
|
||||
self.mainwindow.servicemanagerSettingsSection),
|
||||
translate('OpenLP.ServiceManager', 'OpenLP Service Files (*.osz)')))
|
||||
if not fileName:
|
||||
return False
|
||||
|
@ -584,8 +600,8 @@ class ServiceManager(QtGui.QWidget):
|
|||
fileTo = None
|
||||
try:
|
||||
zip = zipfile.ZipFile(fileName)
|
||||
for file in zip.namelist():
|
||||
ucsfile = file_is_unicode(file)
|
||||
for zipinfo in zip.infolist():
|
||||
ucsfile = file_is_unicode(zipinfo.filename)
|
||||
if not ucsfile:
|
||||
critical_error_message_box(
|
||||
message=translate('OpenLP.ServiceManager',
|
||||
|
@ -593,14 +609,12 @@ class ServiceManager(QtGui.QWidget):
|
|||
'The content encoding is not UTF-8.'))
|
||||
continue
|
||||
osfile = unicode(QtCore.QDir.toNativeSeparators(ucsfile))
|
||||
filePath = os.path.join(self.servicePath,
|
||||
os.path.split(osfile)[1])
|
||||
fileTo = open(filePath, u'wb')
|
||||
fileTo.write(zip.read(file))
|
||||
fileTo.flush()
|
||||
fileTo.close()
|
||||
if filePath.endswith(u'osd'):
|
||||
p_file = filePath
|
||||
if not osfile.startswith(u'audio'):
|
||||
osfile = os.path.split(osfile)[1]
|
||||
zipinfo.filename = osfile
|
||||
zip.extract(zipinfo, self.servicePath)
|
||||
if osfile.endswith(u'osd'):
|
||||
p_file = os.path.join(self.servicePath, osfile)
|
||||
if 'p_file' in locals():
|
||||
Receiver.send_message(u'cursor_busy')
|
||||
fileTo = open(p_file, u'r')
|
||||
|
@ -624,17 +638,17 @@ class ServiceManager(QtGui.QWidget):
|
|||
self.mainwindow.addRecentFile(fileName)
|
||||
self.setModified(False)
|
||||
QtCore.QSettings().setValue(
|
||||
'service/last file', QtCore.QVariant(fileName))
|
||||
'servicemanager/last file', QtCore.QVariant(fileName))
|
||||
else:
|
||||
critical_error_message_box(
|
||||
message=translate('OpenLP.ServiceManager',
|
||||
'File is not a valid service.'))
|
||||
log.exception(u'File contains no service data')
|
||||
except (IOError, NameError, zipfile.BadZipfile):
|
||||
log.exception(u'Problem loading service file %s' % fileName)
|
||||
critical_error_message_box(
|
||||
message=translate('OpenLP.ServiceManager',
|
||||
'File could not be opened because it is corrupt.'))
|
||||
log.exception(u'Problem loading service file %s' % fileName)
|
||||
except zipfile.BadZipfile:
|
||||
if os.path.getsize(fileName) == 0:
|
||||
log.exception(u'Service file is zero sized: %s' % fileName)
|
||||
|
@ -666,7 +680,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
present.
|
||||
"""
|
||||
fileName = QtCore.QSettings(). \
|
||||
value(u'service/last file',QtCore.QVariant(u'')).toString()
|
||||
value(u'servicemanager/last file',QtCore.QVariant(u'')).toString()
|
||||
if fileName:
|
||||
self.loadFile(fileName)
|
||||
|
||||
|
@ -683,16 +697,16 @@ class ServiceManager(QtGui.QWidget):
|
|||
self.maintainAction.setVisible(False)
|
||||
self.notesAction.setVisible(False)
|
||||
self.timeAction.setVisible(False)
|
||||
if serviceItem[u'service_item'].is_capable(ItemCapabilities.AllowsEdit)\
|
||||
if serviceItem[u'service_item'].is_capable(ItemCapabilities.CanEdit)\
|
||||
and serviceItem[u'service_item'].edit_id:
|
||||
self.editAction.setVisible(True)
|
||||
if serviceItem[u'service_item']\
|
||||
.is_capable(ItemCapabilities.AllowsMaintain):
|
||||
.is_capable(ItemCapabilities.CanMaintain):
|
||||
self.maintainAction.setVisible(True)
|
||||
if item.parent() is None:
|
||||
self.notesAction.setVisible(True)
|
||||
if serviceItem[u'service_item']\
|
||||
.is_capable(ItemCapabilities.AllowsVariableStartTime):
|
||||
.is_capable(ItemCapabilities.HasVariableStartTime):
|
||||
self.timeAction.setVisible(True)
|
||||
self.themeMenu.menuAction().setVisible(False)
|
||||
# Set up the theme menu.
|
||||
|
@ -963,7 +977,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
(unicode(translate('OpenLP.ServiceManager', 'Notes')),
|
||||
cgi.escape(unicode(serviceitem.notes))))
|
||||
if item[u'service_item'] \
|
||||
.is_capable(ItemCapabilities.AllowsVariableStartTime):
|
||||
.is_capable(ItemCapabilities.HasVariableStartTime):
|
||||
tips.append(item[u'service_item'].get_media_time())
|
||||
treewidgetitem.setToolTip(0, u'<br>'.join(tips))
|
||||
treewidgetitem.setData(0, QtCore.Qt.UserRole,
|
||||
|
@ -999,6 +1013,8 @@ class ServiceManager(QtGui.QWidget):
|
|||
for file in os.listdir(self.servicePath):
|
||||
file_path = os.path.join(self.servicePath, file)
|
||||
delete_file(file_path)
|
||||
if os.path.exists(os.path.join(self.servicePath, u'audio')):
|
||||
shutil.rmtree(os.path.join(self.servicePath, u'audio'), False)
|
||||
|
||||
def onThemeComboBoxSelected(self, currentIndex):
|
||||
"""
|
||||
|
@ -1008,7 +1024,8 @@ class ServiceManager(QtGui.QWidget):
|
|||
self.service_theme = unicode(self.themeComboBox.currentText())
|
||||
self.mainwindow.renderer.set_service_theme(self.service_theme)
|
||||
QtCore.QSettings().setValue(
|
||||
self.mainwindow.serviceSettingsSection + u'/service theme',
|
||||
self.mainwindow.servicemanagerSettingsSection +
|
||||
u'/service theme',
|
||||
QtCore.QVariant(self.service_theme))
|
||||
self.regenerateServiceItems()
|
||||
|
||||
|
@ -1196,7 +1213,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
item += 1
|
||||
if self.serviceItems and item < len(self.serviceItems) and \
|
||||
self.serviceItems[item][u'service_item'].is_capable(
|
||||
ItemCapabilities.AllowsPreview):
|
||||
ItemCapabilities.CanPreview):
|
||||
self.mainwindow.previewController.addServiceManagerItem(
|
||||
self.serviceItems[item][u'service_item'], 0)
|
||||
self.mainwindow.liveController.previewListWidget.setFocus()
|
||||
|
@ -1214,7 +1231,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
"""
|
||||
item = self.findServiceItem()[0]
|
||||
if self.serviceItems[item][u'service_item']\
|
||||
.is_capable(ItemCapabilities.AllowsEdit):
|
||||
.is_capable(ItemCapabilities.CanEdit):
|
||||
Receiver.send_message(u'%s_edit' %
|
||||
self.serviceItems[item][u'service_item'].name.lower(),
|
||||
u'L:%s' % self.serviceItems[item][u'service_item'].edit_id)
|
||||
|
@ -1297,7 +1314,7 @@ class ServiceManager(QtGui.QWidget):
|
|||
serviceItem = self.serviceItems[pos]
|
||||
if (plugin == serviceItem[u'service_item'].name and
|
||||
serviceItem[u'service_item'].is_capable(
|
||||
ItemCapabilities.AllowsAdditions)):
|
||||
ItemCapabilities.CanAppend)):
|
||||
action = self.dndMenu.exec_(QtGui.QCursor.pos())
|
||||
# New action required
|
||||
if action == self.newAction:
|
||||
|
|
|
@ -256,6 +256,12 @@ class SlideController(QtGui.QWidget):
|
|||
self.songMenu.setMenu(QtGui.QMenu(
|
||||
translate('OpenLP.SlideController', 'Go To'), self.toolbar))
|
||||
self.toolbar.makeWidgetsInvisible([u'Song Menu'])
|
||||
# Stuff for items with background audio.
|
||||
self.audioPauseItem = self.toolbar.addToolbarButton(
|
||||
u'Pause Audio', u':/slides/media_playback_pause.png',
|
||||
translate('OpenLP.SlideController', 'Pause audio.'),
|
||||
self.onAudioPauseClicked, True)
|
||||
self.audioPauseItem.setVisible(False)
|
||||
# Build the volumeSlider.
|
||||
self.volumeSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
|
||||
self.volumeSlider.setTickInterval(1)
|
||||
|
@ -512,13 +518,13 @@ class SlideController(QtGui.QWidget):
|
|||
self.playSlidesOnce.setChecked(False)
|
||||
self.playSlidesOnce.setIcon(build_icon(u':/media/media_time.png'))
|
||||
self.playSlidesLoop.setChecked(False)
|
||||
self.playSlidesLoop.setIcon(build_icon(u':/media/media_time.png'))
|
||||
self.playSlidesLoop.setIcon(build_icon(u':/media/media_time.png'))
|
||||
if item.is_text():
|
||||
if QtCore.QSettings().value(
|
||||
self.parent().songsSettingsSection + u'/display songbar',
|
||||
QtCore.QVariant(True)).toBool() and len(self.slideList) > 0:
|
||||
self.toolbar.makeWidgetsVisible([u'Song Menu'])
|
||||
if item.is_capable(ItemCapabilities.AllowsLoop) and \
|
||||
if item.is_capable(ItemCapabilities.CanLoop) and \
|
||||
len(item.get_frames()) > 1:
|
||||
self.toolbar.makeWidgetsVisible(self.loopList)
|
||||
if item.is_media():
|
||||
|
@ -538,7 +544,7 @@ class SlideController(QtGui.QWidget):
|
|||
self.toolbar.hide()
|
||||
self.mediabar.setVisible(False)
|
||||
self.toolbar.makeWidgetsInvisible(self.songEditList)
|
||||
if item.is_capable(ItemCapabilities.AllowsEdit) and item.from_plugin:
|
||||
if item.is_capable(ItemCapabilities.CanEdit) and item.from_plugin:
|
||||
self.toolbar.makeWidgetsVisible(self.songEditList)
|
||||
elif item.is_media():
|
||||
self.toolbar.setVisible(False)
|
||||
|
@ -576,7 +582,7 @@ class SlideController(QtGui.QWidget):
|
|||
"""
|
||||
Replacement item following a remote edit
|
||||
"""
|
||||
if item.__eq__(self.serviceItem):
|
||||
if item == self.serviceItem:
|
||||
self._processItem(item, self.previewListWidget.currentRow())
|
||||
|
||||
def addServiceManagerItem(self, item, slideno):
|
||||
|
@ -586,15 +592,17 @@ class SlideController(QtGui.QWidget):
|
|||
Called by ServiceManager
|
||||
"""
|
||||
log.debug(u'addServiceManagerItem live = %s' % self.isLive)
|
||||
# If no valid slide number is specified we take the first one.
|
||||
# If no valid slide number is specified we take the first one, but we
|
||||
# remember the initial value to see if we should reload the song or not
|
||||
slidenum = slideno
|
||||
if slideno == -1:
|
||||
slideno = 0
|
||||
# If service item is the same as the current on only change slide
|
||||
if item.__eq__(self.serviceItem):
|
||||
self.__checkUpdateSelectedSlide(slideno)
|
||||
slidenum = 0
|
||||
# If service item is the same as the current one, only change slide
|
||||
if slideno >= 0 and item == self.serviceItem:
|
||||
self.__checkUpdateSelectedSlide(slidenum)
|
||||
self.slideSelected()
|
||||
return
|
||||
self._processItem(item, slideno)
|
||||
else:
|
||||
self._processItem(item, slidenum)
|
||||
|
||||
def _processItem(self, serviceItem, slideno):
|
||||
"""
|
||||
|
@ -618,6 +626,22 @@ class SlideController(QtGui.QWidget):
|
|||
self.previewListWidget.setColumnWidth(0, width)
|
||||
if self.isLive:
|
||||
self.songMenu.menu().clear()
|
||||
self.display.audioPlayer.reset()
|
||||
self.setAudioItemsVisibility(False)
|
||||
self.audioPauseItem.setChecked(False)
|
||||
if self.serviceItem.is_capable(ItemCapabilities.HasBackgroundAudio):
|
||||
log.debug(u'Starting to play...')
|
||||
self.display.audioPlayer.addToPlaylist(
|
||||
self.serviceItem.background_audio)
|
||||
if QtCore.QSettings().value(
|
||||
self.parent().generalSettingsSection + \
|
||||
u'/audio start paused',
|
||||
QtCore.QVariant(True)).toBool():
|
||||
self.audioPauseItem.setChecked(True)
|
||||
self.display.audioPlayer.pause()
|
||||
else:
|
||||
self.display.audioPlayer.play()
|
||||
self.setAudioItemsVisibility(True)
|
||||
row = 0
|
||||
text = []
|
||||
for framenumber, frame in enumerate(self.serviceItem.get_frames()):
|
||||
|
@ -767,6 +791,8 @@ class SlideController(QtGui.QWidget):
|
|||
self.onBlankDisplay(True)
|
||||
else:
|
||||
Receiver.send_message(u'maindisplay_show')
|
||||
else:
|
||||
Receiver.send_message(u'maindisplay_hide', HideMode.Screen)
|
||||
|
||||
def onSlideBlank(self):
|
||||
"""
|
||||
|
@ -1097,6 +1123,17 @@ class SlideController(QtGui.QWidget):
|
|||
self.playSlidesLoop.setChecked(False)
|
||||
self.onToggleLoop()
|
||||
|
||||
def setAudioItemsVisibility(self, visible):
|
||||
self.audioPauseItem.setVisible(visible)
|
||||
|
||||
def onAudioPauseClicked(self, checked):
|
||||
if not self.audioPauseItem.isVisible():
|
||||
return
|
||||
if checked:
|
||||
self.display.audioPlayer.pause()
|
||||
else:
|
||||
self.display.audioPlayer.play()
|
||||
|
||||
def timerEvent(self, event):
|
||||
"""
|
||||
If the timer event is for this window select next slide
|
||||
|
|
|
@ -66,6 +66,8 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
|
|||
self.onGradientComboBoxCurrentIndexChanged)
|
||||
QtCore.QObject.connect(self.colorButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onColorButtonClicked)
|
||||
QtCore.QObject.connect(self.imageColorButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onImageColorButtonClicked)
|
||||
QtCore.QObject.connect(self.gradientStartButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onGradientStartButtonClicked)
|
||||
QtCore.QObject.connect(self.gradientEndButton,
|
||||
|
@ -330,6 +332,8 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
|
|||
self.theme.background_end_color)
|
||||
self.setField(u'background_type', QtCore.QVariant(1))
|
||||
else:
|
||||
self.imageColorButton.setStyleSheet(u'background-color: %s' %
|
||||
self.theme.background_border_color)
|
||||
self.imageFileEdit.setText(self.theme.background_filename)
|
||||
self.setField(u'background_type', QtCore.QVariant(2))
|
||||
if self.theme.background_direction == \
|
||||
|
@ -464,6 +468,14 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
|
|||
self._colorButton(self.theme.background_color)
|
||||
self.setBackgroundPageValues()
|
||||
|
||||
def onImageColorButtonClicked(self):
|
||||
"""
|
||||
Background / Gradient 1 Color button pushed.
|
||||
"""
|
||||
self.theme.background_border_color = \
|
||||
self._colorButton(self.theme.background_border_color)
|
||||
self.setBackgroundPageValues()
|
||||
|
||||
def onGradientStartButtonClicked(self):
|
||||
"""
|
||||
Gradient 2 Color button pushed.
|
||||
|
@ -564,7 +576,7 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
|
|||
|
||||
def accept(self):
|
||||
"""
|
||||
Lets save the them as Finish has been pressed
|
||||
Lets save the theme as Finish has been pressed
|
||||
"""
|
||||
# Save the theme name
|
||||
self.theme.theme_name = unicode(self.field(u'name').toString())
|
||||
|
|
|
@ -610,6 +610,11 @@ class ThemeManager(QtGui.QWidget):
|
|||
and to trigger the reload of the theme list
|
||||
"""
|
||||
self._writeTheme(theme, imageFrom, imageTo)
|
||||
if theme.background_type == \
|
||||
BackgroundType.to_string(BackgroundType.Image):
|
||||
self.mainwindow.imageManager.update_image(theme.theme_name,
|
||||
u'theme', QtGui.QColor(theme.background_border_color))
|
||||
self.mainwindow.imageManager.process_updates()
|
||||
self.loadThemes()
|
||||
|
||||
def _writeTheme(self, theme, imageFrom, imageTo):
|
||||
|
|
|
@ -105,6 +105,11 @@ class Ui_ThemeWizard(object):
|
|||
self.imageLayout = QtGui.QFormLayout(self.imageWidget)
|
||||
self.imageLayout.setMargin(0)
|
||||
self.imageLayout.setObjectName(u'ImageLayout')
|
||||
self.imageColorLabel = QtGui.QLabel(self.colorWidget)
|
||||
self.imageColorLabel.setObjectName(u'ImageColorLabel')
|
||||
self.imageColorButton = QtGui.QPushButton(self.colorWidget)
|
||||
self.imageColorButton.setObjectName(u'ImageColorButton')
|
||||
self.imageLayout.addRow(self.imageColorLabel, self.imageColorButton)
|
||||
self.imageLabel = QtGui.QLabel(self.imageWidget)
|
||||
self.imageLabel.setObjectName(u'ImageLabel')
|
||||
self.imageFileLayout = QtGui.QHBoxLayout()
|
||||
|
@ -118,7 +123,7 @@ class Ui_ThemeWizard(object):
|
|||
build_icon(u':/general/general_open.png'))
|
||||
self.imageFileLayout.addWidget(self.imageBrowseButton)
|
||||
self.imageLayout.addRow(self.imageLabel, self.imageFileLayout)
|
||||
self.imageLayout.setItem(1, QtGui.QFormLayout.LabelRole, self.spacer)
|
||||
self.imageLayout.setItem(2, QtGui.QFormLayout.LabelRole, self.spacer)
|
||||
self.backgroundStack.addWidget(self.imageWidget)
|
||||
self.backgroundLayout.addLayout(self.backgroundStack)
|
||||
themeWizard.addPage(self.backgroundPage)
|
||||
|
@ -443,6 +448,8 @@ class Ui_ThemeWizard(object):
|
|||
translate('OpenLP.ThemeWizard', 'Top Left - Bottom Right'))
|
||||
self.gradientComboBox.setItemText(BackgroundGradientType.LeftBottom,
|
||||
translate('OpenLP.ThemeWizard', 'Bottom Left - Top Right'))
|
||||
self.imageColorLabel.setText(
|
||||
translate(u'OpenLP.ThemeWizard', 'Background color:'))
|
||||
self.imageLabel.setText(u'%s:' % UiStrings().Image)
|
||||
self.mainAreaPage.setTitle(
|
||||
translate('OpenLP.ThemeWizard', 'Main Area Font Details'))
|
||||
|
|
|
@ -218,7 +218,7 @@ class BSExtract(object):
|
|||
send_error_message(u'parse')
|
||||
return None
|
||||
content = content.find(u'div').findAll(u'div')
|
||||
verse_number = re.compile(r'v(\d{1,2})(\d{3})(\d{3}) verse')
|
||||
verse_number = re.compile(r'v(\d{1,2})(\d{3})(\d{3}) verse.*')
|
||||
verses = {}
|
||||
for verse in content:
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
|
|
|
@ -67,7 +67,7 @@ class BibleMediaItem(MediaManagerItem):
|
|||
self.hasSearch = True
|
||||
self.search_results = {}
|
||||
self.second_search_results = {}
|
||||
self.check_search_result()
|
||||
self.checkSearchResult()
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'bibles_load_list'), self.reloadBibles)
|
||||
|
||||
|
@ -391,10 +391,13 @@ class BibleMediaItem(MediaManagerItem):
|
|||
elif len(bibles):
|
||||
self.initialiseAdvancedBible(bibles[0])
|
||||
|
||||
def reloadBibles(self):
|
||||
def reloadBibles(self, process=False):
|
||||
log.debug(u'Reloading Bibles')
|
||||
self.plugin.manager.reload_bibles()
|
||||
self.loadBibles()
|
||||
# If called from first time wizard re-run, process any new bibles.
|
||||
if process:
|
||||
self.plugin.appStartup()
|
||||
self.updateAutoCompleter()
|
||||
|
||||
def initialiseAdvancedBible(self, bible):
|
||||
|
@ -648,7 +651,7 @@ class BibleMediaItem(MediaManagerItem):
|
|||
elif self.search_results:
|
||||
self.displayResults(bible, second_bible)
|
||||
self.advancedSearchButton.setEnabled(True)
|
||||
self.check_search_result()
|
||||
self.checkSearchResult()
|
||||
Receiver.send_message(u'cursor_normal')
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
|
||||
|
@ -712,7 +715,7 @@ class BibleMediaItem(MediaManagerItem):
|
|||
elif self.search_results:
|
||||
self.displayResults(bible, second_bible)
|
||||
self.quickSearchButton.setEnabled(True)
|
||||
self.check_search_result()
|
||||
self.checkSearchResult()
|
||||
Receiver.send_message(u'cursor_normal')
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
|
||||
|
@ -785,7 +788,8 @@ class BibleMediaItem(MediaManagerItem):
|
|||
items.append(bible_verse)
|
||||
return items
|
||||
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
"""
|
||||
Generates and formats the slides for the service item as well as the
|
||||
service item's title.
|
||||
|
@ -860,9 +864,9 @@ class BibleMediaItem(MediaManagerItem):
|
|||
not second_bible:
|
||||
# Split the line but do not replace line breaks in renderer.
|
||||
service_item.add_capability(ItemCapabilities.NoLineBreaks)
|
||||
service_item.add_capability(ItemCapabilities.AllowsPreview)
|
||||
service_item.add_capability(ItemCapabilities.AllowsLoop)
|
||||
service_item.add_capability(ItemCapabilities.AllowsWordSplit)
|
||||
service_item.add_capability(ItemCapabilities.CanPreview)
|
||||
service_item.add_capability(ItemCapabilities.CanLoop)
|
||||
service_item.add_capability(ItemCapabilities.CanWordSplit)
|
||||
# Service Item: Title
|
||||
service_item.title = u', '.join(raw_title)
|
||||
# Service Item: Theme
|
||||
|
|
|
@ -135,7 +135,7 @@ class EditCustomForm(QtGui.QDialog, Ui_CustomEditDialog):
|
|||
self.customSlide.credits = unicode(self.creditEdit.text())
|
||||
self.customSlide.theme_name = unicode(self.themeComboBox.currentText())
|
||||
success = self.manager.save_object(self.customSlide)
|
||||
self.mediaitem.auto_select_id = self.customSlide.id
|
||||
self.mediaitem.autoSelectId = self.customSlide.id
|
||||
return success
|
||||
|
||||
def onUpButtonClicked(self):
|
||||
|
|
|
@ -132,7 +132,7 @@ class CustomMediaItem(MediaManagerItem):
|
|||
|
||||
def loadList(self, custom_slides):
|
||||
# Sort out what custom we want to select after loading the list.
|
||||
self.save_auto_select_id()
|
||||
self.saveAutoSelectId()
|
||||
self.listView.clear()
|
||||
# Sort the customs by its title considering language specific
|
||||
# characters. lower() is needed for windows!
|
||||
|
@ -144,9 +144,9 @@ class CustomMediaItem(MediaManagerItem):
|
|||
QtCore.Qt.UserRole, QtCore.QVariant(custom_slide.id))
|
||||
self.listView.addItem(custom_name)
|
||||
# Auto-select the custom.
|
||||
if custom_slide.id == self.auto_select_id:
|
||||
if custom_slide.id == self.autoSelectId:
|
||||
self.listView.setCurrentItem(custom_name)
|
||||
self.auto_select_id = -1
|
||||
self.autoSelectId = -1
|
||||
# Called to redisplay the custom list screen edith from a search
|
||||
# or from the exit of the Custom edit dialog. If remote editing is
|
||||
# active trigger it and clean up so it will not update again.
|
||||
|
@ -180,7 +180,7 @@ class CustomMediaItem(MediaManagerItem):
|
|||
self.remoteTriggered = remote_type
|
||||
self.edit_custom_form.loadCustom(custom_id, (remote_type == u'P'))
|
||||
self.edit_custom_form.exec_()
|
||||
self.auto_select_id = -1
|
||||
self.autoSelectId = -1
|
||||
self.onSearchTextButtonClick()
|
||||
|
||||
def onEditClick(self):
|
||||
|
@ -192,7 +192,7 @@ class CustomMediaItem(MediaManagerItem):
|
|||
item_id = (item.data(QtCore.Qt.UserRole)).toInt()[0]
|
||||
self.edit_custom_form.loadCustom(item_id, False)
|
||||
self.edit_custom_form.exec_()
|
||||
self.auto_select_id = -1
|
||||
self.autoSelectId = -1
|
||||
self.onSearchTextButtonClick()
|
||||
|
||||
def onDeleteClick(self):
|
||||
|
@ -217,21 +217,21 @@ class CustomMediaItem(MediaManagerItem):
|
|||
for item in self.listView.selectedIndexes()]
|
||||
for id in id_list:
|
||||
self.plugin.manager.delete_object(CustomSlide, id)
|
||||
for row in row_list:
|
||||
self.listView.takeItem(row)
|
||||
self.onSearchTextButtonClick()
|
||||
|
||||
def onFocus(self):
|
||||
self.searchTextEdit.setFocus()
|
||||
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
raw_footer = []
|
||||
slide = None
|
||||
theme = None
|
||||
item_id = self._getIdOfItemToGenerate(item, self.remoteCustom)
|
||||
service_item.add_capability(ItemCapabilities.AllowsEdit)
|
||||
service_item.add_capability(ItemCapabilities.AllowsPreview)
|
||||
service_item.add_capability(ItemCapabilities.AllowsLoop)
|
||||
service_item.add_capability(ItemCapabilities.AllowsVirtualSplit)
|
||||
service_item.add_capability(ItemCapabilities.CanEdit)
|
||||
service_item.add_capability(ItemCapabilities.CanPreview)
|
||||
service_item.add_capability(ItemCapabilities.CanLoop)
|
||||
service_item.add_capability(ItemCapabilities.CanSoftBreak)
|
||||
customSlide = self.plugin.manager.get_object(CustomSlide, item_id)
|
||||
title = customSlide.title
|
||||
credit = customSlide.credits
|
||||
|
@ -274,7 +274,7 @@ class CustomMediaItem(MediaManagerItem):
|
|||
CustomSlide.theme_name.like(u'%' + self.whitespace.sub(u' ',
|
||||
search_keywords) + u'%'), order_by_ref=CustomSlide.title)
|
||||
self.loadList(search_results)
|
||||
self.check_search_result()
|
||||
self.checkSearchResult()
|
||||
|
||||
def onSearchTextEditChanged(self, text):
|
||||
"""
|
||||
|
|
|
@ -25,10 +25,13 @@
|
|||
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
|
||||
###############################################################################
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
import logging
|
||||
|
||||
from openlp.core.lib import Plugin, StringContent, build_icon, translate
|
||||
from openlp.plugins.images.lib import ImageMediaItem
|
||||
from openlp.core.lib import Plugin, StringContent, build_icon, translate, \
|
||||
Receiver
|
||||
from openlp.plugins.images.lib import ImageMediaItem, ImageTab
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
@ -36,10 +39,13 @@ class ImagePlugin(Plugin):
|
|||
log.info(u'Image Plugin loaded')
|
||||
|
||||
def __init__(self, plugin_helpers):
|
||||
Plugin.__init__(self, u'images', plugin_helpers, ImageMediaItem)
|
||||
Plugin.__init__(self, u'images', plugin_helpers, ImageMediaItem,
|
||||
ImageTab)
|
||||
self.weight = -7
|
||||
self.icon_path = u':/plugins/plugin_images.png'
|
||||
self.icon = build_icon(self.icon_path)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'image_updated'), self.image_updated)
|
||||
|
||||
def about(self):
|
||||
about_text = translate('ImagePlugin', '<strong>Image Plugin</strong>'
|
||||
|
@ -81,3 +87,13 @@ class ImagePlugin(Plugin):
|
|||
'Add the selected image to the service.')
|
||||
}
|
||||
self.setPluginUiTextStrings(tooltips)
|
||||
|
||||
def image_updated(self):
|
||||
"""
|
||||
Triggered by saving and changing the image border. Sets the images in
|
||||
image manager to require updates. Actual update is triggered by the
|
||||
last part of saving the config.
|
||||
"""
|
||||
background = QtGui.QColor(QtCore.QSettings().value(self.settingsSection
|
||||
+ u'/background color', QtCore.QVariant(u'#000000')))
|
||||
self.liveController.imageManager.update_images(u'image', background)
|
||||
|
|
|
@ -26,3 +26,4 @@
|
|||
###############################################################################
|
||||
|
||||
from mediaitem import ImageMediaItem
|
||||
from imagetab import ImageTab
|
||||
|
|
|
@ -0,0 +1,101 @@
|
|||
# -*- 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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Miller, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from openlp.core.lib import SettingsTab, translate, Receiver
|
||||
from openlp.core.lib.ui import UiStrings, create_valign_combo
|
||||
|
||||
class ImageTab(SettingsTab):
|
||||
"""
|
||||
ImageTab is the images settings tab in the settings dialog.
|
||||
"""
|
||||
def __init__(self, parent, name, visible_title, icon_path):
|
||||
SettingsTab.__init__(self, parent, name, visible_title, icon_path)
|
||||
|
||||
def setupUi(self):
|
||||
self.setObjectName(u'ImagesTab')
|
||||
SettingsTab.setupUi(self)
|
||||
self.bgColorGroupBox = QtGui.QGroupBox(self.leftColumn)
|
||||
self.bgColorGroupBox.setObjectName(u'FontGroupBox')
|
||||
self.formLayout = QtGui.QFormLayout(self.bgColorGroupBox)
|
||||
self.formLayout.setObjectName(u'FormLayout')
|
||||
self.colorLayout = QtGui.QHBoxLayout()
|
||||
self.backgroundColorLabel = QtGui.QLabel(self.bgColorGroupBox)
|
||||
self.backgroundColorLabel.setObjectName(u'BackgroundColorLabel')
|
||||
self.colorLayout.addWidget(self.backgroundColorLabel)
|
||||
self.backgroundColorButton = QtGui.QPushButton(self.bgColorGroupBox)
|
||||
self.backgroundColorButton.setObjectName(u'BackgroundColorButton')
|
||||
self.colorLayout.addWidget(self.backgroundColorButton)
|
||||
self.formLayout.addRow(self.colorLayout)
|
||||
self.informationLabel = QtGui.QLabel(self.bgColorGroupBox)
|
||||
self.informationLabel.setObjectName(u'InformationLabel')
|
||||
self.formLayout.addRow(self.informationLabel)
|
||||
self.leftLayout.addWidget(self.bgColorGroupBox)
|
||||
self.leftLayout.addStretch()
|
||||
self.rightColumn.setSizePolicy(
|
||||
QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred)
|
||||
self.rightLayout.addStretch()
|
||||
# Signals and slots
|
||||
QtCore.QObject.connect(self.backgroundColorButton,
|
||||
QtCore.SIGNAL(u'pressed()'), self.onbackgroundColorButtonClicked)
|
||||
|
||||
def retranslateUi(self):
|
||||
self.bgColorGroupBox.setTitle(
|
||||
translate('ImagesPlugin.ImageTab', 'Background Color'))
|
||||
self.backgroundColorLabel.setText(
|
||||
translate('ImagesPlugin.ImageTab', 'Default Color:'))
|
||||
self.informationLabel.setText(
|
||||
translate('ImagesPlugin.ImageTab', 'Provides border where image '
|
||||
'is not the correct dimensions for the screen when resized.'))
|
||||
|
||||
def onbackgroundColorButtonClicked(self):
|
||||
new_color = QtGui.QColorDialog.getColor(
|
||||
QtGui.QColor(self.bg_color), self)
|
||||
if new_color.isValid():
|
||||
self.bg_color = new_color.name()
|
||||
self.backgroundColorButton.setStyleSheet(
|
||||
u'background-color: %s' % self.bg_color)
|
||||
|
||||
def load(self):
|
||||
settings = QtCore.QSettings()
|
||||
settings.beginGroup(self.settingsSection)
|
||||
self.bg_color = unicode(settings.value(
|
||||
u'background color', QtCore.QVariant(u'#000000')).toString())
|
||||
self.initial_color = self.bg_color
|
||||
settings.endGroup()
|
||||
self.backgroundColorButton.setStyleSheet(
|
||||
u'background-color: %s' % self.bg_color)
|
||||
|
||||
def save(self):
|
||||
settings = QtCore.QSettings()
|
||||
settings.beginGroup(self.settingsSection)
|
||||
settings.setValue(u'background color', QtCore.QVariant(self.bg_color))
|
||||
settings.endGroup()
|
||||
if self.initial_color != self.bg_color:
|
||||
Receiver.send_message(u'image_updated')
|
||||
|
|
@ -99,6 +99,8 @@ class ImageMediaItem(MediaManagerItem):
|
|||
"""
|
||||
Remove an image item from the list
|
||||
"""
|
||||
# Turn off auto preview triggers.
|
||||
self.listView.blockSignals(True)
|
||||
if check_item_selected(self.listView, translate('ImagePlugin.MediaItem',
|
||||
'You must select an image to delete.')):
|
||||
row_list = [item.row() for item in self.listView.selectedIndexes()]
|
||||
|
@ -111,6 +113,7 @@ class ImageMediaItem(MediaManagerItem):
|
|||
self.listView.takeItem(row)
|
||||
SettingsManager.set_list(self.settingsSection,
|
||||
u'images', self.getFileList())
|
||||
self.listView.blockSignals(False)
|
||||
|
||||
def loadList(self, images, initialLoad=False):
|
||||
if not initialLoad:
|
||||
|
@ -139,7 +142,10 @@ class ImageMediaItem(MediaManagerItem):
|
|||
if not initialLoad:
|
||||
self.plugin.formparent.finishedProgressBar()
|
||||
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
background = QtGui.QColor(QtCore.QSettings().value(self.settingsSection
|
||||
+ u'/background color', QtCore.QVariant(u'#000000')))
|
||||
if item:
|
||||
items = [item]
|
||||
else:
|
||||
|
@ -147,10 +153,10 @@ class ImageMediaItem(MediaManagerItem):
|
|||
if not items:
|
||||
return False
|
||||
service_item.title = unicode(self.plugin.nameStrings[u'plural'])
|
||||
service_item.add_capability(ItemCapabilities.AllowsMaintain)
|
||||
service_item.add_capability(ItemCapabilities.AllowsPreview)
|
||||
service_item.add_capability(ItemCapabilities.AllowsLoop)
|
||||
service_item.add_capability(ItemCapabilities.AllowsAdditions)
|
||||
service_item.add_capability(ItemCapabilities.CanMaintain)
|
||||
service_item.add_capability(ItemCapabilities.CanPreview)
|
||||
service_item.add_capability(ItemCapabilities.CanLoop)
|
||||
service_item.add_capability(ItemCapabilities.CanAppend)
|
||||
# force a nonexistent theme
|
||||
service_item.theme = -1
|
||||
missing_items = []
|
||||
|
@ -164,11 +170,12 @@ class ImageMediaItem(MediaManagerItem):
|
|||
items.remove(item)
|
||||
# We cannot continue, as all images do not exist.
|
||||
if not items:
|
||||
critical_error_message_box(
|
||||
translate('ImagePlugin.MediaItem', 'Missing Image(s)'),
|
||||
unicode(translate('ImagePlugin.MediaItem',
|
||||
'The following image(s) no longer exist: %s')) %
|
||||
u'\n'.join(missing_items_filenames))
|
||||
if not remote:
|
||||
critical_error_message_box(
|
||||
translate('ImagePlugin.MediaItem', 'Missing Image(s)'),
|
||||
unicode(translate('ImagePlugin.MediaItem',
|
||||
'The following image(s) no longer exist: %s')) %
|
||||
u'\n'.join(missing_items_filenames))
|
||||
return False
|
||||
# We have missing as well as existing images. We ask what to do.
|
||||
elif missing_items and QtGui.QMessageBox.question(self,
|
||||
|
@ -183,7 +190,7 @@ class ImageMediaItem(MediaManagerItem):
|
|||
for bitem in items:
|
||||
filename = unicode(bitem.data(QtCore.Qt.UserRole).toString())
|
||||
(path, name) = os.path.split(filename)
|
||||
service_item.add_from_image(filename, name)
|
||||
service_item.add_from_image(filename, name, background)
|
||||
return True
|
||||
|
||||
def onResetClick(self):
|
||||
|
@ -206,13 +213,16 @@ class ImageMediaItem(MediaManagerItem):
|
|||
if check_item_selected(self.listView,
|
||||
translate('ImagePlugin.MediaItem',
|
||||
'You must select an image to replace the background with.')):
|
||||
background = QtGui.QColor(QtCore.QSettings().value(
|
||||
self.settingsSection + u'/background color',
|
||||
QtCore.QVariant(u'#000000')))
|
||||
item = self.listView.selectedIndexes()[0]
|
||||
bitem = self.listView.item(item.row())
|
||||
filename = unicode(bitem.data(QtCore.Qt.UserRole).toString())
|
||||
if os.path.exists(filename):
|
||||
(path, name) = os.path.split(filename)
|
||||
if self.plugin.liveController.display.directImage(name,
|
||||
filename):
|
||||
filename, background):
|
||||
self.resetAction.setVisible(True)
|
||||
else:
|
||||
critical_error_message_box(UiStrings().LiveBGError,
|
||||
|
|
|
@ -31,11 +31,11 @@ import os
|
|||
import locale
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
from PyQt4.phonon import Phonon
|
||||
|
||||
from openlp.core.lib import MediaManagerItem, build_icon, ItemCapabilities, \
|
||||
SettingsManager, translate, check_item_selected, Receiver
|
||||
SettingsManager, translate, check_item_selected, Receiver, MediaType
|
||||
from openlp.core.lib.ui import UiStrings, critical_error_message_box
|
||||
from PyQt4.phonon import Phonon
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
@ -48,9 +48,9 @@ class MediaMediaItem(MediaManagerItem):
|
|||
log.info(u'%s MediaMediaItem loaded', __name__)
|
||||
|
||||
def __init__(self, parent, plugin, icon):
|
||||
self.IconPath = u'images/image'
|
||||
self.iconPath = u'images/image'
|
||||
self.background = False
|
||||
self.PreviewFunction = CLAPPERBOARD
|
||||
self.previewFunction = CLAPPERBOARD
|
||||
MediaManagerItem.__init__(self, parent, plugin, icon)
|
||||
self.singleServiceItem = False
|
||||
self.hasSearch = True
|
||||
|
@ -129,18 +129,20 @@ class MediaMediaItem(MediaManagerItem):
|
|||
'There was a problem replacing your background, '
|
||||
'the media file "%s" no longer exists.')) % filename)
|
||||
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
if item is None:
|
||||
item = self.listView.currentItem()
|
||||
if item is None:
|
||||
return False
|
||||
filename = unicode(item.data(QtCore.Qt.UserRole).toString())
|
||||
if not os.path.exists(filename):
|
||||
# File is no longer present
|
||||
critical_error_message_box(
|
||||
translate('MediaPlugin.MediaItem', 'Missing Media File'),
|
||||
unicode(translate('MediaPlugin.MediaItem',
|
||||
'The file %s no longer exists.')) % filename)
|
||||
if not remote:
|
||||
# File is no longer present
|
||||
critical_error_message_box(
|
||||
translate('MediaPlugin.MediaItem', 'Missing Media File'),
|
||||
unicode(translate('MediaPlugin.MediaItem',
|
||||
'The file %s no longer exists.')) % filename)
|
||||
return False
|
||||
self.mediaObject.stop()
|
||||
self.mediaObject.clearQueue()
|
||||
|
@ -156,13 +158,16 @@ class MediaMediaItem(MediaManagerItem):
|
|||
or self.mediaObject.currentSource().type() \
|
||||
== Phonon.MediaSource.Invalid:
|
||||
self.mediaObject.stop()
|
||||
critical_error_message_box(UiStrings().UnsupportedFile,
|
||||
UiStrings().UnsupportedFile)
|
||||
critical_error_message_box(
|
||||
translate('MediaPlugin.MediaItem', 'File Too Big'),
|
||||
translate('MediaPlugin.MediaItem', 'The file you are '
|
||||
'trying to load is too big. Please reduce it to less '
|
||||
'than 50MiB.'))
|
||||
return False
|
||||
self.mediaObject.stop()
|
||||
service_item.media_length = self.mediaObject.totalTime() / 1000
|
||||
service_item.add_capability(
|
||||
ItemCapabilities.AllowsVariableStartTime)
|
||||
ItemCapabilities.HasVariableStartTime)
|
||||
service_item.title = unicode(self.plugin.nameStrings[u'singular'])
|
||||
service_item.add_capability(ItemCapabilities.RequiresMedia)
|
||||
# force a non-existent theme
|
||||
|
@ -217,6 +222,19 @@ class MediaMediaItem(MediaManagerItem):
|
|||
item_name.setToolTip(track)
|
||||
self.listView.addItem(item_name)
|
||||
|
||||
def getList(self, type=MediaType.Audio):
|
||||
media = SettingsManager.load_list(self.settingsSection, u'media')
|
||||
media.sort(cmp=locale.strcoll,
|
||||
key=lambda filename: os.path.split(unicode(filename))[1].lower())
|
||||
ext = []
|
||||
if type == MediaType.Audio:
|
||||
ext = self.plugin.audio_extensions_list
|
||||
else:
|
||||
ext = self.plugin.video_extensions_list
|
||||
ext = map(lambda x: x[1:], ext)
|
||||
media = filter(lambda x: os.path.splitext(x)[1] in ext, media)
|
||||
return media
|
||||
|
||||
def createPhonon(self):
|
||||
log.debug(u'CreatePhonon')
|
||||
if not self.mediaObject:
|
||||
|
|
|
@ -233,7 +233,8 @@ class PresentationMediaItem(MediaManagerItem):
|
|||
SettingsManager.set_list(self.settingsSection,
|
||||
u'presentations', self.getFileList())
|
||||
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
"""
|
||||
Load the relevant information for displaying the presentation
|
||||
in the slidecontroller. In the case of powerpoints, an image
|
||||
|
@ -248,7 +249,7 @@ class PresentationMediaItem(MediaManagerItem):
|
|||
service_item.title = unicode(self.displayTypeComboBox.currentText())
|
||||
service_item.shortname = unicode(self.displayTypeComboBox.currentText())
|
||||
service_item.add_capability(ItemCapabilities.ProvidesOwnDisplay)
|
||||
service_item.add_capability(ItemCapabilities.AllowsDetailedTitleDisplay)
|
||||
service_item.add_capability(ItemCapabilities.HasDetailedTitleDisplay)
|
||||
shortname = service_item.shortname
|
||||
if shortname:
|
||||
for bitem in items:
|
||||
|
@ -275,12 +276,13 @@ class PresentationMediaItem(MediaManagerItem):
|
|||
return True
|
||||
else:
|
||||
# File is no longer present
|
||||
critical_error_message_box(
|
||||
translate('PresentationPlugin.MediaItem',
|
||||
'Missing Presentation'),
|
||||
unicode(translate('PresentationPlugin.MediaItem',
|
||||
'The Presentation %s is incomplete,'
|
||||
' please reload.')) % filename)
|
||||
if not remote:
|
||||
critical_error_message_box(
|
||||
translate('PresentationPlugin.MediaItem',
|
||||
'Missing Presentation'),
|
||||
unicode(translate('PresentationPlugin.MediaItem',
|
||||
'The Presentation %s is incomplete,'
|
||||
' please reload.')) % filename)
|
||||
return False
|
||||
else:
|
||||
# File is no longer present
|
||||
|
|
|
@ -528,7 +528,7 @@ class HttpConnection(object):
|
|||
id = json.loads(self.url_params[u'data'][0])[u'request'][u'id']
|
||||
plugin = self.parent.plugin.pluginManager.get_plugin_by_name(type)
|
||||
if plugin.status == PluginStatus.Active and plugin.mediaItem:
|
||||
plugin.mediaItem.goLive(id)
|
||||
plugin.mediaItem.goLive(id, remote=True)
|
||||
|
||||
def add_to_service(self, type):
|
||||
"""
|
||||
|
@ -538,7 +538,7 @@ class HttpConnection(object):
|
|||
plugin = self.parent.plugin.pluginManager.get_plugin_by_name(type)
|
||||
if plugin.status == PluginStatus.Active and plugin.mediaItem:
|
||||
item_id = plugin.mediaItem.createItemFromId(id)
|
||||
plugin.mediaItem.addToService(item_id)
|
||||
plugin.mediaItem.addToService(item_id, remote=True)
|
||||
|
||||
def send_response(self, response):
|
||||
http = u'HTTP/1.1 %s\r\n' % response.code
|
||||
|
|
|
@ -52,6 +52,7 @@ them separate from the functionality, so that it is easier to recreate the GUI
|
|||
from the .ui files later if necessary.
|
||||
"""
|
||||
|
||||
from mediafilesform import MediaFilesForm
|
||||
from authorsform import AuthorsForm
|
||||
from topicsform import TopicsForm
|
||||
from songbookform import SongBookForm
|
||||
|
|
|
@ -28,7 +28,8 @@
|
|||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from openlp.core.lib import build_icon, translate
|
||||
from openlp.core.lib.ui import UiStrings, create_accept_reject_button_box
|
||||
from openlp.core.lib.ui import UiStrings, create_accept_reject_button_box, \
|
||||
create_up_down_push_button_set
|
||||
from openlp.plugins.songs.lib.ui import SongStrings
|
||||
|
||||
class Ui_EditSongDialog(object):
|
||||
|
@ -36,9 +37,11 @@ class Ui_EditSongDialog(object):
|
|||
editSongDialog.setObjectName(u'editSongDialog')
|
||||
editSongDialog.resize(650, 400)
|
||||
editSongDialog.setWindowIcon(
|
||||
build_icon(u':/icon/openlp.org-icon-32.bmp'))
|
||||
build_icon(u':/icon/openlp-logo-16x16.png'))
|
||||
editSongDialog.setModal(True)
|
||||
self.dialogLayout = QtGui.QVBoxLayout(editSongDialog)
|
||||
self.dialogLayout.setSpacing(8)
|
||||
self.dialogLayout.setContentsMargins(8, 8, 8, 8)
|
||||
self.dialogLayout.setObjectName(u'dialogLayout')
|
||||
self.songTabWidget = QtGui.QTabWidget(editSongDialog)
|
||||
self.songTabWidget.setObjectName(u'songTabWidget')
|
||||
|
@ -246,6 +249,36 @@ class Ui_EditSongDialog(object):
|
|||
self.commentsLayout.addWidget(self.commentsEdit)
|
||||
self.themeTabLayout.addWidget(self.commentsGroupBox)
|
||||
self.songTabWidget.addTab(self.themeTab, u'')
|
||||
# audio tab
|
||||
self.audioTab = QtGui.QWidget()
|
||||
self.audioTab.setObjectName(u'audioTab')
|
||||
self.audioLayout = QtGui.QHBoxLayout(self.audioTab)
|
||||
self.audioLayout.setObjectName(u'audioLayout')
|
||||
self.audioListWidget = QtGui.QListWidget(self.audioTab)
|
||||
self.audioListWidget.setObjectName(u'audioListWidget')
|
||||
self.audioLayout.addWidget(self.audioListWidget)
|
||||
self.audioButtonsLayout = QtGui.QVBoxLayout()
|
||||
self.audioButtonsLayout.setObjectName(u'audioButtonsLayout')
|
||||
self.audioAddFromFileButton = QtGui.QPushButton(self.audioTab)
|
||||
self.audioAddFromFileButton.setObjectName(u'audioAddFromFileButton')
|
||||
self.audioButtonsLayout.addWidget(self.audioAddFromFileButton)
|
||||
self.audioAddFromMediaButton = QtGui.QPushButton(self.audioTab)
|
||||
self.audioAddFromMediaButton.setObjectName(u'audioAddFromMediaButton')
|
||||
self.audioButtonsLayout.addWidget(self.audioAddFromMediaButton)
|
||||
self.audioRemoveButton = QtGui.QPushButton(self.audioTab)
|
||||
self.audioRemoveButton.setObjectName(u'audioRemoveButton')
|
||||
self.audioButtonsLayout.addWidget(self.audioRemoveButton)
|
||||
self.audioRemoveAllButton = QtGui.QPushButton(self.audioTab)
|
||||
self.audioRemoveAllButton.setObjectName(u'audioRemoveAllButton')
|
||||
self.audioButtonsLayout.addWidget(self.audioRemoveAllButton)
|
||||
self.audioButtonsLayout.addStretch(1)
|
||||
self.upButton, self.downButton = \
|
||||
create_up_down_push_button_set(self)
|
||||
self.audioButtonsLayout.addWidget(self.upButton)
|
||||
self.audioButtonsLayout.addWidget(self.downButton)
|
||||
self.audioLayout.addLayout(self.audioButtonsLayout)
|
||||
self.songTabWidget.addTab(self.audioTab, u'')
|
||||
# Last few bits
|
||||
self.dialogLayout.addWidget(self.songTabWidget)
|
||||
self.buttonBox = create_accept_reject_button_box(editSongDialog)
|
||||
self.dialogLayout.addWidget(self.buttonBox)
|
||||
|
@ -305,6 +338,17 @@ class Ui_EditSongDialog(object):
|
|||
self.songTabWidget.indexOf(self.themeTab),
|
||||
translate('SongsPlugin.EditSongForm',
|
||||
'Theme, Copyright Info && Comments'))
|
||||
self.songTabWidget.setTabText(
|
||||
self.songTabWidget.indexOf(self.audioTab),
|
||||
translate('SongsPlugin.EditSongForm', 'Linked Audio'))
|
||||
self.audioAddFromFileButton.setText(
|
||||
translate('SongsPlugin.EditSongForm', 'Add &File(s)'))
|
||||
self.audioAddFromMediaButton.setText(
|
||||
translate('SongsPlugin.EditSongForm', 'Add &Media'))
|
||||
self.audioRemoveButton.setText(
|
||||
translate('SongsPlugin.EditSongForm', '&Remove'))
|
||||
self.audioRemoveAllButton.setText(
|
||||
translate('SongsPlugin.EditSongForm', 'Remove &All'))
|
||||
|
||||
def editSongDialogComboBox(parent, name):
|
||||
"""
|
||||
|
|
|
@ -27,15 +27,18 @@
|
|||
|
||||
import logging
|
||||
import re
|
||||
import os
|
||||
import shutil
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from openlp.core.lib import Receiver, translate
|
||||
from openlp.core.lib import PluginStatus, Receiver, MediaType, translate
|
||||
from openlp.core.lib.ui import UiStrings, add_widget_completer, \
|
||||
critical_error_message_box, find_and_set_in_combo_box
|
||||
from openlp.plugins.songs.forms import EditVerseForm
|
||||
from openlp.core.utils import AppLocation
|
||||
from openlp.plugins.songs.forms import EditVerseForm, MediaFilesForm
|
||||
from openlp.plugins.songs.lib import SongXML, VerseType, clean_song
|
||||
from openlp.plugins.songs.lib.db import Book, Song, Author, Topic
|
||||
from openlp.plugins.songs.lib.db import Book, Song, Author, Topic, MediaFile
|
||||
from openlp.plugins.songs.lib.ui import SongStrings
|
||||
from editsongdialog import Ui_EditSongDialog
|
||||
|
||||
|
@ -93,6 +96,14 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.mediaitem.plugin.renderer.themeManager.onAddTheme)
|
||||
QtCore.QObject.connect(self.maintenanceButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onMaintenanceButtonClicked)
|
||||
QtCore.QObject.connect(self.audioAddFromFileButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onAudioAddFromFileButtonClicked)
|
||||
QtCore.QObject.connect(self.audioAddFromMediaButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onAudioAddFromMediaButtonClicked)
|
||||
QtCore.QObject.connect(self.audioRemoveButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onAudioRemoveButtonClicked)
|
||||
QtCore.QObject.connect(self.audioRemoveAllButton,
|
||||
QtCore.SIGNAL(u'clicked()'), self.onAudioRemoveAllButtonClicked)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'theme_update_list'), self.loadThemes)
|
||||
self.previewButton = QtGui.QPushButton()
|
||||
|
@ -104,12 +115,14 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
QtCore.SIGNAL(u'clicked(QAbstractButton*)'), self.onPreview)
|
||||
# Create other objects and forms
|
||||
self.manager = manager
|
||||
self.verse_form = EditVerseForm(self)
|
||||
self.verseForm = EditVerseForm(self)
|
||||
self.mediaForm = MediaFilesForm(self)
|
||||
self.initialise()
|
||||
self.authorsListView.setSortingEnabled(False)
|
||||
self.authorsListView.setAlternatingRowColors(True)
|
||||
self.topicsListView.setSortingEnabled(False)
|
||||
self.topicsListView.setAlternatingRowColors(True)
|
||||
self.audioListWidget.setAlternatingRowColors(True)
|
||||
self.findVerseSplit = re.compile(u'---\[\]---\n', re.UNICODE)
|
||||
self.whitespace = re.compile(r'\W+', re.UNICODE)
|
||||
|
||||
|
@ -161,6 +174,16 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.themes.append(theme)
|
||||
add_widget_completer(self.themes, self.themeComboBox)
|
||||
|
||||
def loadMediaFiles(self):
|
||||
self.audioAddFromMediaButton.setVisible(False)
|
||||
for plugin in self.parent().pluginManager.plugins:
|
||||
if plugin.name == u'media' and \
|
||||
plugin.status == PluginStatus.Active:
|
||||
self.audioAddFromMediaButton.setVisible(True)
|
||||
self.mediaForm.populateFiles(
|
||||
plugin.getMediaManagerItem().getList(MediaType.Audio))
|
||||
break
|
||||
|
||||
def newSong(self):
|
||||
log.debug(u'New Song')
|
||||
self.song = None
|
||||
|
@ -176,11 +199,13 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.verseListWidget.setRowCount(0)
|
||||
self.authorsListView.clear()
|
||||
self.topicsListView.clear()
|
||||
self.audioListWidget.clear()
|
||||
self.titleEdit.setFocus(QtCore.Qt.OtherFocusReason)
|
||||
self.songBookNumberEdit.setText(u'')
|
||||
self.loadAuthors()
|
||||
self.loadTopics()
|
||||
self.loadBooks()
|
||||
self.loadMediaFiles()
|
||||
self.themeComboBox.setCurrentIndex(0)
|
||||
# it's a new song to preview is not possible
|
||||
self.previewButton.setVisible(False)
|
||||
|
@ -201,6 +226,7 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.loadAuthors()
|
||||
self.loadTopics()
|
||||
self.loadBooks()
|
||||
self.loadMediaFiles()
|
||||
self.song = self.manager.get_object(Song, id)
|
||||
self.titleEdit.setText(self.song.title)
|
||||
if self.song.alternate_title:
|
||||
|
@ -303,6 +329,11 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
topic_name = QtGui.QListWidgetItem(unicode(topic.name))
|
||||
topic_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(topic.id))
|
||||
self.topicsListView.addItem(topic_name)
|
||||
self.audioListWidget.clear()
|
||||
for media in self.song.media_files:
|
||||
media_file = QtGui.QListWidgetItem(os.path.split(media.file_name)[1])
|
||||
media_file.setData(QtCore.Qt.UserRole, QtCore.QVariant(media.file_name))
|
||||
self.audioListWidget.addItem(media_file)
|
||||
self.titleEdit.setFocus(QtCore.Qt.OtherFocusReason)
|
||||
# Hide or show the preview button.
|
||||
self.previewButton.setVisible(preview)
|
||||
|
@ -436,9 +467,9 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.verseDeleteButton.setEnabled(True)
|
||||
|
||||
def onVerseAddButtonClicked(self):
|
||||
self.verse_form.setVerse(u'', True)
|
||||
if self.verse_form.exec_():
|
||||
after_text, verse_tag, verse_num = self.verse_form.getVerse()
|
||||
self.verseForm.setVerse(u'', True)
|
||||
if self.verseForm.exec_():
|
||||
after_text, verse_tag, verse_num = self.verseForm.getVerse()
|
||||
verse_def = u'%s%s' % (verse_tag, verse_num)
|
||||
item = QtGui.QTableWidgetItem(after_text)
|
||||
item.setData(QtCore.Qt.UserRole, QtCore.QVariant(verse_def))
|
||||
|
@ -454,20 +485,21 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
if item:
|
||||
tempText = item.text()
|
||||
verseId = unicode(item.data(QtCore.Qt.UserRole).toString())
|
||||
self.verse_form.setVerse(tempText, True, verseId)
|
||||
if self.verse_form.exec_():
|
||||
after_text, verse_tag, verse_num = self.verse_form.getVerse()
|
||||
self.verseForm.setVerse(tempText, True, verseId)
|
||||
if self.verseForm.exec_():
|
||||
after_text, verse_tag, verse_num = self.verseForm.getVerse()
|
||||
verse_def = u'%s%s' % (verse_tag, verse_num)
|
||||
item.setData(QtCore.Qt.UserRole, QtCore.QVariant(verse_def))
|
||||
item.setText(after_text)
|
||||
# number of lines has change so repaint the list moving the data
|
||||
# number of lines has changed, repaint the list moving the data
|
||||
if len(tempText.split(u'\n')) != len(after_text.split(u'\n')):
|
||||
tempList = {}
|
||||
tempId = {}
|
||||
for row in range(0, self.verseListWidget.rowCount()):
|
||||
tempList[row] = self.verseListWidget.item(row, 0).text()
|
||||
tempId[row] = self.verseListWidget.item(row, 0).\
|
||||
data(QtCore.Qt.UserRole)
|
||||
tempList[row] = self.verseListWidget.item(row, 0)\
|
||||
.text()
|
||||
tempId[row] = self.verseListWidget.item(row, 0)\
|
||||
.data(QtCore.Qt.UserRole)
|
||||
self.verseListWidget.clear()
|
||||
for row in range (0, len(tempList)):
|
||||
item = QtGui.QTableWidgetItem(tempList[row], 0)
|
||||
|
@ -486,12 +518,12 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
verse_list += u'---[%s:%s]---\n' % (verse_tag, verse_num)
|
||||
verse_list += item.text()
|
||||
verse_list += u'\n'
|
||||
self.verse_form.setVerse(verse_list)
|
||||
self.verseForm.setVerse(verse_list)
|
||||
else:
|
||||
self.verse_form.setVerse(u'')
|
||||
if not self.verse_form.exec_():
|
||||
self.verseForm.setVerse(u'')
|
||||
if not self.verseForm.exec_():
|
||||
return
|
||||
verse_list = self.verse_form.getVerseAll()
|
||||
verse_list = self.verseForm.getVerseAll()
|
||||
verse_list = unicode(verse_list.replace(u'\r\n', u'\n'))
|
||||
self.verseListWidget.clear()
|
||||
self.verseListWidget.setRowCount(0)
|
||||
|
@ -670,6 +702,66 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.saveSong(True)
|
||||
Receiver.send_message(u'songs_preview')
|
||||
|
||||
def onAudioAddFromFileButtonClicked(self):
|
||||
"""
|
||||
Loads file(s) from the filesystem.
|
||||
"""
|
||||
filters = u'%s (*)' % UiStrings().AllFiles
|
||||
filenames = QtGui.QFileDialog.getOpenFileNames(self,
|
||||
translate('SongsPlugin.EditSongForm', 'Open File(s)'),
|
||||
QtCore.QString(), filters)
|
||||
for filename in filenames:
|
||||
item = QtGui.QListWidgetItem(os.path.split(unicode(filename))[1])
|
||||
item.setData(QtCore.Qt.UserRole, filename)
|
||||
self.audioListWidget.addItem(item)
|
||||
|
||||
def onAudioAddFromMediaButtonClicked(self):
|
||||
"""
|
||||
Loads file(s) from the media plugin.
|
||||
"""
|
||||
if self.mediaForm.exec_():
|
||||
for filename in self.mediaForm.getSelectedFiles():
|
||||
item = QtGui.QListWidgetItem(os.path.split(unicode(filename))[1])
|
||||
item.setData(QtCore.Qt.UserRole, filename)
|
||||
self.audioListWidget.addItem(item)
|
||||
|
||||
def onAudioRemoveButtonClicked(self):
|
||||
"""
|
||||
Removes a file from the list.
|
||||
"""
|
||||
row = self.audioListWidget.currentRow()
|
||||
if row == -1:
|
||||
return
|
||||
self.audioListWidget.takeItem(row)
|
||||
|
||||
def onAudioRemoveAllButtonClicked(self):
|
||||
"""
|
||||
Removes all files from the list.
|
||||
"""
|
||||
self.audioListWidget.clear()
|
||||
|
||||
def onUpButtonClicked(self):
|
||||
"""
|
||||
Moves a file up when the user clicks the up button on the audio tab.
|
||||
"""
|
||||
row = self.audioListWidget.currentRow()
|
||||
if row <= 0:
|
||||
return
|
||||
item = self.audioListWidget.takeItem(row)
|
||||
self.audioListWidget.insertItem(row - 1, item)
|
||||
self.audioListWidget.setCurrentRow(row - 1)
|
||||
|
||||
def onDownButtonClicked(self):
|
||||
"""
|
||||
Moves a file down when the user clicks the up button on the audio tab.
|
||||
"""
|
||||
row = self.audioListWidget.currentRow()
|
||||
if row == -1 or row > self.audioListWidget.count() - 1:
|
||||
return
|
||||
item = self.audioListWidget.takeItem(row)
|
||||
self.audioListWidget.insertItem(row + 1, item)
|
||||
self.audioListWidget.setCurrentRow(row + 1)
|
||||
|
||||
def clearCaches(self):
|
||||
"""
|
||||
Free up autocompletion memory on dialog exit
|
||||
|
@ -744,18 +836,55 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
self.song.theme_name = None
|
||||
self._processLyrics()
|
||||
self.song.authors = []
|
||||
for row in range(self.authorsListView.count()):
|
||||
for row in xrange(self.authorsListView.count()):
|
||||
item = self.authorsListView.item(row)
|
||||
authorId = (item.data(QtCore.Qt.UserRole)).toInt()[0]
|
||||
self.song.authors.append(self.manager.get_object(Author, authorId))
|
||||
self.song.topics = []
|
||||
for row in range(self.topicsListView.count()):
|
||||
for row in xrange(self.topicsListView.count()):
|
||||
item = self.topicsListView.item(row)
|
||||
topicId = (item.data(QtCore.Qt.UserRole)).toInt()[0]
|
||||
self.song.topics.append(self.manager.get_object(Topic, topicId))
|
||||
# Save the song here because we need a valid id for the audio files.
|
||||
clean_song(self.manager, self.song)
|
||||
self.manager.save_object(self.song)
|
||||
self.mediaitem.auto_select_id = self.song.id
|
||||
audio_files = map(lambda a: a.file_name, self.song.media_files)
|
||||
log.debug(audio_files)
|
||||
save_path = os.path.join(
|
||||
AppLocation.get_section_data_path(self.mediaitem.plugin.name),
|
||||
'audio', str(self.song.id))
|
||||
if not os.path.exists(save_path):
|
||||
os.makedirs(save_path)
|
||||
self.song.media_files = []
|
||||
files = []
|
||||
for row in xrange(self.audioListWidget.count()):
|
||||
item = self.audioListWidget.item(row)
|
||||
filename = unicode(item.data(QtCore.Qt.UserRole).toString())
|
||||
if not filename.startswith(save_path):
|
||||
oldfile, filename = filename, os.path.join(save_path,
|
||||
os.path.split(filename)[1])
|
||||
shutil.copyfile(oldfile, filename)
|
||||
files.append(filename)
|
||||
media_file = MediaFile()
|
||||
media_file.file_name = filename
|
||||
media_file.type = u'audio'
|
||||
media_file.weight = row
|
||||
self.song.media_files.append(media_file)
|
||||
for audio in audio_files:
|
||||
if audio not in files:
|
||||
try:
|
||||
os.remove(audio)
|
||||
except:
|
||||
log.exception('Could not remove file: %s', audio)
|
||||
pass
|
||||
if not files:
|
||||
try:
|
||||
os.rmdir(save_path)
|
||||
except OSError:
|
||||
log.exception(u'Could not remove directory: %s', save_path)
|
||||
clean_song(self.manager, self.song)
|
||||
self.manager.save_object(self.song)
|
||||
self.mediaitem.autoSelectId = self.song.id
|
||||
|
||||
def _processLyrics(self):
|
||||
"""
|
||||
|
@ -783,3 +912,4 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
|
|||
except:
|
||||
log.exception(u'Problem processing song Lyrics \n%s',
|
||||
sxml.dump_xml())
|
||||
|
||||
|
|
|
@ -0,0 +1,75 @@
|
|||
# -*- 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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Miller, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from openlp.core.lib import translate, build_icon
|
||||
|
||||
class Ui_MediaFilesDialog(object):
|
||||
def setupUi(self, mediaFilesDialog):
|
||||
mediaFilesDialog.setObjectName(u'mediaFilesDialog')
|
||||
mediaFilesDialog.setWindowModality(QtCore.Qt.ApplicationModal)
|
||||
mediaFilesDialog.resize(400, 300)
|
||||
mediaFilesDialog.setModal(True)
|
||||
mediaFilesDialog.setWindowIcon(
|
||||
build_icon(u':/icon/openlp-logo-16x16.png'))
|
||||
self.filesVerticalLayout = QtGui.QVBoxLayout(mediaFilesDialog)
|
||||
self.filesVerticalLayout.setSpacing(8)
|
||||
self.filesVerticalLayout.setMargin(8)
|
||||
self.filesVerticalLayout.setObjectName(u'filesVerticalLayout')
|
||||
self.selectLabel = QtGui.QLabel(mediaFilesDialog)
|
||||
self.selectLabel.setWordWrap(True)
|
||||
self.selectLabel.setObjectName(u'selectLabel')
|
||||
self.filesVerticalLayout.addWidget(self.selectLabel)
|
||||
self.fileListWidget = QtGui.QListWidget(mediaFilesDialog)
|
||||
self.fileListWidget.setAlternatingRowColors(True)
|
||||
self.fileListWidget.setSelectionMode(
|
||||
QtGui.QAbstractItemView.ExtendedSelection)
|
||||
self.fileListWidget.setObjectName(u'fileListWidget')
|
||||
self.filesVerticalLayout.addWidget(self.fileListWidget)
|
||||
self.buttonBox = QtGui.QDialogButtonBox(mediaFilesDialog)
|
||||
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
|
||||
self.buttonBox.setStandardButtons(
|
||||
QtGui.QDialogButtonBox.Cancel | QtGui.QDialogButtonBox.Ok)
|
||||
self.buttonBox.setObjectName(u'buttonBox')
|
||||
self.filesVerticalLayout.addWidget(self.buttonBox)
|
||||
|
||||
self.retranslateUi(mediaFilesDialog)
|
||||
QtCore.QObject.connect(self.buttonBox,
|
||||
QtCore.SIGNAL(u'accepted()'), mediaFilesDialog.accept)
|
||||
QtCore.QObject.connect(self.buttonBox,
|
||||
QtCore.SIGNAL(u'rejected()'), mediaFilesDialog.reject)
|
||||
QtCore.QMetaObject.connectSlotsByName(mediaFilesDialog)
|
||||
|
||||
def retranslateUi(self, mediaFilesDialog):
|
||||
mediaFilesDialog.setWindowTitle(
|
||||
translate('SongsPlugin.MediaFilesForm', 'Select Media File(s)'))
|
||||
self.selectLabel.setText(
|
||||
translate('SongsPlugin.MediaFilesForm', u'Select one or more '
|
||||
'audio files from the list below, and click OK to import them '
|
||||
'into this song.'))
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
# -*- 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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Miller, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 os
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
|
||||
from mediafilesdialog import Ui_MediaFilesDialog
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
class MediaFilesForm(QtGui.QDialog, Ui_MediaFilesDialog):
|
||||
"""
|
||||
Class to show a list of files from the
|
||||
"""
|
||||
log.info(u'%s MediaFilesForm loaded', __name__)
|
||||
|
||||
def __init__(self, parent):
|
||||
QtGui.QDialog.__init__(self)
|
||||
self.setupUi(self)
|
||||
|
||||
def populateFiles(self, files):
|
||||
self.fileListWidget.clear()
|
||||
for file in files:
|
||||
item = QtGui.QListWidgetItem(os.path.split(file)[1])
|
||||
item.setData(QtCore.Qt.UserRole, file)
|
||||
self.fileListWidget.addItem(item)
|
||||
|
||||
def getSelectedFiles(self):
|
||||
return map(lambda x: unicode(x.data(QtCore.Qt.UserRole).toString()),
|
||||
self.fileListWidget.selectedItems())
|
||||
|
|
@ -170,8 +170,8 @@ class SongExportForm(OpenLPWizard):
|
|||
translate('OpenLP.Ui', 'Welcome to the Song Export Wizard'))
|
||||
self.informationLabel.setText(
|
||||
translate('SongsPlugin.ExportWizardForm', 'This wizard will help to'
|
||||
' export your songs to the open and free OpenLyrics worship song '
|
||||
'format.'))
|
||||
' export your songs to the open and free <strong>OpenLyrics'
|
||||
'</strong> worship song format.'))
|
||||
self.availableSongsPage.setTitle(
|
||||
translate('SongsPlugin.ExportWizardForm', 'Select Songs'))
|
||||
self.availableSongsPage.setSubTitle(
|
||||
|
@ -285,7 +285,9 @@ class SongExportForm(OpenLPWizard):
|
|||
self, songs, unicode(self.directoryLineEdit.text()))
|
||||
if exporter.do_export():
|
||||
self.progressLabel.setText(
|
||||
translate('SongsPlugin.SongExportForm', 'Finished export.'))
|
||||
translate('SongsPlugin.SongExportForm', 'Finished export. To '
|
||||
'import these files use the <strong>OpenLyrics</strong> '
|
||||
'importer.'))
|
||||
else:
|
||||
self.progressLabel.setText(
|
||||
translate('SongsPlugin.SongExportForm',
|
||||
|
|
|
@ -686,7 +686,7 @@ class SongImportForm(OpenLPWizard):
|
|||
def performWizard(self):
|
||||
"""
|
||||
Perform the actual import. This method pulls in the correct importer
|
||||
class, and then runs the ``do_import`` method of the importer to do
|
||||
class, and then runs the ``doImport`` method of the importer to do
|
||||
the actual importing.
|
||||
"""
|
||||
source_format = self.formatComboBox.currentIndex()
|
||||
|
@ -759,8 +759,8 @@ class SongImportForm(OpenLPWizard):
|
|||
importer = self.plugin.importSongs(SongFormat.FoilPresenter,
|
||||
filenames=self.getListOfFiles(self.foilPresenterFileListWidget)
|
||||
)
|
||||
importer.do_import()
|
||||
if importer.error_log:
|
||||
importer.doImport()
|
||||
if importer.errorLog:
|
||||
self.progressLabel.setText(translate(
|
||||
'SongsPlugin.SongImportForm', 'Your song import failed.'))
|
||||
else:
|
||||
|
|
|
@ -184,10 +184,11 @@ class VerseType(object):
|
|||
verse_index = VerseType.from_translated_string(verse_name)
|
||||
if verse_index is None:
|
||||
verse_index = VerseType.from_string(verse_name)
|
||||
if verse_index is None:
|
||||
verse_index = VerseType.from_translated_tag(verse_name)
|
||||
if verse_index is None:
|
||||
verse_index = VerseType.from_tag(verse_name)
|
||||
elif len(verse_name) == 1:
|
||||
if verse_index is None:
|
||||
verse_index = VerseType.from_translated_tag(verse_name)
|
||||
if verse_index is None:
|
||||
verse_index = VerseType.from_tag(verse_name)
|
||||
return verse_index
|
||||
|
||||
def retrieve_windows_encoding(recommendation=None):
|
||||
|
|
|
@ -55,13 +55,13 @@ class CCLIFileImport(SongImport):
|
|||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Import either a ``.usr`` or a ``.txt`` SongSelect file.
|
||||
"""
|
||||
log.debug(u'Starting CCLI File Import')
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
for filename in self.import_source:
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
for filename in self.importSource:
|
||||
filename = unicode(filename)
|
||||
log.debug(u'Importing CCLI File: %s', filename)
|
||||
lines = []
|
||||
|
@ -80,23 +80,23 @@ class CCLIFileImport(SongImport):
|
|||
ext = os.path.splitext(filename)[1]
|
||||
if ext.lower() == u'.usr':
|
||||
log.info(u'SongSelect .usr format file found: %s', filename)
|
||||
if not self.do_import_usr_file(lines):
|
||||
self.log_error(filename)
|
||||
if not self.doImportUsrFile(lines):
|
||||
self.logError(filename)
|
||||
elif ext.lower() == u'.txt':
|
||||
log.info(u'SongSelect .txt format file found: %s', filename)
|
||||
if not self.do_import_txt_file(lines):
|
||||
self.log_error(filename)
|
||||
if not self.doImportTxtFile(lines):
|
||||
self.logError(filename)
|
||||
else:
|
||||
self.log_error(filename,
|
||||
self.logError(filename,
|
||||
translate('SongsPlugin.CCLIFileImport',
|
||||
'The file does not have a valid extension.'))
|
||||
log.info(u'Extension %s is not valid', filename)
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
|
||||
def do_import_usr_file(self, textList):
|
||||
def doImportUsrFile(self, textList):
|
||||
"""
|
||||
The :func:`do_import_usr_file` method provides OpenLP with the ability
|
||||
The :func:`doImport_usr_file` method provides OpenLP with the ability
|
||||
to import CCLI SongSelect songs in *USR* file format.
|
||||
|
||||
``textList``
|
||||
|
@ -165,7 +165,7 @@ class CCLIFileImport(SongImport):
|
|||
elif line.startswith(u'Themes='):
|
||||
song_topics = line[7:].strip()
|
||||
elif line.startswith(u'[S A'):
|
||||
self.ccli_number = line[4:-3].strip()
|
||||
self.ccliNumber = line[4:-3].strip()
|
||||
elif line.startswith(u'Fields='):
|
||||
# Fields contain single line indicating verse, chorus, etc,
|
||||
# /t delimited, same as with words field. store seperately
|
||||
|
@ -204,7 +204,7 @@ class CCLIFileImport(SongImport):
|
|||
verse_type = VerseType.Tags[VerseType.Other]
|
||||
verse_text = verse_lines[1]
|
||||
if len(verse_text) > 0:
|
||||
self.add_verse(verse_text, verse_type)
|
||||
self.addVerse(verse_text, verse_type)
|
||||
check_first_verse_line = False
|
||||
# Handle multiple authors
|
||||
author_list = song_author.split(u'/')
|
||||
|
@ -213,15 +213,15 @@ class CCLIFileImport(SongImport):
|
|||
for author in author_list:
|
||||
separated = author.split(u',')
|
||||
if len(separated) > 1:
|
||||
self.add_author(u' '.join(reversed(separated)))
|
||||
self.addAuthor(u' '.join(reversed(separated)))
|
||||
else:
|
||||
self.add_author(author)
|
||||
self.addAuthor(author)
|
||||
self.topics = [topic.strip() for topic in song_topics.split(u'/t')]
|
||||
return self.finish()
|
||||
|
||||
def do_import_txt_file(self, textList):
|
||||
def doImportTxtFile(self, textList):
|
||||
"""
|
||||
The :func:`do_import_txt_file` method provides OpenLP with the ability
|
||||
The :func:`doImport_txt_file` method provides OpenLP with the ability
|
||||
to import CCLI SongSelect songs in *TXT* file format.
|
||||
|
||||
``textList``
|
||||
|
@ -264,7 +264,7 @@ class CCLIFileImport(SongImport):
|
|||
continue
|
||||
elif verse_start:
|
||||
if verse_text:
|
||||
self.add_verse(verse_text, verse_type)
|
||||
self.addVerse(verse_text, verse_type)
|
||||
verse_text = u''
|
||||
verse_start = False
|
||||
else:
|
||||
|
@ -278,7 +278,7 @@ class CCLIFileImport(SongImport):
|
|||
if clean_line.startswith(u'CCLI'):
|
||||
line_number += 1
|
||||
ccli_parts = clean_line.split(' ')
|
||||
self.ccli_number = ccli_parts[len(ccli_parts) - 1]
|
||||
self.ccliNumber = ccli_parts[len(ccli_parts) - 1]
|
||||
elif not verse_start:
|
||||
# We have the verse descriptor
|
||||
verse_desc_parts = clean_line.split(u' ')
|
||||
|
@ -333,5 +333,5 @@ class CCLIFileImport(SongImport):
|
|||
if len(author_list) < 2:
|
||||
author_list = song_author.split(u'|')
|
||||
# Clean spaces before and after author names.
|
||||
[self.add_author(author_name.strip()) for author_name in author_list]
|
||||
[self.addAuthor(author_name.strip()) for author_name in author_list]
|
||||
return self.finish()
|
||||
|
|
|
@ -31,6 +31,7 @@ the Songs plugin
|
|||
|
||||
from sqlalchemy import Column, ForeignKey, Table, types
|
||||
from sqlalchemy.orm import mapper, relation
|
||||
from sqlalchemy.sql.expression import func
|
||||
|
||||
from openlp.core.lib.db import BaseModel, init_db
|
||||
|
||||
|
@ -70,7 +71,6 @@ class Topic(BaseModel):
|
|||
"""
|
||||
pass
|
||||
|
||||
|
||||
def init_schema(url):
|
||||
"""
|
||||
Setup the songs database connection and initialise the database schema.
|
||||
|
@ -111,10 +111,6 @@ def init_schema(url):
|
|||
* file_name
|
||||
* type
|
||||
|
||||
**media_files_songs Table**
|
||||
* media_file_id
|
||||
* song_id
|
||||
|
||||
**song_books Table**
|
||||
The *song_books* table holds a list of books that a congregation gets
|
||||
their songs from, or old hymnals now no longer used. This table has the
|
||||
|
@ -162,7 +158,7 @@ def init_schema(url):
|
|||
|
||||
# Definition of the "authors" table
|
||||
authors_table = Table(u'authors', metadata,
|
||||
Column(u'id', types.Integer, primary_key=True),
|
||||
Column(u'id', types.Integer(), primary_key=True),
|
||||
Column(u'first_name', types.Unicode(128)),
|
||||
Column(u'last_name', types.Unicode(128)),
|
||||
Column(u'display_name', types.Unicode(255), index=True, nullable=False)
|
||||
|
@ -170,22 +166,25 @@ def init_schema(url):
|
|||
|
||||
# Definition of the "media_files" table
|
||||
media_files_table = Table(u'media_files', metadata,
|
||||
Column(u'id', types.Integer, primary_key=True),
|
||||
Column(u'id', types.Integer(), primary_key=True),
|
||||
Column(u'song_id', types.Integer(), ForeignKey(u'songs.id'),
|
||||
default=None),
|
||||
Column(u'file_name', types.Unicode(255), nullable=False),
|
||||
Column(u'type', types.Unicode(64), nullable=False, default=u'audio')
|
||||
Column(u'type', types.Unicode(64), nullable=False, default=u'audio'),
|
||||
Column(u'weight', types.Integer(), default=0)
|
||||
)
|
||||
|
||||
# Definition of the "song_books" table
|
||||
song_books_table = Table(u'song_books', metadata,
|
||||
Column(u'id', types.Integer, primary_key=True),
|
||||
Column(u'id', types.Integer(), primary_key=True),
|
||||
Column(u'name', types.Unicode(128), nullable=False),
|
||||
Column(u'publisher', types.Unicode(128))
|
||||
)
|
||||
|
||||
# Definition of the "songs" table
|
||||
songs_table = Table(u'songs', metadata,
|
||||
Column(u'id', types.Integer, primary_key=True),
|
||||
Column(u'song_book_id', types.Integer,
|
||||
Column(u'id', types.Integer(), primary_key=True),
|
||||
Column(u'song_book_id', types.Integer(),
|
||||
ForeignKey(u'song_books.id'), default=None),
|
||||
Column(u'title', types.Unicode(255), nullable=False),
|
||||
Column(u'alternate_title', types.Unicode(255)),
|
||||
|
@ -197,36 +196,31 @@ def init_schema(url):
|
|||
Column(u'song_number', types.Unicode(64)),
|
||||
Column(u'theme_name', types.Unicode(128)),
|
||||
Column(u'search_title', types.Unicode(255), index=True, nullable=False),
|
||||
Column(u'search_lyrics', types.UnicodeText, nullable=False)
|
||||
Column(u'search_lyrics', types.UnicodeText, nullable=False),
|
||||
Column(u'create_date', types.DateTime(), default=func.now()),
|
||||
Column(u'last_modified', types.DateTime(), default=func.now(),
|
||||
onupdate=func.now())
|
||||
)
|
||||
|
||||
# Definition of the "topics" table
|
||||
topics_table = Table(u'topics', metadata,
|
||||
Column(u'id', types.Integer, primary_key=True),
|
||||
Column(u'id', types.Integer(), primary_key=True),
|
||||
Column(u'name', types.Unicode(128), index=True, nullable=False)
|
||||
)
|
||||
|
||||
# Definition of the "authors_songs" table
|
||||
authors_songs_table = Table(u'authors_songs', metadata,
|
||||
Column(u'author_id', types.Integer,
|
||||
Column(u'author_id', types.Integer(),
|
||||
ForeignKey(u'authors.id'), primary_key=True),
|
||||
Column(u'song_id', types.Integer,
|
||||
ForeignKey(u'songs.id'), primary_key=True)
|
||||
)
|
||||
|
||||
# Definition of the "media_files_songs" table
|
||||
media_files_songs_table = Table(u'media_files_songs', metadata,
|
||||
Column(u'media_file_id', types.Integer,
|
||||
ForeignKey(u'media_files.id'), primary_key=True),
|
||||
Column(u'song_id', types.Integer,
|
||||
Column(u'song_id', types.Integer(),
|
||||
ForeignKey(u'songs.id'), primary_key=True)
|
||||
)
|
||||
|
||||
# Definition of the "songs_topics" table
|
||||
songs_topics_table = Table(u'songs_topics', metadata,
|
||||
Column(u'song_id', types.Integer,
|
||||
Column(u'song_id', types.Integer(),
|
||||
ForeignKey(u'songs.id'), primary_key=True),
|
||||
Column(u'topic_id', types.Integer,
|
||||
Column(u'topic_id', types.Integer(),
|
||||
ForeignKey(u'topics.id'), primary_key=True)
|
||||
)
|
||||
|
||||
|
@ -239,7 +233,7 @@ def init_schema(url):
|
|||
secondary=authors_songs_table, lazy=False),
|
||||
'book': relation(Book, backref='songs'),
|
||||
'media_files': relation(MediaFile, backref='songs',
|
||||
secondary=media_files_songs_table),
|
||||
order_by=media_files_table.c.weight),
|
||||
'topics': relation(Topic, backref='songs',
|
||||
secondary=songs_topics_table)
|
||||
})
|
||||
|
|
|
@ -49,50 +49,50 @@ class EasiSlidesImport(SongImport):
|
|||
SongImport.__init__(self, manager, **kwargs)
|
||||
self.commit = True
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Import either each of the files in self.import_sources - each element of
|
||||
Import either each of the files in self.importSources - each element of
|
||||
which can be either a single opensong file, or a zipfile containing
|
||||
multiple opensong files. If `self.commit` is set False, the
|
||||
import will not be committed to the database (useful for test scripts).
|
||||
"""
|
||||
log.info(u'Importing EasiSlides XML file %s', self.import_source)
|
||||
log.info(u'Importing EasiSlides XML file %s', self.importSource)
|
||||
parser = etree.XMLParser(remove_blank_text=True)
|
||||
parsed_file = etree.parse(self.import_source, parser)
|
||||
parsed_file = etree.parse(self.importSource, parser)
|
||||
xml = unicode(etree.tostring(parsed_file))
|
||||
song_xml = objectify.fromstring(xml)
|
||||
self.import_wizard.progressBar.setMaximum(len(song_xml.Item))
|
||||
self.importWizard.progressBar.setMaximum(len(song_xml.Item))
|
||||
for song in song_xml.Item:
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
self._parse_song(song)
|
||||
self._parseSong(song)
|
||||
|
||||
def _parse_song(self, song):
|
||||
def _parseSong(self, song):
|
||||
self._success = True
|
||||
self._add_unicode_attribute(u'title', song.Title1, True)
|
||||
self._addUnicodeAttribute(u'title', song.Title1, True)
|
||||
if hasattr(song, u'Title2'):
|
||||
self._add_unicode_attribute(u'alternate_title', song.Title2)
|
||||
self._addUnicodeAttribute(u'alternateTitle', song.Title2)
|
||||
if hasattr(song, u'SongNumber'):
|
||||
self._add_unicode_attribute(u'song_number', song.SongNumber)
|
||||
if self.song_number == u'0':
|
||||
self.song_number = u''
|
||||
self._add_authors(song)
|
||||
self._addUnicodeAttribute(u'songNumber', song.SongNumber)
|
||||
if self.songNumber == u'0':
|
||||
self.songNumber = u''
|
||||
self._addAuthors(song)
|
||||
if hasattr(song, u'Copyright'):
|
||||
self._add_copyright(song.Copyright)
|
||||
self._addCopyright(song.Copyright)
|
||||
if hasattr(song, u'LicenceAdmin1'):
|
||||
self._add_copyright(song.LicenceAdmin1)
|
||||
self._addCopyright(song.LicenceAdmin1)
|
||||
if hasattr(song, u'LicenceAdmin2'):
|
||||
self._add_copyright(song.LicenceAdmin2)
|
||||
self._addCopyright(song.LicenceAdmin2)
|
||||
if hasattr(song, u'BookReference'):
|
||||
self._add_unicode_attribute(u'song_book_name', song.BookReference)
|
||||
self._parse_and_add_lyrics(song)
|
||||
self._addUnicodeAttribute(u'songBookName', song.BookReference)
|
||||
self._parseAndAddLyrics(song)
|
||||
if self._success:
|
||||
if not self.finish():
|
||||
self.log_error(song.Title1 if song.Title1 else u'')
|
||||
self.logError(song.Title1 if song.Title1 else u'')
|
||||
else:
|
||||
self.set_defaults()
|
||||
self.setDefaults()
|
||||
|
||||
def _add_unicode_attribute(self, self_attribute, import_attribute,
|
||||
def _addUnicodeAttribute(self, self_attribute, import_attribute,
|
||||
mandatory=False):
|
||||
"""
|
||||
Add imported values to the song model converting them to unicode at the
|
||||
|
@ -119,7 +119,7 @@ class EasiSlidesImport(SongImport):
|
|||
if mandatory:
|
||||
self._success = False
|
||||
|
||||
def _add_authors(self, song):
|
||||
def _addAuthors(self, song):
|
||||
try:
|
||||
authors = unicode(song.Writer).split(u',')
|
||||
self.authors = \
|
||||
|
@ -130,7 +130,7 @@ class EasiSlidesImport(SongImport):
|
|||
except AttributeError:
|
||||
pass
|
||||
|
||||
def _add_copyright(self, element):
|
||||
def _addCopyright(self, element):
|
||||
"""
|
||||
Add a piece of copyright to the total copyright information for the
|
||||
song.
|
||||
|
@ -139,14 +139,14 @@ class EasiSlidesImport(SongImport):
|
|||
The imported variable to get the data from.
|
||||
"""
|
||||
try:
|
||||
self.add_copyright(unicode(element).strip())
|
||||
self.addCopyright(unicode(element).strip())
|
||||
except UnicodeDecodeError:
|
||||
log.exception(u'Unicode error on decoding copyright: %s' % element)
|
||||
self._success = False
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
def _parse_and_add_lyrics(self, song):
|
||||
def _parseAndAddLyrics(self, song):
|
||||
try:
|
||||
lyrics = unicode(song.Contents).strip()
|
||||
except UnicodeDecodeError:
|
||||
|
@ -295,7 +295,7 @@ class EasiSlidesImport(SongImport):
|
|||
else:
|
||||
continue
|
||||
if tag in versetags:
|
||||
self.verse_order_list.append(tag)
|
||||
self.verseOrderList.append(tag)
|
||||
else:
|
||||
log.info(u'Got order item %s, which is not in versetags,'
|
||||
u'dropping item from presentation order', tag)
|
||||
|
|
|
@ -49,15 +49,15 @@ def strip_rtf(blob, encoding):
|
|||
control = False
|
||||
clear_text = []
|
||||
control_word = []
|
||||
|
||||
# workaround for \tx bug: remove one pair of curly braces
|
||||
|
||||
# workaround for \tx bug: remove one pair of curly braces
|
||||
# if \tx is encountered
|
||||
match = RTF_STRIPPING_REGEX.search(blob)
|
||||
if match:
|
||||
# start and end indices of match are curly braces - filter them out
|
||||
blob = ''.join([blob[i] for i in xrange(len(blob))
|
||||
blob = ''.join([blob[i] for i in xrange(len(blob))
|
||||
if i != match.start() and i !=match.end()])
|
||||
|
||||
|
||||
for c in blob:
|
||||
if control:
|
||||
# for delimiters, set control to False
|
||||
|
@ -155,24 +155,24 @@ class EasyWorshipSongImport(SongImport):
|
|||
def __init__(self, manager, **kwargs):
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
# Open the DB and MB files if they exist
|
||||
import_source_mb = self.import_source.replace('.DB', '.MB')
|
||||
if not os.path.isfile(self.import_source):
|
||||
import_source_mb = self.importSource.replace('.DB', '.MB')
|
||||
if not os.path.isfile(self.importSource):
|
||||
return
|
||||
if not os.path.isfile(import_source_mb):
|
||||
return
|
||||
db_size = os.path.getsize(self.import_source)
|
||||
db_size = os.path.getsize(self.importSource)
|
||||
if db_size < 0x800:
|
||||
return
|
||||
db_file = open(self.import_source, 'rb')
|
||||
self.memo_file = open(import_source_mb, 'rb')
|
||||
db_file = open(self.importSource, 'rb')
|
||||
self.memoFile = open(import_source_mb, 'rb')
|
||||
# Don't accept files that are clearly not paradox files
|
||||
record_size, header_size, block_size, first_block, num_fields \
|
||||
= struct.unpack('<hhxb8xh17xh', db_file.read(35))
|
||||
if header_size != 0x800 or block_size < 1 or block_size > 4:
|
||||
db_file.close()
|
||||
self.memo_file.close()
|
||||
self.memoFile.close()
|
||||
return
|
||||
# Take a stab at how text is encoded
|
||||
self.encoding = u'cp1252'
|
||||
|
@ -204,7 +204,7 @@ class EasyWorshipSongImport(SongImport):
|
|||
# There does not appear to be a _reliable_ way of getting the number
|
||||
# of songs/records, so let's use file blocks for measuring progress.
|
||||
total_blocks = (db_size - header_size) / (block_size * 1024)
|
||||
self.import_wizard.progressBar.setMaximum(total_blocks)
|
||||
self.importWizard.progressBar.setMaximum(total_blocks)
|
||||
# Read the field description information
|
||||
db_file.seek(120)
|
||||
field_info = db_file.read(num_fields * 2)
|
||||
|
@ -218,16 +218,16 @@ class EasyWorshipSongImport(SongImport):
|
|||
field_info, i * 2)
|
||||
field_descs.append(FieldDescEntry(field_name, field_type,
|
||||
field_size))
|
||||
self.set_record_struct(field_descs)
|
||||
self.setRecordStruct(field_descs)
|
||||
# Pick out the field description indexes we will need
|
||||
try:
|
||||
success = True
|
||||
fi_title = self.find_field(u'Title')
|
||||
fi_author = self.find_field(u'Author')
|
||||
fi_copy = self.find_field(u'Copyright')
|
||||
fi_admin = self.find_field(u'Administrator')
|
||||
fi_words = self.find_field(u'Words')
|
||||
fi_ccli = self.find_field(u'Song Number')
|
||||
fi_title = self.findField(u'Title')
|
||||
fi_author = self.findField(u'Author')
|
||||
fi_copy = self.findField(u'Copyright')
|
||||
fi_admin = self.findField(u'Administrator')
|
||||
fi_words = self.findField(u'Words')
|
||||
fi_ccli = self.findField(u'Song Number')
|
||||
except IndexError:
|
||||
# This is the wrong table
|
||||
success = False
|
||||
|
@ -239,18 +239,18 @@ class EasyWorshipSongImport(SongImport):
|
|||
rec_count = (rec_count + record_size) / record_size
|
||||
# Loop through each record within the current block
|
||||
for i in range(rec_count):
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
raw_record = db_file.read(record_size)
|
||||
self.fields = self.record_struct.unpack(raw_record)
|
||||
self.set_defaults()
|
||||
self.title = self.get_field(fi_title)
|
||||
self.setDefaults()
|
||||
self.title = self.getField(fi_title)
|
||||
# Get remaining fields.
|
||||
copy = self.get_field(fi_copy)
|
||||
admin = self.get_field(fi_admin)
|
||||
ccli = self.get_field(fi_ccli)
|
||||
authors = self.get_field(fi_author)
|
||||
words = self.get_field(fi_words)
|
||||
copy = self.getField(fi_copy)
|
||||
admin = self.getField(fi_admin)
|
||||
ccli = self.getField(fi_ccli)
|
||||
authors = self.getField(fi_author)
|
||||
words = self.getField(fi_words)
|
||||
# Set the SongImport object members.
|
||||
if copy:
|
||||
self.copyright = copy
|
||||
|
@ -261,7 +261,7 @@ class EasyWorshipSongImport(SongImport):
|
|||
unicode(translate('SongsPlugin.EasyWorshipSongImport',
|
||||
'Administered by %s')) % admin
|
||||
if ccli:
|
||||
self.ccli_number = ccli
|
||||
self.ccliNumber = ccli
|
||||
if authors:
|
||||
# Split up the authors
|
||||
author_list = authors.split(u'/')
|
||||
|
@ -270,7 +270,7 @@ class EasyWorshipSongImport(SongImport):
|
|||
if len(author_list) < 2:
|
||||
author_list = authors.split(u',')
|
||||
for author_name in author_list:
|
||||
self.add_author(author_name.strip())
|
||||
self.addAuthor(author_name.strip())
|
||||
if words:
|
||||
# Format the lyrics
|
||||
words = strip_rtf(words, self.encoding)
|
||||
|
@ -281,9 +281,9 @@ class EasyWorshipSongImport(SongImport):
|
|||
continue
|
||||
verse_split = verse.split(u'\n', 1)
|
||||
first_line_is_tag = False
|
||||
# EW tags: verse, chorus, pre-chorus, bridge, tag,
|
||||
# EW tags: verse, chorus, pre-chorus, bridge, tag,
|
||||
# intro, ending, slide
|
||||
for type in VerseType.Names+[u'tag', u'slide']:
|
||||
for type in VerseType.Names+[u'tag', u'slide']:
|
||||
type = type.lower()
|
||||
ew_tag = verse_split[0].strip().lower()
|
||||
if ew_tag.startswith(type):
|
||||
|
@ -293,7 +293,7 @@ class EasyWorshipSongImport(SongImport):
|
|||
first_line_is_tag = True
|
||||
number_found = False
|
||||
# check if tag is followed by number and/or note
|
||||
if len(ew_tag) > len(type):
|
||||
if len(ew_tag) > len(type):
|
||||
match = NUMBER_REGEX.search(ew_tag)
|
||||
if match:
|
||||
number = match.group()
|
||||
|
@ -305,23 +305,24 @@ class EasyWorshipSongImport(SongImport):
|
|||
if not number_found:
|
||||
verse_type += u'1'
|
||||
break
|
||||
self.add_verse(
|
||||
verse_split[-1].strip() if first_line_is_tag else verse,
|
||||
self.addVerse(
|
||||
verse_split[-1].strip() \
|
||||
if first_line_is_tag else verse,
|
||||
verse_type)
|
||||
if len(self.comments) > 5:
|
||||
self.comments += unicode(
|
||||
translate('SongsPlugin.EasyWorshipSongImport',
|
||||
'\n[above are Song Tags with notes imported from \
|
||||
EasyWorship]'))
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
if not self.finish():
|
||||
self.log_error(self.import_source)
|
||||
self.logError(self.importSource)
|
||||
db_file.close()
|
||||
self.memo_file.close()
|
||||
self.memoFile.close()
|
||||
|
||||
def find_field(self, field_name):
|
||||
return [i for i, x in enumerate(self.field_descs)
|
||||
return [i for i, x in enumerate(self.fieldDescs)
|
||||
if x.name == field_name][0]
|
||||
|
||||
def set_record_struct(self, field_descs):
|
||||
|
@ -351,12 +352,12 @@ class EasyWorshipSongImport(SongImport):
|
|||
fsl.append('Q')
|
||||
else:
|
||||
fsl.append('%ds' % field_desc.size)
|
||||
self.record_struct = struct.Struct(''.join(fsl))
|
||||
self.field_descs = field_descs
|
||||
self.recordStruct = struct.Struct(''.join(fsl))
|
||||
self.fieldDescs = field_descs
|
||||
|
||||
def get_field(self, field_desc_index):
|
||||
field = self.fields[field_desc_index]
|
||||
field_desc = self.field_descs[field_desc_index]
|
||||
field_desc = self.fieldDescs[field_desc_index]
|
||||
# Return None in case of 'blank' entries
|
||||
if isinstance(field, str):
|
||||
if len(field.rstrip('\0')) == 0:
|
||||
|
@ -382,18 +383,18 @@ class EasyWorshipSongImport(SongImport):
|
|||
struct.unpack_from('<II', field, len(field)-10)
|
||||
sub_block = block_start & 0xff
|
||||
block_start &= ~0xff
|
||||
self.memo_file.seek(block_start)
|
||||
memo_block_type, = struct.unpack('b', self.memo_file.read(1))
|
||||
self.memoFile.seek(block_start)
|
||||
memo_block_type, = struct.unpack('b', self.memoFile.read(1))
|
||||
if memo_block_type == 2:
|
||||
self.memo_file.seek(8, os.SEEK_CUR)
|
||||
self.memoFile.seek(8, os.SEEK_CUR)
|
||||
elif memo_block_type == 3:
|
||||
if sub_block > 63:
|
||||
return u''
|
||||
self.memo_file.seek(11 + (5 * sub_block), os.SEEK_CUR)
|
||||
sub_block_start, = struct.unpack('B', self.memo_file.read(1))
|
||||
self.memo_file.seek(block_start + (sub_block_start * 16))
|
||||
self.memoFile.seek(11 + (5 * sub_block), os.SEEK_CUR)
|
||||
sub_block_start, = struct.unpack('B', self.memoFile.read(1))
|
||||
self.memoFile.seek(block_start + (sub_block_start * 16))
|
||||
else:
|
||||
return u''
|
||||
return self.memo_file.read(blob_size)
|
||||
return self.memoFile.read(blob_size)
|
||||
else:
|
||||
return 0
|
||||
|
|
|
@ -115,23 +115,23 @@ class FoilPresenterImport(SongImport):
|
|||
SongImport.__init__(self, manager, **kwargs)
|
||||
self.FoilPresenter = FoilPresenter(self.manager)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Imports the songs.
|
||||
"""
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
parser = etree.XMLParser(remove_blank_text=True)
|
||||
for file_path in self.import_source:
|
||||
if self.stop_import_flag:
|
||||
for file_path in self.importSource:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
self.import_wizard.incrementProgressBar(
|
||||
self.importWizard.incrementProgressBar(
|
||||
WizardStrings.ImportingType % os.path.basename(file_path))
|
||||
try:
|
||||
parsed_file = etree.parse(file_path, parser)
|
||||
xml = unicode(etree.tostring(parsed_file))
|
||||
self.FoilPresenter.xml_to_song(xml)
|
||||
except etree.XMLSyntaxError:
|
||||
self.log_error(file_path, SongStrings.XMLSyntaxError)
|
||||
self.logError(file_path, SongStrings.XMLSyntaxError)
|
||||
log.exception(u'XML syntax error in file %s' % file_path)
|
||||
|
||||
|
||||
|
|
|
@ -28,6 +28,8 @@
|
|||
import logging
|
||||
import locale
|
||||
import re
|
||||
import os
|
||||
import shutil
|
||||
|
||||
from PyQt4 import QtCore, QtGui
|
||||
from sqlalchemy.sql import or_
|
||||
|
@ -37,11 +39,12 @@ from openlp.core.lib import MediaManagerItem, Receiver, ItemCapabilities, \
|
|||
from openlp.core.lib.searchedit import SearchEdit
|
||||
from openlp.core.lib.ui import UiStrings, context_menu_action, \
|
||||
context_menu_separator
|
||||
from openlp.core.utils import AppLocation
|
||||
from openlp.plugins.songs.forms import EditSongForm, SongMaintenanceForm, \
|
||||
SongImportForm, SongExportForm
|
||||
from openlp.plugins.songs.lib import OpenLyrics, SongXML, VerseType, \
|
||||
clean_string
|
||||
from openlp.plugins.songs.lib.db import Author, Song
|
||||
from openlp.plugins.songs.lib.db import Author, Song, MediaFile
|
||||
from openlp.plugins.songs.lib.ui import SongStrings
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
@ -66,11 +69,11 @@ class SongMediaItem(MediaManagerItem):
|
|||
def __init__(self, parent, plugin, icon):
|
||||
self.IconPath = u'songs/song'
|
||||
MediaManagerItem.__init__(self, parent, plugin, icon)
|
||||
self.edit_song_form = EditSongForm(self, self.plugin.formparent,
|
||||
self.editSongForm = EditSongForm(self, self.plugin.formparent,
|
||||
self.plugin.manager)
|
||||
self.openLyrics = OpenLyrics(self.plugin.manager)
|
||||
self.singleServiceItem = False
|
||||
self.song_maintenance_form = SongMaintenanceForm(
|
||||
self.songMaintenanceForm = SongMaintenanceForm(
|
||||
self.plugin.manager, self)
|
||||
# Holds information about whether the edit is remotly triggered and
|
||||
# which Song is required.
|
||||
|
@ -79,6 +82,22 @@ class SongMediaItem(MediaManagerItem):
|
|||
self.quickPreviewAllowed = True
|
||||
self.hasSearch = True
|
||||
|
||||
def _updateBackgroundAudio(self, song, item):
|
||||
song.media_files = []
|
||||
for i, bga in enumerate(item.background_audio):
|
||||
dest_file = os.path.join(
|
||||
AppLocation.get_section_data_path(self.plugin.name),
|
||||
u'audio', str(song.id), os.path.split(bga)[1])
|
||||
if not os.path.exists(os.path.split(dest_file)[0]):
|
||||
os.makedirs(os.path.split(dest_file)[0])
|
||||
shutil.copyfile(os.path.join(
|
||||
AppLocation.get_section_data_path(
|
||||
u'servicemanager'), bga),
|
||||
dest_file)
|
||||
song.media_files.append(MediaFile.populate(
|
||||
weight=i, file_name=dest_file))
|
||||
self.plugin.manager.save_object(song, True)
|
||||
|
||||
def addEndHeaderBar(self):
|
||||
self.addToolbarSeparator()
|
||||
## Song Maintenance Button ##
|
||||
|
@ -210,7 +229,7 @@ class SongMediaItem(MediaManagerItem):
|
|||
search_results = self.plugin.manager.get_all_objects(Song,
|
||||
Song.theme_name.like(u'%' + search_keywords + u'%'))
|
||||
self.displayResultsSong(search_results)
|
||||
self.check_search_result()
|
||||
self.checkSearchResult()
|
||||
|
||||
def searchEntire(self, search_keywords):
|
||||
return self.plugin.manager.get_all_objects(Song,
|
||||
|
@ -244,7 +263,7 @@ class SongMediaItem(MediaManagerItem):
|
|||
|
||||
def displayResultsSong(self, searchresults):
|
||||
log.debug(u'display results Song')
|
||||
self.save_auto_select_id()
|
||||
self.saveAutoSelectId()
|
||||
self.listView.clear()
|
||||
# Sort the songs by its title considering language specific characters.
|
||||
# lower() is needed for windows!
|
||||
|
@ -258,9 +277,9 @@ class SongMediaItem(MediaManagerItem):
|
|||
song_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(song.id))
|
||||
self.listView.addItem(song_name)
|
||||
# Auto-select the item if name has been set
|
||||
if song.id == self.auto_select_id:
|
||||
if song.id == self.autoSelectId:
|
||||
self.listView.setCurrentItem(song_name)
|
||||
self.auto_select_id = -1
|
||||
self.autoSelectId = -1
|
||||
|
||||
def displayResultsAuthor(self, searchresults):
|
||||
log.debug(u'display results Author')
|
||||
|
@ -297,25 +316,26 @@ class SongMediaItem(MediaManagerItem):
|
|||
self.onClearTextButtonClick()
|
||||
|
||||
def onImportClick(self):
|
||||
if not hasattr(self, u'import_wizard'):
|
||||
self.import_wizard = SongImportForm(self, self.plugin)
|
||||
if self.import_wizard.exec_() == QtGui.QDialog.Accepted:
|
||||
if not hasattr(self, u'importWizard'):
|
||||
self.importWizard = SongImportForm(self, self.plugin)
|
||||
if self.importWizard.exec_() == QtGui.QDialog.Accepted:
|
||||
Receiver.send_message(u'songs_load_list')
|
||||
|
||||
def onExportClick(self):
|
||||
export_wizard = SongExportForm(self, self.plugin)
|
||||
export_wizard.exec_()
|
||||
if not hasattr(self, u'exportWizard'):
|
||||
self.exportWizard = SongExportForm(self, self.plugin)
|
||||
self.exportWizard.exec_()
|
||||
|
||||
def onNewClick(self):
|
||||
log.debug(u'onNewClick')
|
||||
self.edit_song_form.newSong()
|
||||
self.edit_song_form.exec_()
|
||||
self.editSongForm.newSong()
|
||||
self.editSongForm.exec_()
|
||||
self.onClearTextButtonClick()
|
||||
self.onSelectionChange()
|
||||
self.auto_select_id = -1
|
||||
self.autoSelectId = -1
|
||||
|
||||
def onSongMaintenanceClick(self):
|
||||
self.song_maintenance_form.exec_()
|
||||
self.songMaintenanceForm.exec_()
|
||||
|
||||
def onRemoteEditClear(self):
|
||||
log.debug(u'onRemoteEditClear')
|
||||
|
@ -335,9 +355,9 @@ class SongMediaItem(MediaManagerItem):
|
|||
if valid:
|
||||
self.remoteSong = song_id
|
||||
self.remoteTriggered = remote_type
|
||||
self.edit_song_form.loadSong(song_id, (remote_type == u'P'))
|
||||
self.edit_song_form.exec_()
|
||||
self.auto_select_id = -1
|
||||
self.editSongForm.loadSong(song_id, remote_type == u'P')
|
||||
self.editSongForm.exec_()
|
||||
self.autoSelectId = -1
|
||||
self.onSongListLoad()
|
||||
|
||||
def onEditClick(self):
|
||||
|
@ -348,9 +368,9 @@ class SongMediaItem(MediaManagerItem):
|
|||
if check_item_selected(self.listView, UiStrings().SelectEdit):
|
||||
self.editItem = self.listView.currentItem()
|
||||
item_id = (self.editItem.data(QtCore.Qt.UserRole)).toInt()[0]
|
||||
self.edit_song_form.loadSong(item_id, False)
|
||||
self.edit_song_form.exec_()
|
||||
self.auto_select_id = -1
|
||||
self.editSongForm.loadSong(item_id, False)
|
||||
self.editSongForm.exec_()
|
||||
self.autoSelectId = -1
|
||||
self.onSongListLoad()
|
||||
self.editItem = None
|
||||
|
||||
|
@ -371,6 +391,20 @@ class SongMediaItem(MediaManagerItem):
|
|||
return
|
||||
for item in items:
|
||||
item_id = (item.data(QtCore.Qt.UserRole)).toInt()[0]
|
||||
media_files = self.plugin.manager.get_all_objects(MediaFile,
|
||||
MediaFile.song_id == item_id)
|
||||
for media_file in media_files:
|
||||
try:
|
||||
os.remove(media_file.file_name)
|
||||
except:
|
||||
log.exception('Could not remove file: %s', audio)
|
||||
try:
|
||||
save_path = os.path.join(AppLocation.get_section_data_path(
|
||||
self.plugin.name), 'audio', str(item_id))
|
||||
if os.path.exists(save_path):
|
||||
os.rmdir(save_path)
|
||||
except OSError:
|
||||
log.exception(u'Could not remove directory: %s', save_path)
|
||||
self.plugin.manager.delete_object(Song, item_id)
|
||||
self.onSearchTextButtonClick()
|
||||
|
||||
|
@ -392,15 +426,16 @@ class SongMediaItem(MediaManagerItem):
|
|||
self.plugin.manager.save_object(new_song)
|
||||
self.onSongListLoad()
|
||||
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False):
|
||||
def generateSlideData(self, service_item, item=None, xmlVersion=False,
|
||||
remote=False):
|
||||
log.debug(u'generateSlideData (%s:%s)' % (service_item, item))
|
||||
item_id = self._getIdOfItemToGenerate(item, self.remoteSong)
|
||||
service_item.add_capability(ItemCapabilities.AllowsEdit)
|
||||
service_item.add_capability(ItemCapabilities.AllowsPreview)
|
||||
service_item.add_capability(ItemCapabilities.AllowsLoop)
|
||||
service_item.add_capability(ItemCapabilities.CanEdit)
|
||||
service_item.add_capability(ItemCapabilities.CanPreview)
|
||||
service_item.add_capability(ItemCapabilities.CanLoop)
|
||||
service_item.add_capability(ItemCapabilities.OnLoadUpdate)
|
||||
service_item.add_capability(ItemCapabilities.AddIfNewItem)
|
||||
service_item.add_capability(ItemCapabilities.AllowsVirtualSplit)
|
||||
service_item.add_capability(ItemCapabilities.CanSoftBreak)
|
||||
song = self.plugin.manager.get_object(Song, item_id)
|
||||
service_item.theme = song.theme_name
|
||||
service_item.edit_id = item_id
|
||||
|
@ -471,6 +506,10 @@ class SongMediaItem(MediaManagerItem):
|
|||
service_item.data_string = {u'title': song.search_title,
|
||||
u'authors': u', '.join(author_list)}
|
||||
service_item.xml_version = self.openLyrics.song_to_xml(song)
|
||||
# Add the audio file to the service item.
|
||||
if len(song.media_files) > 0:
|
||||
service_item.add_capability(ItemCapabilities.HasBackgroundAudio)
|
||||
service_item.background_audio = [m.file_name for m in song.media_files]
|
||||
return True
|
||||
|
||||
def serviceLoad(self, item):
|
||||
|
@ -510,8 +549,15 @@ class SongMediaItem(MediaManagerItem):
|
|||
add_song = False
|
||||
editId = song.id
|
||||
break
|
||||
# If there's any backing tracks, copy them over.
|
||||
if len(item.background_audio) > 0:
|
||||
self._updateBackgroundAudio(song, item)
|
||||
if add_song and self.addSongFromService:
|
||||
editId = self.openLyrics.xml_to_song(item.xml_version)
|
||||
song = self.openLyrics.xml_to_song(item.xml_version)
|
||||
# If there's any backing tracks, copy them over.
|
||||
if len(item.background_audio) > 0:
|
||||
self._updateBackgroundAudio(song, item)
|
||||
editId = song.id
|
||||
self.onSearchTextButtonClick()
|
||||
# Update service with correct song id.
|
||||
if editId:
|
||||
|
|
|
@ -32,6 +32,8 @@ openlp.org 1.x song databases into the current installation database.
|
|||
import logging
|
||||
from chardet.universaldetector import UniversalDetector
|
||||
import sqlite
|
||||
import sys
|
||||
import os
|
||||
|
||||
from openlp.core.lib import translate
|
||||
from openlp.plugins.songs.lib import retrieve_windows_encoding
|
||||
|
@ -44,7 +46,7 @@ class OpenLP1SongImport(SongImport):
|
|||
The :class:`OpenLP1SongImport` class provides OpenLP with the ability to
|
||||
import song databases from installations of openlp.org 1.x.
|
||||
"""
|
||||
last_encoding = u'windows-1252'
|
||||
lastEncoding = u'windows-1252'
|
||||
|
||||
def __init__(self, manager, **kwargs):
|
||||
"""
|
||||
|
@ -57,23 +59,23 @@ class OpenLP1SongImport(SongImport):
|
|||
The database providing the data to import.
|
||||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
self.available_themes = \
|
||||
self.availableThemes = \
|
||||
kwargs[u'plugin'].formparent.themeManagerContents.getThemes()
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Run the import for an openlp.org 1.x song database.
|
||||
"""
|
||||
if not self.import_source.endswith(u'.olp'):
|
||||
self.log_error(self.import_source,
|
||||
if not self.importSource.endswith(u'.olp'):
|
||||
self.logError(self.importSource,
|
||||
translate('SongsPlugin.OpenLP1SongImport',
|
||||
'Not a valid openlp.org 1.x song database.'))
|
||||
return
|
||||
encoding = self.get_encoding()
|
||||
encoding = self.getEncoding()
|
||||
if not encoding:
|
||||
return
|
||||
# Connect to the database.
|
||||
connection = sqlite.connect(self.import_source, mode=0444,
|
||||
connection = sqlite.connect(self.importSource, mode=0444,
|
||||
encoding=(encoding, 'replace'))
|
||||
cursor = connection.cursor()
|
||||
# Determine if we're using a new or an old DB.
|
||||
|
@ -94,64 +96,66 @@ class OpenLP1SongImport(SongImport):
|
|||
cursor.execute(u'SELECT settingsid, settingsname FROM settings')
|
||||
themes = {}
|
||||
for theme_id, theme_name in cursor.fetchall():
|
||||
if theme_name in self.available_themes:
|
||||
if theme_name in self.availableThemes:
|
||||
themes[theme_id] = theme_name
|
||||
# Import the songs.
|
||||
cursor.execute(u'-- types int, unicode, unicode, unicode, int')
|
||||
cursor.execute(u'SELECT songid, songtitle, lyrics || \'\' AS lyrics, '
|
||||
u'copyrightinfo, settingsid FROM songs')
|
||||
songs = cursor.fetchall()
|
||||
self.import_wizard.progressBar.setMaximum(len(songs))
|
||||
self.importWizard.progressBar.setMaximum(len(songs))
|
||||
for song in songs:
|
||||
self.set_defaults()
|
||||
if self.stop_import_flag:
|
||||
self.setDefaults()
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
song_id = song[0]
|
||||
self.title = song[1]
|
||||
lyrics = song[2].replace(u'\r\n', u'\n')
|
||||
self.add_copyright(song[3])
|
||||
self.addCopyright(song[3])
|
||||
if themes.has_key(song[4]):
|
||||
self.theme_name = themes[song[4]]
|
||||
self.themeName = themes[song[4]]
|
||||
verses = lyrics.split(u'\n\n')
|
||||
for verse in verses:
|
||||
if verse.strip():
|
||||
self.add_verse(verse.strip())
|
||||
self.addVerse(verse.strip())
|
||||
cursor.execute(u'-- types int')
|
||||
cursor.execute(u'SELECT authorid FROM songauthors '
|
||||
u'WHERE songid = %s' % song_id)
|
||||
author_ids = cursor.fetchall()
|
||||
for author_id in author_ids:
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
for author in authors:
|
||||
if author[0] == author_id[0]:
|
||||
self.parse_author(author[1])
|
||||
self.parseAuthor(author[1])
|
||||
break
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
if new_db:
|
||||
cursor.execute(u'-- types int')
|
||||
cursor.execute(u'SELECT trackid FROM songtracks '
|
||||
cursor.execute(u'-- types int, int')
|
||||
cursor.execute(u'SELECT trackid, listindex '
|
||||
u'FROM songtracks '
|
||||
u'WHERE songid = %s ORDER BY listindex' % song_id)
|
||||
track_ids = cursor.fetchall()
|
||||
for track_id in track_ids:
|
||||
if self.stop_import_flag:
|
||||
for track_id, listindex in track_ids:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
for track in tracks:
|
||||
if track[0] == track_id[0]:
|
||||
self.add_media_file(track[1])
|
||||
if track[0] == track_id:
|
||||
media_file = self.expandMediaFile(track[1])
|
||||
self.addMediaFile(media_file, listindex)
|
||||
break
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
if not self.finish():
|
||||
self.log_error(self.import_source)
|
||||
self.logError(self.importSource)
|
||||
|
||||
def get_encoding(self):
|
||||
def getEncoding(self):
|
||||
"""
|
||||
Detect character encoding of an openlp.org 1.x song database.
|
||||
"""
|
||||
# Connect to the database.
|
||||
connection = sqlite.connect(self.import_source, mode=0444)
|
||||
connection = sqlite.connect(self.importSource, mode=0444)
|
||||
cursor = connection.cursor()
|
||||
|
||||
detector = UniversalDetector()
|
||||
|
@ -186,3 +190,22 @@ class OpenLP1SongImport(SongImport):
|
|||
return detector.result[u'encoding']
|
||||
detector.close()
|
||||
return retrieve_windows_encoding(detector.result[u'encoding'])
|
||||
|
||||
def expandMediaFile(self, filename):
|
||||
"""
|
||||
When you're on Windows, this function expands the file name to include
|
||||
the path to OpenLP's application data directory. If you are not on
|
||||
Windows, it returns the original file name.
|
||||
|
||||
``filename``
|
||||
The filename to expand.
|
||||
"""
|
||||
if sys.platform != u'win32' and \
|
||||
not os.environ.get(u'ALLUSERSPROFILE') and \
|
||||
not os.environ.get(u'APPDATA'):
|
||||
return filename
|
||||
common_app_data = os.path.join(os.environ[u'ALLUSERSPROFILE'],
|
||||
os.path.split(os.environ[u'APPDATA'])[1])
|
||||
if not common_app_data:
|
||||
return filename
|
||||
return os.path.join(common_app_data, u'openlp.org', 'Audio', filename)
|
||||
|
|
|
@ -95,22 +95,22 @@ class OpenLPSongImport(SongImport):
|
|||
The database providing the data to import.
|
||||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
self.source_session = None
|
||||
self.sourceSession = None
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Run the import for an OpenLP version 2 song database.
|
||||
"""
|
||||
if not self.import_source.endswith(u'.sqlite'):
|
||||
self.log_error(self.import_source,
|
||||
if not self.importSource.endswith(u'.sqlite'):
|
||||
self.logError(self.importSource,
|
||||
translate('SongsPlugin.OpenLPSongImport',
|
||||
'Not a valid OpenLP 2.0 song database.'))
|
||||
return
|
||||
self.import_source = u'sqlite:///%s' % self.import_source
|
||||
engine = create_engine(self.import_source)
|
||||
self.importSource = u'sqlite:///%s' % self.importSource
|
||||
engine = create_engine(self.importSource)
|
||||
source_meta = MetaData()
|
||||
source_meta.reflect(engine)
|
||||
self.source_session = scoped_session(sessionmaker(bind=engine))
|
||||
self.sourceSession = scoped_session(sessionmaker(bind=engine))
|
||||
if u'media_files' in source_meta.tables.keys():
|
||||
has_media_files = True
|
||||
else:
|
||||
|
@ -156,9 +156,9 @@ class OpenLPSongImport(SongImport):
|
|||
except UnmappedClassError:
|
||||
mapper(OldTopic, source_topics_table)
|
||||
|
||||
source_songs = self.source_session.query(OldSong).all()
|
||||
if self.import_wizard:
|
||||
self.import_wizard.progressBar.setMaximum(len(source_songs))
|
||||
source_songs = self.sourceSession.query(OldSong).all()
|
||||
if self.importWizard:
|
||||
self.importWizard.progressBar.setMaximum(len(source_songs))
|
||||
for song in source_songs:
|
||||
new_song = Song()
|
||||
new_song.title = song.title
|
||||
|
@ -201,22 +201,22 @@ class OpenLPSongImport(SongImport):
|
|||
if existing_topic is None:
|
||||
existing_topic = Topic.populate(name=topic.name)
|
||||
new_song.topics.append(existing_topic)
|
||||
# if has_media_files:
|
||||
# if song.media_files:
|
||||
# for media_file in song.media_files:
|
||||
# existing_media_file = \
|
||||
# self.manager.get_object_filtered(MediaFile,
|
||||
# MediaFile.file_name == media_file.file_name)
|
||||
# if existing_media_file:
|
||||
# new_song.media_files.append(existing_media_file)
|
||||
# else:
|
||||
# new_song.media_files.append(MediaFile.populate(
|
||||
# file_name=media_file.file_name))
|
||||
if has_media_files:
|
||||
if song.media_files:
|
||||
for media_file in song.media_files:
|
||||
existing_media_file = \
|
||||
self.manager.get_object_filtered(MediaFile,
|
||||
MediaFile.file_name == media_file.file_name)
|
||||
if existing_media_file:
|
||||
new_song.media_files.append(existing_media_file)
|
||||
else:
|
||||
new_song.media_files.append(MediaFile.populate(
|
||||
file_name=media_file.file_name))
|
||||
clean_song(self.manager, new_song)
|
||||
self.manager.save_object(new_song)
|
||||
if self.import_wizard:
|
||||
self.import_wizard.incrementProgressBar(
|
||||
if self.importWizard:
|
||||
self.importWizard.incrementProgressBar(
|
||||
WizardStrings.ImportingType % new_song.title)
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
engine.dispose()
|
||||
|
|
|
@ -59,58 +59,58 @@ class OooImport(SongImport):
|
|||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
self.document = None
|
||||
self.process_started = False
|
||||
self.processStarted = False
|
||||
|
||||
def do_import(self):
|
||||
if not isinstance(self.import_source, list):
|
||||
def doImport(self):
|
||||
if not isinstance(self.importSource, list):
|
||||
return
|
||||
try:
|
||||
self.start_ooo()
|
||||
except NoConnectException as exc:
|
||||
self.log_error(
|
||||
self.import_source[0],
|
||||
self.logError(
|
||||
self.importSource[0],
|
||||
translate('SongsPlugin.SongImport',
|
||||
'Cannot access OpenOffice or LibreOffice'))
|
||||
log.error(exc)
|
||||
return
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
for filename in self.import_source:
|
||||
if self.stop_import_flag:
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
for filename in self.importSource:
|
||||
if self.stopImportFlag:
|
||||
break
|
||||
filename = unicode(filename)
|
||||
if os.path.isfile(filename):
|
||||
self.open_ooo_file(filename)
|
||||
self.openOooFile(filename)
|
||||
if self.document:
|
||||
self.process_ooo_document()
|
||||
self.close_ooo_file()
|
||||
self.processOooDocument()
|
||||
self.closeOooFile()
|
||||
else:
|
||||
self.log_error(self.filepath,
|
||||
self.logError(self.filepath,
|
||||
translate('SongsPlugin.SongImport',
|
||||
'Unable to open file'))
|
||||
else:
|
||||
self.log_error(self.filepath,
|
||||
self.logError(self.filepath,
|
||||
translate('SongsPlugin.SongImport', 'File not found'))
|
||||
self.close_ooo()
|
||||
self.closeOoo()
|
||||
|
||||
def process_ooo_document(self):
|
||||
def processOooDocument(self):
|
||||
"""
|
||||
Handle the import process for OpenOffice files. This method facilitates
|
||||
allowing subclasses to handle specific types of OpenOffice files.
|
||||
"""
|
||||
if self.document.supportsService(
|
||||
"com.sun.star.presentation.PresentationDocument"):
|
||||
self.process_pres()
|
||||
self.processPres()
|
||||
if self.document.supportsService("com.sun.star.text.TextDocument"):
|
||||
self.process_doc()
|
||||
self.processDoc()
|
||||
|
||||
def start_ooo(self):
|
||||
def startOoo(self):
|
||||
"""
|
||||
Start OpenOffice.org process
|
||||
TODO: The presentation/Impress plugin may already have it running
|
||||
"""
|
||||
if os.name == u'nt':
|
||||
self.start_ooo_process()
|
||||
self.desktop = self.ooo_manager.createInstance(
|
||||
self.startOooProcess()
|
||||
self.desktop = self.oooManager.createInstance(
|
||||
u'com.sun.star.frame.Desktop')
|
||||
else:
|
||||
context = uno.getComponentContext()
|
||||
|
@ -123,7 +123,7 @@ class OooImport(SongImport):
|
|||
uno_instance = get_uno_instance(resolver)
|
||||
except NoConnectException:
|
||||
log.exception("Failed to resolve uno connection")
|
||||
self.start_ooo_process()
|
||||
self.startOooProcess()
|
||||
loop += 1
|
||||
else:
|
||||
manager = uno_instance.ServiceManager
|
||||
|
@ -132,22 +132,22 @@ class OooImport(SongImport):
|
|||
return
|
||||
raise
|
||||
|
||||
def start_ooo_process(self):
|
||||
def startOooProcess(self):
|
||||
try:
|
||||
if os.name == u'nt':
|
||||
self.ooo_manager = Dispatch(u'com.sun.star.ServiceManager')
|
||||
self.ooo_manager._FlagAsMethod(u'Bridge_GetStruct')
|
||||
self.ooo_manager._FlagAsMethod(u'Bridge_GetValueObject')
|
||||
self.oooManager = Dispatch(u'com.sun.star.ServiceManager')
|
||||
self.oooManager._FlagAsMethod(u'Bridge_GetStruct')
|
||||
self.oooManager._FlagAsMethod(u'Bridge_GetValueObject')
|
||||
else:
|
||||
cmd = get_uno_command()
|
||||
process = QtCore.QProcess()
|
||||
process.startDetached(cmd)
|
||||
process.waitForStarted()
|
||||
self.process_started = True
|
||||
self.processStarted = True
|
||||
except:
|
||||
log.exception("start_ooo_process failed")
|
||||
|
||||
def open_ooo_file(self, filepath):
|
||||
def openOooFile(self, filepath):
|
||||
"""
|
||||
Open the passed file in OpenOffice.org Impress
|
||||
"""
|
||||
|
@ -166,29 +166,29 @@ class OooImport(SongImport):
|
|||
if not self.document.supportsService(
|
||||
"com.sun.star.presentation.PresentationDocument") and not \
|
||||
self.document.supportsService("com.sun.star.text.TextDocument"):
|
||||
self.close_ooo_file()
|
||||
self.closeOooFile()
|
||||
else:
|
||||
self.import_wizard.incrementProgressBar(
|
||||
self.importWizard.incrementProgressBar(
|
||||
u'Processing file ' + filepath, 0)
|
||||
except AttributeError:
|
||||
log.exception("open_ooo_file failed: %s", url)
|
||||
return
|
||||
|
||||
def close_ooo_file(self):
|
||||
def closeOooFile(self):
|
||||
"""
|
||||
Close file.
|
||||
"""
|
||||
self.document.close(True)
|
||||
self.document = None
|
||||
|
||||
def close_ooo(self):
|
||||
def closeOoo(self):
|
||||
"""
|
||||
Close OOo. But only if we started it and not on windows
|
||||
"""
|
||||
if self.process_started:
|
||||
if self.processStarted:
|
||||
self.desktop.terminate()
|
||||
|
||||
def process_pres(self):
|
||||
def processPres(self):
|
||||
"""
|
||||
Process the file
|
||||
"""
|
||||
|
@ -196,8 +196,8 @@ class OooImport(SongImport):
|
|||
slides = doc.getDrawPages()
|
||||
text = u''
|
||||
for slide_no in range(slides.getCount()):
|
||||
if self.stop_import_flag:
|
||||
self.import_wizard.incrementProgressBar(u'Import cancelled', 0)
|
||||
if self.stopImportFlag:
|
||||
self.importWizard.incrementProgressBar(u'Import cancelled', 0)
|
||||
return
|
||||
slide = slides.getByIndex(slide_no)
|
||||
slidetext = u''
|
||||
|
@ -209,10 +209,10 @@ class OooImport(SongImport):
|
|||
if slidetext.strip() == u'':
|
||||
slidetext = u'\f'
|
||||
text += slidetext
|
||||
self.process_songs_text(text)
|
||||
self.processSongsText(text)
|
||||
return
|
||||
|
||||
def process_doc(self):
|
||||
def processDoc(self):
|
||||
"""
|
||||
Process the doc file, a paragraph at a time
|
||||
"""
|
||||
|
@ -231,16 +231,16 @@ class OooImport(SongImport):
|
|||
if textportion.BreakType in (PAGE_AFTER, PAGE_BOTH):
|
||||
paratext += u'\f'
|
||||
text += paratext + u'\n'
|
||||
self.process_songs_text(text)
|
||||
self.processSongsText(text)
|
||||
|
||||
def process_songs_text(self, text):
|
||||
songtexts = self.tidy_text(text).split(u'\f')
|
||||
self.set_defaults()
|
||||
def processSongsText(self, text):
|
||||
songtexts = self.tidyText(text).split(u'\f')
|
||||
self.setDefaults()
|
||||
for songtext in songtexts:
|
||||
if songtext.strip():
|
||||
self.process_song_text(songtext.strip())
|
||||
if self.check_complete():
|
||||
self.processSongText(songtext.strip())
|
||||
if self.checkComplete():
|
||||
self.finish()
|
||||
self.set_defaults()
|
||||
if self.check_complete():
|
||||
self.setDefaults()
|
||||
if self.checkComplete():
|
||||
self.finish()
|
||||
|
|
|
@ -53,16 +53,16 @@ class OpenLyricsImport(SongImport):
|
|||
SongImport.__init__(self, manager, **kwargs)
|
||||
self.openLyrics = OpenLyrics(self.manager)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Imports the songs.
|
||||
"""
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
parser = etree.XMLParser(remove_blank_text=True)
|
||||
for file_path in self.import_source:
|
||||
if self.stop_import_flag:
|
||||
for file_path in self.importSource:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
self.import_wizard.incrementProgressBar(
|
||||
self.importWizard.incrementProgressBar(
|
||||
WizardStrings.ImportingType % os.path.basename(file_path))
|
||||
try:
|
||||
# Pass a file object, because lxml does not cope with some
|
||||
|
@ -72,4 +72,4 @@ class OpenLyricsImport(SongImport):
|
|||
self.openLyrics.xml_to_song(xml)
|
||||
except etree.XMLSyntaxError:
|
||||
log.exception(u'XML syntax error in file %s' % file_path)
|
||||
self.log_error(file_path, SongStrings.XMLSyntaxError)
|
||||
self.logError(file_path, SongStrings.XMLSyntaxError)
|
||||
|
|
|
@ -107,32 +107,32 @@ class OpenSongImport(SongImport):
|
|||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
|
||||
def do_import(self):
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
for filename in self.import_source:
|
||||
if self.stop_import_flag:
|
||||
def doImport(self):
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
for filename in self.importSource:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
song_file = open(filename)
|
||||
self.do_import_file(song_file)
|
||||
self.doImportFile(song_file)
|
||||
song_file.close()
|
||||
|
||||
def do_import_file(self, file):
|
||||
def doImportFile(self, file):
|
||||
"""
|
||||
Process the OpenSong file - pass in a file-like object, not a file path.
|
||||
"""
|
||||
self.set_defaults()
|
||||
self.setDefaults()
|
||||
try:
|
||||
tree = objectify.parse(file)
|
||||
except (Error, LxmlError):
|
||||
self.log_error(file.name, SongStrings.XMLSyntaxError)
|
||||
self.logError(file.name, SongStrings.XMLSyntaxError)
|
||||
log.exception(u'Error parsing XML')
|
||||
return
|
||||
root = tree.getroot()
|
||||
fields = dir(root)
|
||||
decode = {
|
||||
u'copyright': self.add_copyright,
|
||||
u'copyright': self.addCopyright,
|
||||
u'ccli': u'ccli_number',
|
||||
u'author': self.parse_author,
|
||||
u'author': self.parseAuthor,
|
||||
u'title': u'title',
|
||||
u'aka': u'alternate_title',
|
||||
u'hymn_number': u'song_number'
|
||||
|
@ -190,7 +190,10 @@ class OpenSongImport(SongImport):
|
|||
# the verse tag
|
||||
verse_tag = content
|
||||
verse_num = u'1'
|
||||
verse_index = VerseType.from_loose_input(verse_tag)
|
||||
if len(verse_tag) == 0:
|
||||
verse_index = 0
|
||||
else:
|
||||
verse_index = VerseType.from_loose_input(verse_tag)
|
||||
verse_tag = VerseType.Tags[verse_index]
|
||||
inst = 1
|
||||
if [verse_tag, verse_num, inst] in our_verse_order \
|
||||
|
@ -211,7 +214,7 @@ class OpenSongImport(SongImport):
|
|||
verses[verse_tag][verse_num][inst] = []
|
||||
our_verse_order.append([verse_tag, verse_num, inst])
|
||||
# Tidy text and remove the ____s from extended words
|
||||
this_line = self.tidy_text(this_line)
|
||||
this_line = self.tidyText(this_line)
|
||||
this_line = this_line.replace(u'_', u'')
|
||||
this_line = this_line.replace(u'|', u'\n')
|
||||
verses[verse_tag][verse_num][inst].append(this_line)
|
||||
|
@ -220,9 +223,9 @@ class OpenSongImport(SongImport):
|
|||
for (verse_tag, verse_num, inst) in our_verse_order:
|
||||
verse_def = u'%s%s' % (verse_tag, verse_num)
|
||||
lines = u'\n'.join(verses[verse_tag][verse_num][inst])
|
||||
self.add_verse(lines, verse_def)
|
||||
self.addVerse(lines, verse_def)
|
||||
if not self.verses:
|
||||
self.add_verse('')
|
||||
self.addVerse('')
|
||||
# figure out the presentation order, if present
|
||||
if u'presentation' in fields and root.presentation:
|
||||
order = unicode(root.presentation)
|
||||
|
@ -243,9 +246,9 @@ class OpenSongImport(SongImport):
|
|||
verse_def = u'%s%s' % (verse_tag, verse_num)
|
||||
if verses.has_key(verse_tag) and \
|
||||
verses[verse_tag].has_key(verse_num):
|
||||
self.verse_order_list.append(verse_def)
|
||||
self.verseOrderList.append(verse_def)
|
||||
else:
|
||||
log.info(u'Got order %s but not in verse tags, dropping'
|
||||
u'this item from presentation order', verse_def)
|
||||
if not self.finish():
|
||||
self.log_error(file.name)
|
||||
self.logError(file.name)
|
||||
|
|
|
@ -83,32 +83,32 @@ class SofImport(OooImport):
|
|||
OooImport.__init__(self, manager, **kwargs)
|
||||
self.song = False
|
||||
|
||||
def process_ooo_document(self):
|
||||
def processOooDocument(self):
|
||||
"""
|
||||
Handle the import process for SoF files.
|
||||
"""
|
||||
self.process_sof_file()
|
||||
self.processSofFile()
|
||||
|
||||
def process_sof_file(self):
|
||||
def processSofFile(self):
|
||||
"""
|
||||
Process the RTF file, a paragraph at a time
|
||||
"""
|
||||
self.blanklines = 0
|
||||
self.new_song()
|
||||
self.blankLines = 0
|
||||
self.newSong()
|
||||
try:
|
||||
paragraphs = self.document.getText().createEnumeration()
|
||||
while paragraphs.hasMoreElements():
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
paragraph = paragraphs.nextElement()
|
||||
if paragraph.supportsService("com.sun.star.text.Paragraph"):
|
||||
self.process_paragraph(paragraph)
|
||||
self.processParagraph(paragraph)
|
||||
except RuntimeException as exc:
|
||||
log.exception(u'Error processing file: %s', exc)
|
||||
if not self.finish():
|
||||
self.log_error(self.filepath)
|
||||
self.logError(self.filepath)
|
||||
|
||||
def process_paragraph(self, paragraph):
|
||||
def processParagraph(self, paragraph):
|
||||
"""
|
||||
Process a paragraph.
|
||||
In the first book, a paragraph is a single line. In the latter ones
|
||||
|
@ -124,26 +124,26 @@ class SofImport(OooImport):
|
|||
while textportions.hasMoreElements():
|
||||
textportion = textportions.nextElement()
|
||||
if textportion.BreakType in (PAGE_BEFORE, PAGE_BOTH):
|
||||
self.process_paragraph_text(text)
|
||||
self.new_song()
|
||||
self.processParagraphText(text)
|
||||
self.newSong()
|
||||
text = u''
|
||||
text += self.process_textportion(textportion)
|
||||
if textportion.BreakType in (PAGE_AFTER, PAGE_BOTH):
|
||||
self.process_paragraph_text(text)
|
||||
self.new_song()
|
||||
self.processParagraphText(text)
|
||||
self.newSong()
|
||||
text = u''
|
||||
self.process_paragraph_text(text)
|
||||
self.processParagraphText(text)
|
||||
|
||||
def process_paragraph_text(self, text):
|
||||
def processParagraphText(self, text):
|
||||
"""
|
||||
Split the paragraph text into multiple lines and process
|
||||
"""
|
||||
for line in text.split(u'\n'):
|
||||
self.process_paragraph_line(line)
|
||||
if self.blanklines > 2:
|
||||
self.new_song()
|
||||
self.processParagraphLine(line)
|
||||
if self.blankLines > 2:
|
||||
self.newSong()
|
||||
|
||||
def process_paragraph_line(self, text):
|
||||
def processParagraphLine(self, text):
|
||||
"""
|
||||
Process a single line. Throw away that text which isn't relevant, i.e.
|
||||
stuff that appears at the end of the song.
|
||||
|
@ -151,16 +151,16 @@ class SofImport(OooImport):
|
|||
"""
|
||||
text = text.strip()
|
||||
if text == u'':
|
||||
self.blanklines += 1
|
||||
if self.blanklines > 1:
|
||||
self.blankLines += 1
|
||||
if self.blankLines > 1:
|
||||
return
|
||||
if self.title != u'':
|
||||
self.finish_verse()
|
||||
self.finishVerse()
|
||||
return
|
||||
self.blanklines = 0
|
||||
if self.skip_to_close_bracket:
|
||||
self.blankLines = 0
|
||||
if self.skipToCloseBracket:
|
||||
if text.endswith(u')'):
|
||||
self.skip_to_close_bracket = False
|
||||
self.skipToCloseBracket = False
|
||||
return
|
||||
if text.startswith(u'CCL Licence'):
|
||||
self.italics = False
|
||||
|
@ -169,24 +169,24 @@ class SofImport(OooImport):
|
|||
return
|
||||
if text.startswith(u'(NB.') or text.startswith(u'(Regrettably') \
|
||||
or text.startswith(u'(From'):
|
||||
self.skip_to_close_bracket = True
|
||||
self.skipToCloseBracket = True
|
||||
return
|
||||
if text.startswith(u'Copyright'):
|
||||
self.add_copyright(text)
|
||||
self.addCopyright(text)
|
||||
return
|
||||
if text == u'(Repeat)':
|
||||
self.finish_verse()
|
||||
self.repeat_verse()
|
||||
self.finishVerse()
|
||||
self.repeatVerse()
|
||||
return
|
||||
if self.title == u'':
|
||||
if self.copyright == u'':
|
||||
self.add_sof_author(text)
|
||||
self.addSofAuthor(text)
|
||||
else:
|
||||
self.add_copyright(text)
|
||||
self.addCopyright(text)
|
||||
return
|
||||
self.add_verse_line(text)
|
||||
self.addVerseLine(text)
|
||||
|
||||
def process_textportion(self, textportion):
|
||||
def processTextPortion(self, textportion):
|
||||
"""
|
||||
Process a text portion. Here we just get the text and detect if
|
||||
it's bold or italics. If it's bold then its a song number or song title.
|
||||
|
@ -199,53 +199,53 @@ class SofImport(OooImport):
|
|||
return text
|
||||
if textportion.CharWeight == BOLD:
|
||||
boldtext = text.strip()
|
||||
if boldtext.isdigit() and self.song_number == '':
|
||||
self.add_songnumber(boldtext)
|
||||
if boldtext.isdigit() and self.songNumber == '':
|
||||
self.addSongNumber(boldtext)
|
||||
return u''
|
||||
if self.title == u'':
|
||||
text = self.uncap_text(text)
|
||||
self.add_title(text)
|
||||
self.addTitle(text)
|
||||
return text
|
||||
if text.strip().startswith(u'('):
|
||||
return text
|
||||
self.italics = (textportion.CharPosture == ITALIC)
|
||||
return text
|
||||
|
||||
def new_song(self):
|
||||
def newSong(self):
|
||||
"""
|
||||
A change of song. Store the old, create a new
|
||||
... but only if the last song was complete. If not, stick with it
|
||||
"""
|
||||
if self.song:
|
||||
self.finish_verse()
|
||||
if not self.check_complete():
|
||||
self.finishVerse()
|
||||
if not self.checkComplete():
|
||||
return
|
||||
self.finish()
|
||||
self.song = True
|
||||
self.set_defaults()
|
||||
self.skip_to_close_bracket = False
|
||||
self.is_chorus = False
|
||||
self.setDefaults()
|
||||
self.skipToCloseBracket = False
|
||||
self.isChorus = False
|
||||
self.italics = False
|
||||
self.currentverse = u''
|
||||
self.currentVerse = u''
|
||||
|
||||
def add_songnumber(self, song_no):
|
||||
def addSongNumber(self, song_no):
|
||||
"""
|
||||
Add a song number, store as alternate title. Also use the song
|
||||
number to work out which songbook we're in
|
||||
"""
|
||||
self.song_number = song_no
|
||||
self.alternate_title = song_no + u'.'
|
||||
self.song_book_pub = u'Kingsway Publications'
|
||||
self.songNumber = song_no
|
||||
self.alternateTitle = song_no + u'.'
|
||||
self.songBook_pub = u'Kingsway Publications'
|
||||
if int(song_no) <= 640:
|
||||
self.song_book = u'Songs of Fellowship 1'
|
||||
self.songBook = u'Songs of Fellowship 1'
|
||||
elif int(song_no) <= 1150:
|
||||
self.song_book = u'Songs of Fellowship 2'
|
||||
self.songBook = u'Songs of Fellowship 2'
|
||||
elif int(song_no) <= 1690:
|
||||
self.song_book = u'Songs of Fellowship 3'
|
||||
self.songBook = u'Songs of Fellowship 3'
|
||||
else:
|
||||
self.song_book = u'Songs of Fellowship 4'
|
||||
self.songBook = u'Songs of Fellowship 4'
|
||||
|
||||
def add_title(self, text):
|
||||
def addTitle(self, text):
|
||||
"""
|
||||
Add the title to the song. Strip some leading/trailing punctuation that
|
||||
we don't want in a title
|
||||
|
@ -256,9 +256,9 @@ class SofImport(OooImport):
|
|||
if title.endswith(u','):
|
||||
title = title[:-1]
|
||||
self.title = title
|
||||
self.import_wizard.incrementProgressBar(u'Processing song ' + title, 0)
|
||||
self.importWizard.incrementProgressBar(u'Processing song ' + title, 0)
|
||||
|
||||
def add_sof_author(self, text):
|
||||
def addSofAuthor(self, text):
|
||||
"""
|
||||
Add the author. OpenLP stores them individually so split by 'and', '&'
|
||||
and comma.
|
||||
|
@ -266,42 +266,42 @@ class SofImport(OooImport):
|
|||
"Mr Smith" and "Mrs Smith".
|
||||
"""
|
||||
text = text.replace(u' and ', u' & ')
|
||||
self.parse_author(text)
|
||||
self.parseAuthor(text)
|
||||
|
||||
def add_verse_line(self, text):
|
||||
def addVerseLine(self, text):
|
||||
"""
|
||||
Add a line to the current verse. If the formatting has changed and
|
||||
we're beyond the second line of first verse, then this indicates
|
||||
a change of verse. Italics are a chorus
|
||||
"""
|
||||
if self.italics != self.is_chorus and ((len(self.verses) > 0) or
|
||||
(self.currentverse.count(u'\n') > 1)):
|
||||
self.finish_verse()
|
||||
if self.italics != self.isChorus and ((len(self.verses) > 0) or
|
||||
(self.currentVerse.count(u'\n') > 1)):
|
||||
self.finishVerse()
|
||||
if self.italics:
|
||||
self.is_chorus = True
|
||||
self.currentverse += text + u'\n'
|
||||
self.isChorus = True
|
||||
self.currentVerse += text + u'\n'
|
||||
|
||||
def finish_verse(self):
|
||||
def finishVerse(self):
|
||||
"""
|
||||
Verse is finished, store it. Note in book 1+2, some songs are formatted
|
||||
incorrectly. Here we try and split songs with missing line breaks into
|
||||
the correct number of verses.
|
||||
"""
|
||||
if self.currentverse.strip() == u'':
|
||||
if self.currentVerse.strip() == u'':
|
||||
return
|
||||
if self.is_chorus:
|
||||
if self.isChorus:
|
||||
versetag = u'C'
|
||||
splitat = None
|
||||
else:
|
||||
versetag = u'V'
|
||||
splitat = self.verse_splits(self.song_number)
|
||||
splitat = self.verseSplits(self.songNumber)
|
||||
if splitat:
|
||||
ln = 0
|
||||
verse = u''
|
||||
for line in self.currentverse.split(u'\n'):
|
||||
for line in self.currentVerse.split(u'\n'):
|
||||
ln += 1
|
||||
if line == u'' or ln > splitat:
|
||||
self.add_sof_verse(verse, versetag)
|
||||
self.addSofVerse(verse, versetag)
|
||||
ln = 0
|
||||
if line:
|
||||
verse = line + u'\n'
|
||||
|
@ -310,19 +310,19 @@ class SofImport(OooImport):
|
|||
else:
|
||||
verse += line + u'\n'
|
||||
if verse:
|
||||
self.add_sof_verse(verse, versetag)
|
||||
self.addSofVerse(verse, versetag)
|
||||
else:
|
||||
self.add_sof_verse(self.currentverse, versetag)
|
||||
self.currentverse = u''
|
||||
self.is_chorus = False
|
||||
self.addSofVerse(self.currentVerse, versetag)
|
||||
self.currentVerse = u''
|
||||
self.isChorus = False
|
||||
|
||||
def add_sof_verse(self, lyrics, tag):
|
||||
self.add_verse(lyrics, tag)
|
||||
if not self.is_chorus and u'C1' in self.verse_order_list_generated:
|
||||
self.verse_order_list_generated.append(u'C1')
|
||||
self.verse_order_list_generated_useful = True
|
||||
def addSofVerse(self, lyrics, tag):
|
||||
self.addVerse(lyrics, tag)
|
||||
if not self.isChorus and u'C1' in self.verseOrderListGenerated:
|
||||
self.verseOrderListGenerated.append(u'C1')
|
||||
self.verseOrderListGenerated_useful = True
|
||||
|
||||
def uncap_text(self, text):
|
||||
def uncapText(self, text):
|
||||
"""
|
||||
Words in the title are in all capitals, so we lowercase them.
|
||||
However some of these words, e.g. referring to God need a leading
|
||||
|
@ -348,7 +348,7 @@ class SofImport(OooImport):
|
|||
text = u''.join(textarr)
|
||||
return text
|
||||
|
||||
def verse_splits(self, song_number):
|
||||
def verseSplits(self, song_number):
|
||||
"""
|
||||
Because someone at Kingsway forgot to check the 1+2 RTF file,
|
||||
some verses were not formatted correctly.
|
||||
|
|
|
@ -91,27 +91,27 @@ class SongBeamerImport(SongImport):
|
|||
(re.compile(u'<align.*?>'), u''),
|
||||
(re.compile(u'<valign.*?>'), u'')
|
||||
]
|
||||
|
||||
|
||||
def __init__(self, manager, **kwargs):
|
||||
"""
|
||||
Initialise the Song Beamer importer.
|
||||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Receive a single file or a list of files to import.
|
||||
"""
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
if not isinstance(self.import_source, list):
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
if not isinstance(self.importSource, list):
|
||||
return
|
||||
for file in self.import_source:
|
||||
for file in self.importSource:
|
||||
# TODO: check that it is a valid SongBeamer file
|
||||
if self.stop_import_flag:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
self.set_defaults()
|
||||
self.current_verse = u''
|
||||
self.current_verse_type = VerseType.Tags[VerseType.Verse]
|
||||
self.setDefaults()
|
||||
self.currentVerse = u''
|
||||
self.currentVerseType = VerseType.Tags[VerseType.Verse]
|
||||
read_verses = False
|
||||
file_name = os.path.split(file)[1]
|
||||
if os.path.isfile(file):
|
||||
|
@ -119,48 +119,48 @@ class SongBeamerImport(SongImport):
|
|||
details = chardet.detect(detect_file.read())
|
||||
detect_file.close()
|
||||
infile = codecs.open(file, u'r', details['encoding'])
|
||||
songData = infile.readlines()
|
||||
song_data = infile.readlines()
|
||||
infile.close()
|
||||
else:
|
||||
continue
|
||||
self.title = file_name.split('.sng')[0]
|
||||
read_verses = False
|
||||
for line in songData:
|
||||
for line in song_data:
|
||||
# Just make sure that the line is of the type 'Unicode'.
|
||||
line = unicode(line).strip()
|
||||
if line.startswith(u'#') and not read_verses:
|
||||
self.parse_tags(line)
|
||||
self.parseTags(line)
|
||||
elif line.startswith(u'---'):
|
||||
if self.current_verse:
|
||||
self.replace_html_tags()
|
||||
self.add_verse(self.current_verse,
|
||||
self.current_verse_type)
|
||||
self.current_verse = u''
|
||||
self.current_verse_type = VerseType.Tags[VerseType.Verse]
|
||||
if self.currentVerse:
|
||||
self.replaceHtmlTags()
|
||||
self.addVerse(self.currentVerse,
|
||||
self.currentVerseType)
|
||||
self.currentVerse = u''
|
||||
self.currentVerseType = VerseType.Tags[VerseType.Verse]
|
||||
read_verses = True
|
||||
verse_start = True
|
||||
elif read_verses:
|
||||
if verse_start:
|
||||
verse_start = False
|
||||
if not self.check_verse_marks(line):
|
||||
self.current_verse = line + u'\n'
|
||||
if not self.checkVerseMarks(line):
|
||||
self.currentVerse = line + u'\n'
|
||||
else:
|
||||
self.current_verse += line + u'\n'
|
||||
if self.current_verse:
|
||||
self.replace_html_tags()
|
||||
self.add_verse(self.current_verse, self.current_verse_type)
|
||||
self.currentVerse += line + u'\n'
|
||||
if self.currentVerse:
|
||||
self.replaceHtmlTags()
|
||||
self.addVerse(self.currentVerse, self.currentVerseType)
|
||||
if not self.finish():
|
||||
self.log_error(file)
|
||||
self.logError(file)
|
||||
|
||||
def replace_html_tags(self):
|
||||
def replaceHtmlTags(self):
|
||||
"""
|
||||
This can be called to replace SongBeamer's specific (html) tags with
|
||||
OpenLP's specific (html) tags.
|
||||
"""
|
||||
for pair in SongBeamerImport.HTML_TAG_PAIRS:
|
||||
self.current_verse = pair[0].sub(pair[1], self.current_verse)
|
||||
self.currentVerse = pair[0].sub(pair[1], self.currentVerse)
|
||||
|
||||
def parse_tags(self, line):
|
||||
def parseTags(self, line):
|
||||
"""
|
||||
Parses a meta data line.
|
||||
|
||||
|
@ -176,11 +176,11 @@ class SongBeamerImport(SongImport):
|
|||
if not tag_val[0] or not tag_val[1]:
|
||||
return
|
||||
if tag_val[0] == u'#(c)':
|
||||
self.add_copyright(tag_val[1])
|
||||
self.addCopyright(tag_val[1])
|
||||
elif tag_val[0] == u'#AddCopyrightInfo':
|
||||
pass
|
||||
elif tag_val[0] == u'#Author':
|
||||
self.parse_author(tag_val[1])
|
||||
self.parseAuthor(tag_val[1])
|
||||
elif tag_val[0] == u'#BackgroundImage':
|
||||
pass
|
||||
elif tag_val[0] == u'#Bible':
|
||||
|
@ -188,7 +188,7 @@ class SongBeamerImport(SongImport):
|
|||
elif tag_val[0] == u'#Categories':
|
||||
self.topics = tag_val[1].split(',')
|
||||
elif tag_val[0] == u'#CCLI':
|
||||
self.ccli_number = tag_val[1]
|
||||
self.ccliNumber = tag_val[1]
|
||||
elif tag_val[0] == u'#Chords':
|
||||
pass
|
||||
elif tag_val[0] == u'#ChurchSongID':
|
||||
|
@ -220,7 +220,7 @@ class SongBeamerImport(SongImport):
|
|||
elif tag_val[0] == u'#LangCount':
|
||||
pass
|
||||
elif tag_val[0] == u'#Melody':
|
||||
self.parse_author(tag_val[1])
|
||||
self.parseAuthor(tag_val[1])
|
||||
elif tag_val[0] == u'#NatCopyright':
|
||||
pass
|
||||
elif tag_val[0] == u'#OTitle':
|
||||
|
@ -235,10 +235,10 @@ class SongBeamerImport(SongImport):
|
|||
song_book_pub = tag_val[1]
|
||||
elif tag_val[0] == u'#Songbook' or tag_val[0] == u'#SongBook':
|
||||
book_data = tag_val[1].split(u'/')
|
||||
self.song_book_name = book_data[0].strip()
|
||||
self.songBookName = book_data[0].strip()
|
||||
if len(book_data) == 2:
|
||||
number = book_data[1].strip()
|
||||
self.song_number = number if number.isdigit() else u''
|
||||
self.songNumber = number if number.isdigit() else u''
|
||||
elif tag_val[0] == u'#Speed':
|
||||
pass
|
||||
elif tag_val[0] == u'Tempo':
|
||||
|
@ -269,7 +269,7 @@ class SongBeamerImport(SongImport):
|
|||
# TODO: add the verse order.
|
||||
pass
|
||||
|
||||
def check_verse_marks(self, line):
|
||||
def checkVerseMarks(self, line):
|
||||
"""
|
||||
Check and add the verse's MarkType. Returns ``True`` if the given line
|
||||
contains a correct verse mark otherwise ``False``.
|
||||
|
@ -279,10 +279,10 @@ class SongBeamerImport(SongImport):
|
|||
"""
|
||||
marks = line.split(u' ')
|
||||
if len(marks) <= 2 and marks[0] in SongBeamerTypes.MarkTypes:
|
||||
self.current_verse_type = SongBeamerTypes.MarkTypes[marks[0]]
|
||||
self.currentVerseType = SongBeamerTypes.MarkTypes[marks[0]]
|
||||
if len(marks) == 2:
|
||||
# If we have a digit, we append it to current_verse_type.
|
||||
if marks[1].isdigit():
|
||||
self.current_verse_type += marks[1]
|
||||
self.currentVerseType += marks[1]
|
||||
return True
|
||||
return False
|
||||
|
|
|
@ -26,11 +26,14 @@
|
|||
###############################################################################
|
||||
import logging
|
||||
import re
|
||||
import shutil
|
||||
import os
|
||||
|
||||
from PyQt4 import QtCore
|
||||
|
||||
from openlp.core.lib import Receiver, translate
|
||||
from openlp.core.ui.wizard import WizardStrings
|
||||
from openlp.core.utils import AppLocation
|
||||
from openlp.plugins.songs.lib import clean_song, VerseType
|
||||
from openlp.plugins.songs.lib.db import Song, Author, Topic, Book, MediaFile
|
||||
from openlp.plugins.songs.lib.ui import SongStrings
|
||||
|
@ -58,51 +61,51 @@ class SongImport(QtCore.QObject):
|
|||
self.manager = manager
|
||||
QtCore.QObject.__init__(self)
|
||||
if kwargs.has_key(u'filename'):
|
||||
self.import_source = kwargs[u'filename']
|
||||
self.importSource = kwargs[u'filename']
|
||||
elif kwargs.has_key(u'filenames'):
|
||||
self.import_source = kwargs[u'filenames']
|
||||
self.importSource = kwargs[u'filenames']
|
||||
else:
|
||||
raise KeyError(u'Keyword arguments "filename[s]" not supplied.')
|
||||
log.debug(self.import_source)
|
||||
self.import_wizard = None
|
||||
log.debug(self.importSource)
|
||||
self.importWizard = None
|
||||
self.song = None
|
||||
self.stop_import_flag = False
|
||||
self.set_defaults()
|
||||
self.error_log = []
|
||||
self.stopImportFlag = False
|
||||
self.setDefaults()
|
||||
self.errorLog = []
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'openlp_stop_wizard'), self.stop_import)
|
||||
QtCore.SIGNAL(u'openlp_stop_wizard'), self.stopImport)
|
||||
|
||||
def set_defaults(self):
|
||||
def setDefaults(self):
|
||||
"""
|
||||
Create defaults for properties - call this before each song
|
||||
if importing many songs at once to ensure a clean beginning
|
||||
"""
|
||||
self.title = u''
|
||||
self.song_number = u''
|
||||
self.alternate_title = u''
|
||||
self.songNumber = u''
|
||||
self.alternateTitle = u''
|
||||
self.copyright = u''
|
||||
self.comments = u''
|
||||
self.theme_name = u''
|
||||
self.ccli_number = u''
|
||||
self.themeName = u''
|
||||
self.ccliNumber = u''
|
||||
self.authors = []
|
||||
self.topics = []
|
||||
self.media_files = []
|
||||
self.song_book_name = u''
|
||||
self.song_book_pub = u''
|
||||
self.verse_order_list_generated_useful = False
|
||||
self.verse_order_list_generated = []
|
||||
self.verse_order_list = []
|
||||
self.mediaFiles = []
|
||||
self.songBookName = u''
|
||||
self.songBookPub = u''
|
||||
self.verseOrderListGeneratedUseful = False
|
||||
self.verseOrderListGenerated = []
|
||||
self.verseOrderList = []
|
||||
self.verses = []
|
||||
self.verse_counts = {}
|
||||
self.copyright_string = unicode(translate(
|
||||
self.verseCounts = {}
|
||||
self.copyrightString = unicode(translate(
|
||||
'SongsPlugin.SongImport', 'copyright'))
|
||||
|
||||
def log_error(self, filepath, reason=SongStrings.SongIncomplete):
|
||||
def logError(self, filepath, reason=SongStrings.SongIncomplete):
|
||||
"""
|
||||
This should be called, when a song could not be imported.
|
||||
|
||||
``filepath``
|
||||
This should be the file path if ``self.import_source`` is a list
|
||||
This should be the file path if ``self.importSource`` is a list
|
||||
with different files. If it is not a list, but a single file (for
|
||||
instance a database), then this should be the song's title.
|
||||
|
||||
|
@ -110,30 +113,30 @@ class SongImport(QtCore.QObject):
|
|||
The reason, why the import failed. The string should be as
|
||||
informative as possible.
|
||||
"""
|
||||
self.set_defaults()
|
||||
if self.import_wizard is None:
|
||||
self.setDefaults()
|
||||
if self.importWizard is None:
|
||||
return
|
||||
if self.import_wizard.errorReportTextEdit.isHidden():
|
||||
self.import_wizard.errorReportTextEdit.setText(
|
||||
if self.importWizard.errorReportTextEdit.isHidden():
|
||||
self.importWizard.errorReportTextEdit.setText(
|
||||
translate('SongsPlugin.SongImport',
|
||||
'The following songs could not be imported:'))
|
||||
self.import_wizard.errorReportTextEdit.setVisible(True)
|
||||
self.import_wizard.errorCopyToButton.setVisible(True)
|
||||
self.import_wizard.errorSaveToButton.setVisible(True)
|
||||
self.import_wizard.errorReportTextEdit.append(
|
||||
self.importWizard.errorReportTextEdit.setVisible(True)
|
||||
self.importWizard.errorCopyToButton.setVisible(True)
|
||||
self.importWizard.errorSaveToButton.setVisible(True)
|
||||
self.importWizard.errorReportTextEdit.append(
|
||||
u'- %s (%s)' % (filepath, reason))
|
||||
|
||||
def stop_import(self):
|
||||
def stopImport(self):
|
||||
"""
|
||||
Sets the flag for importers to stop their import
|
||||
"""
|
||||
log.debug(u'Stopping songs import')
|
||||
self.stop_import_flag = True
|
||||
self.stopImportFlag = True
|
||||
|
||||
def register(self, import_wizard):
|
||||
self.import_wizard = import_wizard
|
||||
self.importWizard = import_wizard
|
||||
|
||||
def tidy_text(self, text):
|
||||
def tidyText(self, text):
|
||||
"""
|
||||
Get rid of some dodgy unicode and formatting characters we're not
|
||||
interested in. Some can be converted to ascii.
|
||||
|
@ -151,34 +154,34 @@ class SongImport(QtCore.QObject):
|
|||
text = re.sub(r' ?(\n{5}|\f)+ ?', u'\f', text)
|
||||
return text
|
||||
|
||||
def process_song_text(self, text):
|
||||
def processSongText(self, text):
|
||||
verse_texts = text.split(u'\n\n')
|
||||
for verse_text in verse_texts:
|
||||
if verse_text.strip() != u'':
|
||||
self.process_verse_text(verse_text.strip())
|
||||
self.processVerseText(verse_text.strip())
|
||||
|
||||
def process_verse_text(self, text):
|
||||
def processVerseText(self, text):
|
||||
lines = text.split(u'\n')
|
||||
if text.lower().find(self.copyright_string) >= 0 \
|
||||
if text.lower().find(self.copyrightString) >= 0 \
|
||||
or text.find(unicode(SongStrings.CopyrightSymbol)) >= 0:
|
||||
copyright_found = False
|
||||
for line in lines:
|
||||
if (copyright_found or
|
||||
line.lower().find(self.copyright_string) >= 0 or
|
||||
line.lower().find(self.copyrightString) >= 0 or
|
||||
line.find(unicode(SongStrings.CopyrightSymbol)) >= 0):
|
||||
copyright_found = True
|
||||
self.add_copyright(line)
|
||||
self.addCopyright(line)
|
||||
else:
|
||||
self.parse_author(line)
|
||||
self.parseAuthor(line)
|
||||
return
|
||||
if len(lines) == 1:
|
||||
self.parse_author(lines[0])
|
||||
self.parseAuthor(lines[0])
|
||||
return
|
||||
if not self.title:
|
||||
self.title = lines[0]
|
||||
self.add_verse(text)
|
||||
self.addVerse(text)
|
||||
|
||||
def add_copyright(self, copyright):
|
||||
def addCopyright(self, copyright):
|
||||
"""
|
||||
Build the copyright field
|
||||
"""
|
||||
|
@ -188,7 +191,7 @@ class SongImport(QtCore.QObject):
|
|||
self.copyright += ' '
|
||||
self.copyright += copyright
|
||||
|
||||
def parse_author(self, text):
|
||||
def parseAuthor(self, text):
|
||||
"""
|
||||
Add the author. OpenLP stores them individually so split by 'and', '&'
|
||||
and comma. However need to check for 'Mr and Mrs Smith' and turn it to
|
||||
|
@ -204,9 +207,9 @@ class SongImport(QtCore.QObject):
|
|||
if author2.endswith(u'.'):
|
||||
author2 = author2[:-1]
|
||||
if author2:
|
||||
self.add_author(author2)
|
||||
self.addAuthor(author2)
|
||||
|
||||
def add_author(self, author):
|
||||
def addAuthor(self, author):
|
||||
"""
|
||||
Add an author to the list
|
||||
"""
|
||||
|
@ -214,15 +217,15 @@ class SongImport(QtCore.QObject):
|
|||
return
|
||||
self.authors.append(author)
|
||||
|
||||
def add_media_file(self, filename):
|
||||
def addMediaFile(self, filename, weight=0):
|
||||
"""
|
||||
Add a media file to the list
|
||||
"""
|
||||
if filename in self.media_files:
|
||||
if filename in map(lambda x: x[0], self.mediaFiles):
|
||||
return
|
||||
self.media_files.append(filename)
|
||||
self.mediaFiles.append((filename, weight))
|
||||
|
||||
def add_verse(self, verse_text, verse_def=u'v', lang=None):
|
||||
def addVerse(self, verse_text, verse_def=u'v', lang=None):
|
||||
"""
|
||||
Add a verse. This is the whole verse, lines split by \\n. It will also
|
||||
attempt to detect duplicates. In this case it will just add to the verse
|
||||
|
@ -241,29 +244,29 @@ class SongImport(QtCore.QObject):
|
|||
"""
|
||||
for (old_verse_def, old_verse, old_lang) in self.verses:
|
||||
if old_verse.strip() == verse_text.strip():
|
||||
self.verse_order_list_generated.append(old_verse_def)
|
||||
self.verse_order_list_generated_useful = True
|
||||
self.verseOrderListGenerated.append(old_verse_def)
|
||||
self.verseOrderListGeneratedUseful = True
|
||||
return
|
||||
if verse_def[0] in self.verse_counts:
|
||||
self.verse_counts[verse_def[0]] += 1
|
||||
if verse_def[0] in self.verseCounts:
|
||||
self.verseCounts[verse_def[0]] += 1
|
||||
else:
|
||||
self.verse_counts[verse_def[0]] = 1
|
||||
self.verseCounts[verse_def[0]] = 1
|
||||
if len(verse_def) == 1:
|
||||
verse_def += unicode(self.verse_counts[verse_def[0]])
|
||||
elif int(verse_def[1:]) > self.verse_counts[verse_def[0]]:
|
||||
self.verse_counts[verse_def[0]] = int(verse_def[1:])
|
||||
verse_def += unicode(self.verseCounts[verse_def[0]])
|
||||
elif int(verse_def[1:]) > self.verseCounts[verse_def[0]]:
|
||||
self.verseCounts[verse_def[0]] = int(verse_def[1:])
|
||||
self.verses.append([verse_def, verse_text.rstrip(), lang])
|
||||
self.verse_order_list_generated.append(verse_def)
|
||||
self.verseOrderListGenerated.append(verse_def)
|
||||
|
||||
def repeat_verse(self):
|
||||
def repeatVerse(self):
|
||||
"""
|
||||
Repeat the previous verse in the verse order
|
||||
"""
|
||||
self.verse_order_list_generated.append(
|
||||
self.verse_order_list_generated[-1])
|
||||
self.verse_order_list_generated_useful = True
|
||||
self.verseOrderListGenerated.append(
|
||||
self.verseOrderListGenerated[-1])
|
||||
self.verseOrderListGeneratedUseful = True
|
||||
|
||||
def check_complete(self):
|
||||
def checkComplete(self):
|
||||
"""
|
||||
Check the mandatory fields are entered (i.e. title and a verse)
|
||||
Author not checked here, if no author then "Author unknown" is
|
||||
|
@ -278,21 +281,21 @@ class SongImport(QtCore.QObject):
|
|||
"""
|
||||
All fields have been set to this song. Write the song to disk.
|
||||
"""
|
||||
if not self.check_complete():
|
||||
self.set_defaults()
|
||||
if not self.checkComplete():
|
||||
self.setDefaults()
|
||||
return False
|
||||
log.info(u'committing song %s to database', self.title)
|
||||
song = Song()
|
||||
song.title = self.title
|
||||
if self.import_wizard is not None:
|
||||
self.import_wizard.incrementProgressBar(
|
||||
if self.importWizard is not None:
|
||||
self.importWizard.incrementProgressBar(
|
||||
WizardStrings.ImportingType % song.title)
|
||||
song.alternate_title = self.alternate_title
|
||||
song.alternate_title = self.alternateTitle
|
||||
# Values will be set when cleaning the song.
|
||||
song.search_title = u''
|
||||
song.search_lyrics = u''
|
||||
song.verse_order = u''
|
||||
song.song_number = self.song_number
|
||||
song.song_number = self.songNumber
|
||||
verses_changed_to_other = {}
|
||||
sxml = SongXML()
|
||||
other_count = 1
|
||||
|
@ -310,18 +313,18 @@ class SongImport(QtCore.QObject):
|
|||
verse_def = new_verse_def
|
||||
sxml.add_verse_to_lyrics(verse_tag, verse_def[1:], verse_text, lang)
|
||||
song.lyrics = unicode(sxml.extract_xml(), u'utf-8')
|
||||
if not len(self.verse_order_list) and \
|
||||
self.verse_order_list_generated_useful:
|
||||
self.verse_order_list = self.verse_order_list_generated
|
||||
for i, current_verse_def in enumerate(self.verse_order_list):
|
||||
if not len(self.verseOrderList) and \
|
||||
self.verseOrderListGeneratedUseful:
|
||||
self.verseOrderList = self.verseOrderListGenerated
|
||||
for i, current_verse_def in enumerate(self.verseOrderList):
|
||||
if verses_changed_to_other.has_key(current_verse_def):
|
||||
self.verse_order_list[i] = \
|
||||
self.verseOrderList[i] = \
|
||||
verses_changed_to_other[current_verse_def]
|
||||
song.verse_order = u' '.join(self.verse_order_list)
|
||||
song.verse_order = u' '.join(self.verseOrderList)
|
||||
song.copyright = self.copyright
|
||||
song.comments = self.comments
|
||||
song.theme_name = self.theme_name
|
||||
song.ccli_number = self.ccli_number
|
||||
song.theme_name = self.themeName
|
||||
song.ccli_number = self.ccliNumber
|
||||
for authortext in self.authors:
|
||||
author = self.manager.get_object_filtered(Author,
|
||||
Author.display_name == authortext)
|
||||
|
@ -330,17 +333,12 @@ class SongImport(QtCore.QObject):
|
|||
last_name=authortext.split(u' ')[-1],
|
||||
first_name=u' '.join(authortext.split(u' ')[:-1]))
|
||||
song.authors.append(author)
|
||||
for filename in self.media_files:
|
||||
media_file = self.manager.get_object_filtered(MediaFile,
|
||||
MediaFile.file_name == filename)
|
||||
if not media_file:
|
||||
song.media_files.append(MediaFile.populate(file_name=filename))
|
||||
if self.song_book_name:
|
||||
if self.songBookName:
|
||||
song_book = self.manager.get_object_filtered(Book,
|
||||
Book.name == self.song_book_name)
|
||||
Book.name == self.songBookName)
|
||||
if song_book is None:
|
||||
song_book = Book.populate(name=self.song_book_name,
|
||||
publisher=self.song_book_pub)
|
||||
song_book = Book.populate(name=self.songBookName,
|
||||
publisher=self.songBookPub)
|
||||
song.book = song_book
|
||||
for topictext in self.topics:
|
||||
if not topictext:
|
||||
|
@ -350,38 +348,42 @@ class SongImport(QtCore.QObject):
|
|||
if topic is None:
|
||||
topic = Topic.populate(name=topictext)
|
||||
song.topics.append(topic)
|
||||
# We need to save the song now, before adding the media files, so that
|
||||
# we know where to save the media files to.
|
||||
clean_song(self.manager, song)
|
||||
self.manager.save_object(song)
|
||||
self.set_defaults()
|
||||
# Now loop through the media files, copy them to the correct location,
|
||||
# and save the song again.
|
||||
for filename, weight in self.mediaFiles:
|
||||
media_file = self.manager.get_object_filtered(MediaFile,
|
||||
MediaFile.file_name == filename)
|
||||
if not media_file:
|
||||
if os.path.dirname(filename):
|
||||
filename = self.copyMediaFile(song.id, filename)
|
||||
song.media_files.append(
|
||||
MediaFile.populate(file_name=filename, weight=weight)
|
||||
)
|
||||
self.manager.save_object(song)
|
||||
self.setDefaults()
|
||||
return True
|
||||
|
||||
def print_song(self):
|
||||
def copyMediaFile(self, song_id, filename):
|
||||
"""
|
||||
For debugging
|
||||
This method copies the media file to the correct location and returns
|
||||
the new file location.
|
||||
|
||||
``filename``
|
||||
The file to copy.
|
||||
"""
|
||||
print u'========================================' \
|
||||
+ u'========================================'
|
||||
print u'TITLE: ' + self.title
|
||||
print u'ALT TITLE: ' + self.alternate_title
|
||||
for (verse_def, verse_text, lang) in self.verses:
|
||||
print u'VERSE ' + verse_def + u': ' + verse_text
|
||||
print u'ORDER: ' + u' '.join(self.verse_order_list)
|
||||
print u'GENERATED ORDER: ' + u' '.join(self.verse_order_list_generated)
|
||||
for author in self.authors:
|
||||
print u'AUTHOR: ' + author
|
||||
if self.copyright:
|
||||
print u'COPYRIGHT: ' + self.copyright
|
||||
if self.song_book_name:
|
||||
print u'BOOK: ' + self.song_book_name
|
||||
if self.song_book_pub:
|
||||
print u'BOOK PUBLISHER: ' + self.song_book_pub
|
||||
if self.song_number:
|
||||
print u'NUMBER: ' + self.song_number
|
||||
for topictext in self.topics:
|
||||
print u'TOPIC: ' + topictext
|
||||
if self.comments:
|
||||
print u'COMMENTS: ' + self.comments
|
||||
if self.theme_name:
|
||||
print u'THEME: ' + self.theme_name
|
||||
if self.ccli_number:
|
||||
print u'CCLI: ' + self.ccli_number
|
||||
if not hasattr(self, u'save_path'):
|
||||
self.save_path = os.path.join(
|
||||
AppLocation.get_section_data_path(
|
||||
self.importWizard.plugin.name),
|
||||
'audio', str(song_id))
|
||||
if not os.path.exists(self.save_path):
|
||||
os.makedirs(self.save_path)
|
||||
if not filename.startswith(self.save_path):
|
||||
oldfile, filename = filename, os.path.join(self.save_path,
|
||||
os.path.split(filename)[1])
|
||||
shutil.copyfile(oldfile, filename)
|
||||
return filename
|
||||
|
|
|
@ -95,118 +95,120 @@ class SongShowPlusImport(SongImport):
|
|||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Receive a single file or a list of files to import.
|
||||
"""
|
||||
if not isinstance(self.import_source, list):
|
||||
if not isinstance(self.importSource, list):
|
||||
return
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
for file in self.import_source:
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
for file in self.importSource:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
self.sspVerseOrderList = []
|
||||
otherCount = 0
|
||||
otherList = {}
|
||||
other_count = 0
|
||||
other_list = {}
|
||||
file_name = os.path.split(file)[1]
|
||||
self.import_wizard.incrementProgressBar(
|
||||
self.importWizard.incrementProgressBar(
|
||||
WizardStrings.ImportingType % file_name, 0)
|
||||
songData = open(file, 'rb')
|
||||
song_data = open(file, 'rb')
|
||||
while True:
|
||||
blockKey, = struct.unpack("I", songData.read(4))
|
||||
block_key, = struct.unpack("I", song_data.read(4))
|
||||
# The file ends with 4 NUL's
|
||||
if blockKey == 0:
|
||||
if block_key == 0:
|
||||
break
|
||||
nextBlockStarts, = struct.unpack("I", songData.read(4))
|
||||
nextBlockStarts += songData.tell()
|
||||
if blockKey in (VERSE, CHORUS, BRIDGE):
|
||||
null, verseNo, = struct.unpack("BB", songData.read(2))
|
||||
elif blockKey == CUSTOM_VERSE:
|
||||
null, verseNameLength, = struct.unpack("BB",
|
||||
songData.read(2))
|
||||
verseName = songData.read(verseNameLength)
|
||||
lengthDescriptorSize, = struct.unpack("B", songData.read(1))
|
||||
log.debug(lengthDescriptorSize)
|
||||
next_block_starts, = struct.unpack("I", song_data.read(4))
|
||||
next_block_starts += song_data.tell()
|
||||
if block_key in (VERSE, CHORUS, BRIDGE):
|
||||
null, verse_no, = struct.unpack("BB", song_data.read(2))
|
||||
elif block_key == CUSTOM_VERSE:
|
||||
null, verse_name_length, = struct.unpack("BB",
|
||||
song_data.read(2))
|
||||
verse_name = song_data.read(verse_name_length)
|
||||
length_descriptor_size, = struct.unpack("B", song_data.read(1))
|
||||
log.debug(length_descriptor_size)
|
||||
# Detect if/how long the length descriptor is
|
||||
if lengthDescriptorSize == 12 or lengthDescriptorSize == 20:
|
||||
lengthDescriptor, = struct.unpack("I", songData.read(4))
|
||||
elif lengthDescriptorSize == 2:
|
||||
lengthDescriptor = 1
|
||||
elif lengthDescriptorSize == 9:
|
||||
lengthDescriptor = 0
|
||||
if length_descriptor_size == 12 or length_descriptor_size == 20:
|
||||
length_descriptor, = struct.unpack("I", song_data.read(4))
|
||||
elif length_descriptor_size == 2:
|
||||
length_descriptor = 1
|
||||
elif length_descriptor_size == 9:
|
||||
length_descriptor = 0
|
||||
else:
|
||||
lengthDescriptor, = struct.unpack("B", songData.read(1))
|
||||
log.debug(lengthDescriptorSize)
|
||||
data = songData.read(lengthDescriptor)
|
||||
if blockKey == TITLE:
|
||||
length_descriptor, = struct.unpack("B", song_data.read(1))
|
||||
log.debug(length_descriptor_size)
|
||||
data = song_data.read(length_descriptor)
|
||||
if block_key == TITLE:
|
||||
self.title = unicode(data, u'cp1252')
|
||||
elif blockKey == AUTHOR:
|
||||
elif block_key == AUTHOR:
|
||||
authors = data.split(" / ")
|
||||
for author in authors:
|
||||
if author.find(",") !=-1:
|
||||
authorParts = author.split(", ")
|
||||
author = authorParts[1] + " " + authorParts[0]
|
||||
self.parse_author(unicode(author, u'cp1252'))
|
||||
elif blockKey == COPYRIGHT:
|
||||
self.add_copyright(unicode(data, u'cp1252'))
|
||||
elif blockKey == CCLI_NO:
|
||||
self.ccli_number = int(data)
|
||||
elif blockKey == VERSE:
|
||||
self.add_verse(unicode(data, u'cp1252'),
|
||||
"%s%s" % (VerseType.Tags[VerseType.Verse], verseNo))
|
||||
elif blockKey == CHORUS:
|
||||
self.add_verse(unicode(data, u'cp1252'),
|
||||
"%s%s" % (VerseType.Tags[VerseType.Chorus], verseNo))
|
||||
elif blockKey == BRIDGE:
|
||||
self.add_verse(unicode(data, u'cp1252'),
|
||||
"%s%s" % (VerseType.Tags[VerseType.Bridge], verseNo))
|
||||
elif blockKey == TOPIC:
|
||||
self.parseAuthor(unicode(author, u'cp1252'))
|
||||
elif block_key == COPYRIGHT:
|
||||
self.addCopyright(unicode(data, u'cp1252'))
|
||||
elif block_key == CCLI_NO:
|
||||
self.ccliNumber = int(data)
|
||||
elif block_key == VERSE:
|
||||
self.addVerse(unicode(data, u'cp1252'),
|
||||
"%s%s" % (VerseType.Tags[VerseType.Verse], verse_no))
|
||||
elif block_key == CHORUS:
|
||||
self.addVerse(unicode(data, u'cp1252'),
|
||||
"%s%s" % (VerseType.Tags[VerseType.Chorus], verse_no))
|
||||
elif block_key == BRIDGE:
|
||||
self.addVerse(unicode(data, u'cp1252'),
|
||||
"%s%s" % (VerseType.Tags[VerseType.Bridge], verse_no))
|
||||
elif block_key == TOPIC:
|
||||
self.topics.append(unicode(data, u'cp1252'))
|
||||
elif blockKey == COMMENTS:
|
||||
elif block_key == COMMENTS:
|
||||
self.comments = unicode(data, u'cp1252')
|
||||
elif blockKey == VERSE_ORDER:
|
||||
verseTag = self.toOpenLPVerseTag(data, True)
|
||||
if verseTag:
|
||||
if not isinstance(verseTag, unicode):
|
||||
verseTag = unicode(verseTag, u'cp1252')
|
||||
self.sspVerseOrderList.append(verseTag)
|
||||
elif blockKey == SONG_BOOK:
|
||||
self.song_book_name = unicode(data, u'cp1252')
|
||||
elif blockKey == SONG_NUMBER:
|
||||
self.song_number = ord(data)
|
||||
elif blockKey == CUSTOM_VERSE:
|
||||
verseTag = self.toOpenLPVerseTag(verseName)
|
||||
self.add_verse(unicode(data, u'cp1252'), verseTag)
|
||||
elif block_key == VERSE_ORDER:
|
||||
verse_tag = self.toOpenLPVerseTag(data, True)
|
||||
if verse_tag:
|
||||
if not isinstance(verse_tag, unicode):
|
||||
verse_tag = unicode(verse_tag, u'cp1252')
|
||||
self.sspVerseOrderList.append(verse_tag)
|
||||
elif block_key == SONG_BOOK:
|
||||
self.songBookName = unicode(data, u'cp1252')
|
||||
elif block_key == SONG_NUMBER:
|
||||
self.songNumber = ord(data)
|
||||
elif block_key == CUSTOM_VERSE:
|
||||
verse_tag = self.toOpenLPVerseTag(verse_name)
|
||||
self.addVerse(unicode(data, u'cp1252'), verse_tag)
|
||||
else:
|
||||
log.debug("Unrecognised blockKey: %s, data: %s"
|
||||
% (blockKey, data))
|
||||
songData.seek(nextBlockStarts)
|
||||
self.verse_order_list = self.sspVerseOrderList
|
||||
songData.close()
|
||||
% (block_key, data))
|
||||
song_data.seek(next_block_starts)
|
||||
self.verseOrderList = self.sspVerseOrderList
|
||||
song_data.close()
|
||||
if not self.finish():
|
||||
self.log_error(file)
|
||||
self.logError(file)
|
||||
|
||||
def toOpenLPVerseTag(self, verseName, ignoreUnique=False):
|
||||
if verseName.find(" ") != -1:
|
||||
verseParts = verseName.split(" ")
|
||||
verseType = verseParts[0]
|
||||
verseNumber = verseParts[1]
|
||||
def toOpenLPVerseTag(self, verse_name, ignore_unique=False):
|
||||
if verse_name.find(" ") != -1:
|
||||
verse_parts = verse_name.split(" ")
|
||||
verse_type = verse_parts[0]
|
||||
verse_number = verse_parts[1]
|
||||
else:
|
||||
verseType = verseName
|
||||
verseNumber = "1"
|
||||
verseType = verseType.lower()
|
||||
if verseType == "verse":
|
||||
verseTag = VerseType.Tags[VerseType.Verse]
|
||||
elif verseType == "chorus":
|
||||
verseTag = VerseType.Tags[VerseType.Chorus]
|
||||
elif verseType == "bridge":
|
||||
verseTag = VerseType.Tags[VerseType.Bridge]
|
||||
elif verseType == "pre-chorus":
|
||||
verseTag = VerseType.Tags[VerseType.PreChorus]
|
||||
verse_type = verse_name
|
||||
verse_number = "1"
|
||||
verse_type = verse_type.lower()
|
||||
if verse_type == "verse":
|
||||
verse_tag = VerseType.Tags[VerseType.Verse]
|
||||
elif verse_type == "chorus":
|
||||
verse_tag = VerseType.Tags[VerseType.Chorus]
|
||||
elif verse_type == "bridge":
|
||||
verse_tag = VerseType.Tags[VerseType.Bridge]
|
||||
elif verse_type == "pre-chorus":
|
||||
verse_tag = VerseType.Tags[VerseType.PreChorus]
|
||||
else:
|
||||
if not self.otherList.has_key(verseName):
|
||||
if ignoreUnique:
|
||||
if not self.otherList.has_key(verse_name):
|
||||
if ignore_unique:
|
||||
return None
|
||||
self.otherCount = self.otherCount + 1
|
||||
self.otherList[verseName] = str(self.otherCount)
|
||||
verseTag = VerseType.Tags[VerseType.Other]
|
||||
verseNumber = self.otherList[verseName]
|
||||
return verseTag + verseNumber
|
||||
self.otherList[verse_name] = str(self.otherCount)
|
||||
verse_tag = VerseType.Tags[VerseType.Other]
|
||||
verse_number = self.otherList[verse_name]
|
||||
return verse_tag + verse_number
|
||||
|
|
|
@ -0,0 +1,88 @@
|
|||
# -*- 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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Miller, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
"""
|
||||
The :mod:`upgrade` module provides a way for the database and schema that is the
|
||||
backend for the Songs plugin
|
||||
"""
|
||||
|
||||
from sqlalchemy import Column, ForeignKey, Table, types
|
||||
from sqlalchemy.sql.expression import func
|
||||
from migrate import changeset
|
||||
from migrate.changeset.constraint import ForeignKeyConstraint
|
||||
|
||||
__version__ = 2
|
||||
|
||||
def upgrade_setup(metadata):
|
||||
"""
|
||||
Set up the latest revision all tables, with reflection, needed for the
|
||||
upgrade process. If you want to drop a table, you need to remove it from
|
||||
here, and add it to your upgrade function.
|
||||
"""
|
||||
tables = {
|
||||
u'authors': Table(u'authors', metadata, autoload=True),
|
||||
u'media_files': Table(u'media_files', metadata, autoload=True),
|
||||
u'song_books': Table(u'song_books', metadata, autoload=True),
|
||||
u'songs': Table(u'songs', metadata, autoload=True),
|
||||
u'topics': Table(u'topics', metadata, autoload=True),
|
||||
u'authors_songs': Table(u'authors_songs', metadata, autoload=True),
|
||||
u'songs_topics': Table(u'songs_topics', metadata, autoload=True)
|
||||
}
|
||||
return tables
|
||||
|
||||
|
||||
def upgrade_1(session, metadata, tables):
|
||||
"""
|
||||
Version 1 upgrade.
|
||||
|
||||
This upgrade removes the many-to-many relationship between songs and
|
||||
media_files and replaces it with a one-to-many, which is far more
|
||||
representative of the real relationship between the two entities.
|
||||
|
||||
In order to facilitate this one-to-many relationship, a song_id column is
|
||||
added to the media_files table, and a weight column so that the media
|
||||
files can be ordered.
|
||||
"""
|
||||
Table(u'media_files_songs', metadata, autoload=True).drop(checkfirst=True)
|
||||
Column(u'song_id', types.Integer(), default=None)\
|
||||
.create(table=tables[u'media_files'], populate_default=True)
|
||||
Column(u'weight', types.Integer(), default=0)\
|
||||
.create(table=tables[u'media_files'], populate_default=True)
|
||||
if metadata.bind.url.get_dialect().name != 'sqlite':
|
||||
# SQLite doesn't support ALTER TABLE ADD CONSTRAINT
|
||||
ForeignKeyConstraint([u'song_id'], [u'songs.id'],
|
||||
table=tables[u'media_files']).create()
|
||||
|
||||
def upgrade_2(session, metadata, tables):
|
||||
"""
|
||||
Version 2 upgrade.
|
||||
|
||||
This upgrade adds a create_date and last_modified date to the songs table
|
||||
"""
|
||||
Column(u'create_date', types.DateTime(), default=func.now())\
|
||||
.create(table=tables[u'songs'], populate_default=True)
|
||||
Column(u'last_modified', types.DateTime(), default=func.now())\
|
||||
.create(table=tables[u'songs'], populate_default=True)
|
|
@ -98,56 +98,58 @@ class WowImport(SongImport):
|
|||
"""
|
||||
SongImport.__init__(self, manager, **kwargs)
|
||||
|
||||
def do_import(self):
|
||||
def doImport(self):
|
||||
"""
|
||||
Receive a single file or a list of files to import.
|
||||
"""
|
||||
if isinstance(self.import_source, list):
|
||||
self.import_wizard.progressBar.setMaximum(len(self.import_source))
|
||||
for file in self.import_source:
|
||||
if isinstance(self.importSource, list):
|
||||
self.importWizard.progressBar.setMaximum(len(self.importSource))
|
||||
for file in self.importSource:
|
||||
if self.stopImportFlag:
|
||||
return
|
||||
file_name = os.path.split(file)[1]
|
||||
# Get the song title
|
||||
self.title = file_name.rpartition(u'.')[0]
|
||||
songData = open(file, 'rb')
|
||||
if songData.read(19) != u'WoW File\nSong Words':
|
||||
self.log_error(file)
|
||||
song_data = open(file, 'rb')
|
||||
if song_data.read(19) != u'WoW File\nSong Words':
|
||||
self.logError(file)
|
||||
continue
|
||||
# Seek to byte which stores number of blocks in the song
|
||||
songData.seek(56)
|
||||
no_of_blocks = ord(songData.read(1))
|
||||
song_data.seek(56)
|
||||
no_of_blocks = ord(song_data.read(1))
|
||||
# Seek to the beging of the first block
|
||||
songData.seek(82)
|
||||
song_data.seek(82)
|
||||
for block in range(no_of_blocks):
|
||||
self.lines_to_read = ord(songData.read(1))
|
||||
self.linesToRead = ord(song_data.read(1))
|
||||
# Skip 3 nulls to the beginnig of the 1st line
|
||||
songData.seek(3, os.SEEK_CUR)
|
||||
song_data.seek(3, os.SEEK_CUR)
|
||||
block_text = u''
|
||||
while self.lines_to_read:
|
||||
self.line_text = unicode(
|
||||
songData.read(ord(songData.read(1))), u'cp1252')
|
||||
songData.seek(1, os.SEEK_CUR)
|
||||
while self.linesToRead:
|
||||
self.lineText = unicode(
|
||||
song_data.read(ord(song_data.read(1))), u'cp1252')
|
||||
song_data.seek(1, os.SEEK_CUR)
|
||||
if block_text:
|
||||
block_text += u'\n'
|
||||
block_text += self.line_text
|
||||
self.lines_to_read -= 1
|
||||
block_type = BLOCK_TYPES[ord(songData.read(1))]
|
||||
block_text += self.lineText
|
||||
self.linesToRead -= 1
|
||||
block_type = BLOCK_TYPES[ord(song_data.read(1))]
|
||||
# Skip 3 nulls at the end of the block
|
||||
songData.seek(3, os.SEEK_CUR)
|
||||
song_data.seek(3, os.SEEK_CUR)
|
||||
# Blocks are seperated by 2 bytes, skip them, but not if
|
||||
# this is the last block!
|
||||
if block + 1 < no_of_blocks:
|
||||
songData.seek(2, os.SEEK_CUR)
|
||||
self.add_verse(block_text, block_type)
|
||||
song_data.seek(2, os.SEEK_CUR)
|
||||
self.addVerse(block_text, block_type)
|
||||
# Now to extract the author
|
||||
author_length = ord(songData.read(1))
|
||||
author_length = ord(song_data.read(1))
|
||||
if author_length:
|
||||
self.parse_author(
|
||||
unicode(songData.read(author_length), u'cp1252'))
|
||||
self.parseAuthor(
|
||||
unicode(song_data.read(author_length), u'cp1252'))
|
||||
# Finally the copyright
|
||||
copyright_length = ord(songData.read(1))
|
||||
copyright_length = ord(song_data.read(1))
|
||||
if copyright_length:
|
||||
self.add_copyright(unicode(
|
||||
songData.read(copyright_length), u'cp1252'))
|
||||
songData.close()
|
||||
self.addCopyright(unicode(
|
||||
song_data.read(copyright_length), u'cp1252'))
|
||||
song_data.close()
|
||||
if not self.finish():
|
||||
self.log_error(file)
|
||||
self.logError(file)
|
||||
|
|
|
@ -343,7 +343,7 @@ class OpenLyrics(object):
|
|||
self._process_topics(properties, song)
|
||||
clean_song(self.manager, song)
|
||||
self.manager.save_object(song)
|
||||
return song.id
|
||||
return song
|
||||
|
||||
def _add_text_to_element(self, tag, parent, text=None, label=None):
|
||||
if label:
|
||||
|
|
|
@ -36,7 +36,8 @@ from openlp.core.lib import Plugin, StringContent, build_icon, translate, \
|
|||
from openlp.core.lib.db import Manager
|
||||
from openlp.core.lib.ui import UiStrings, base_action, icon_action
|
||||
from openlp.core.utils.actions import ActionList
|
||||
from openlp.plugins.songs.lib import clean_song, SongMediaItem, SongsTab
|
||||
from openlp.plugins.songs.lib import clean_song, upgrade, SongMediaItem, \
|
||||
SongsTab
|
||||
from openlp.plugins.songs.lib.db import init_schema, Song
|
||||
from openlp.plugins.songs.lib.importer import SongFormat
|
||||
from openlp.plugins.songs.lib.olpimport import OpenLPSongImport
|
||||
|
@ -58,8 +59,8 @@ class SongsPlugin(Plugin):
|
|||
Create and set up the Songs plugin.
|
||||
"""
|
||||
Plugin.__init__(self, u'songs', plugin_helpers, SongMediaItem, SongsTab)
|
||||
self.manager = Manager(u'songs', init_schema, upgrade_mod=upgrade)
|
||||
self.weight = -10
|
||||
self.manager = Manager(u'songs', init_schema)
|
||||
self.icon_path = u':/plugins/plugin_songs.png'
|
||||
self.icon = build_icon(self.icon_path)
|
||||
|
||||
|
@ -195,7 +196,7 @@ class SongsPlugin(Plugin):
|
|||
def importSongs(self, format, **kwargs):
|
||||
class_ = SongFormat.get_class(format)
|
||||
importer = class_(self.manager, **kwargs)
|
||||
importer.register(self.mediaItem.import_wizard)
|
||||
importer.register(self.mediaItem.importWizard)
|
||||
return importer
|
||||
|
||||
def setPluginTextStrings(self):
|
||||
|
@ -251,7 +252,7 @@ class SongsPlugin(Plugin):
|
|||
progress.setValue(idx)
|
||||
Receiver.send_message(u'openlp_process_events')
|
||||
importer = OpenLPSongImport(self.manager, filename=db)
|
||||
importer.do_import()
|
||||
importer.doImport()
|
||||
progress.setValue(len(song_dbs))
|
||||
self.mediaItem.onSearchTextButtonClick()
|
||||
|
||||
|
|
|
@ -117,9 +117,11 @@ class SongUsageDetailForm(QtGui.QDialog, Ui_SongUsageDetailDialog):
|
|||
try:
|
||||
fileHandle = open(outname, u'w')
|
||||
for instance in usage:
|
||||
record = u'\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"\n' % (
|
||||
instance.usagedate, instance.usagetime, instance.title,
|
||||
instance.copyright, instance.ccl_number, instance.authors)
|
||||
record = u'\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",' \
|
||||
u'\"%s\",\"%s\"\n' % ( instance.usagedate,
|
||||
instance.usagetime, instance.title, instance.copyright,
|
||||
instance.ccl_number, instance.authors,
|
||||
instance.plugin_name, instance.source)
|
||||
fileHandle.write(record.encode(u'utf-8'))
|
||||
Receiver.send_message(u'openlp_information_message', {
|
||||
u'title': translate('SongUsagePlugin.SongUsageDetailForm',
|
||||
|
|
|
@ -56,7 +56,9 @@ def init_schema(url):
|
|||
Column(u'title', types.Unicode(255), nullable=False),
|
||||
Column(u'authors', types.Unicode(255), nullable=False),
|
||||
Column(u'copyright', types.Unicode(255)),
|
||||
Column(u'ccl_number', types.Unicode(65))
|
||||
Column(u'ccl_number', types.Unicode(65)),
|
||||
Column(u'plugin_name', types.Unicode(20)),
|
||||
Column(u'source', types.Unicode(10))
|
||||
)
|
||||
|
||||
mapper(SongUsageItem, songusage_table)
|
||||
|
|
|
@ -0,0 +1,58 @@
|
|||
# -*- 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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Miller, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
"""
|
||||
The :mod:`upgrade` module provides a way for the database and schema that is the
|
||||
backend for the SongsUsage plugin
|
||||
"""
|
||||
|
||||
from sqlalchemy import Column, Table, types
|
||||
from migrate import changeset
|
||||
|
||||
__version__ = 1
|
||||
|
||||
def upgrade_setup(metadata):
|
||||
"""
|
||||
Set up the latest revision all tables, with reflection, needed for the
|
||||
upgrade process. If you want to drop a table, you need to remove it from
|
||||
here, and add it to your upgrade function.
|
||||
"""
|
||||
tables = {
|
||||
u'songusage_data': Table(u'songusage_data', metadata, autoload=True)
|
||||
}
|
||||
return tables
|
||||
|
||||
|
||||
def upgrade_1(session, metadata, tables):
|
||||
"""
|
||||
Version 1 upgrade.
|
||||
|
||||
This upgrade adds two new fields to the songusage database
|
||||
"""
|
||||
Column(u'plugin_name', types.Unicode(20), default=u'') \
|
||||
.create(table=tables[u'songusage_data'], populate_default=True)
|
||||
Column(u'source', types.Unicode(10), default=u'') \
|
||||
.create(table=tables[u'songusage_data'], populate_default=True)
|
|
@ -37,6 +37,7 @@ from openlp.core.lib.ui import base_action, shortcut_action
|
|||
from openlp.core.utils.actions import ActionList
|
||||
from openlp.plugins.songusage.forms import SongUsageDetailForm, \
|
||||
SongUsageDeleteForm
|
||||
from openlp.plugins.songusage.lib import upgrade
|
||||
from openlp.plugins.songusage.lib.db import init_schema, SongUsageItem
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
@ -46,11 +47,11 @@ class SongUsagePlugin(Plugin):
|
|||
|
||||
def __init__(self, plugin_helpers):
|
||||
Plugin.__init__(self, u'songusage', plugin_helpers)
|
||||
self.manager = Manager(u'songusage', init_schema, upgrade_mod=upgrade)
|
||||
self.weight = -4
|
||||
self.icon = build_icon(u':/plugins/plugin_songusage.png')
|
||||
self.activeIcon = build_icon(u':/songusage/song_usage_active.png')
|
||||
self.inactiveIcon = build_icon(u':/songusage/song_usage_inactive.png')
|
||||
self.manager = None
|
||||
self.songUsageActive = False
|
||||
|
||||
def addToolsMenuItem(self, tools_menu):
|
||||
|
@ -121,7 +122,10 @@ class SongUsagePlugin(Plugin):
|
|||
Plugin.initialise(self)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'slidecontroller_live_started'),
|
||||
self.onReceiveSongUsage)
|
||||
self.displaySongUsage)
|
||||
QtCore.QObject.connect(Receiver.get_receiver(),
|
||||
QtCore.SIGNAL(u'print_service_started'),
|
||||
self.printSongUsage)
|
||||
self.songUsageActive = QtCore.QSettings().value(
|
||||
self.settingsSection + u'/active',
|
||||
QtCore.QVariant(False)).toBool()
|
||||
|
@ -134,8 +138,6 @@ class SongUsagePlugin(Plugin):
|
|||
translate('SongUsagePlugin', 'Song Usage'))
|
||||
action_list.add_action(self.songUsageReport,
|
||||
translate('SongUsagePlugin', 'Song Usage'))
|
||||
if self.manager is None:
|
||||
self.manager = Manager(u'songusage', init_schema)
|
||||
self.songUsageDeleteForm = SongUsageDeleteForm(self.manager,
|
||||
self.formparent)
|
||||
self.songUsageDetailForm = SongUsageDetailForm(self, self.formparent)
|
||||
|
@ -194,10 +196,21 @@ class SongUsagePlugin(Plugin):
|
|||
self.songUsageStatus.blockSignals(False)
|
||||
|
||||
|
||||
def onReceiveSongUsage(self, item):
|
||||
def displaySongUsage(self, item):
|
||||
"""
|
||||
Song Usage for live song from SlideController
|
||||
Song Usage for which has been displayed
|
||||
"""
|
||||
self._add_song_usage(unicode(translate('SongUsagePlugin',
|
||||
'display')), item)
|
||||
|
||||
def printSongUsage(self, item):
|
||||
"""
|
||||
Song Usage for which has been printed
|
||||
"""
|
||||
self._add_song_usage(unicode(translate('SongUsagePlugin',
|
||||
'printed')), item)
|
||||
|
||||
def _add_song_usage(self, source, item):
|
||||
audit = item[0].audit
|
||||
if self.songUsageActive and audit:
|
||||
song_usage_item = SongUsageItem()
|
||||
|
@ -207,6 +220,8 @@ class SongUsagePlugin(Plugin):
|
|||
song_usage_item.copyright = audit[2]
|
||||
song_usage_item.ccl_number = audit[3]
|
||||
song_usage_item.authors = u' '.join(audit[1])
|
||||
song_usage_item.plugin_name = item[0].name
|
||||
song_usage_item.source = source
|
||||
self.manager.save_object(song_usage_item)
|
||||
|
||||
def onSongUsageDelete(self):
|
||||
|
|
|
@ -11,7 +11,7 @@ Package: openlp
|
|||
Architecture: all
|
||||
Depends: ${shlibs:Depends}, ${misc:Depends}, ${python:Depends}, python-qt4,
|
||||
python-qt4-phonon, python-sqlalchemy, python-chardet, python-beautifulsoup,
|
||||
python-lxml, python-sqlite, python-enchant
|
||||
python-lxml, python-sqlite, python-enchant, python-mako, python-migrate
|
||||
Conflicts: python-openlp
|
||||
Description: Church lyrics projection application
|
||||
OpenLP is free church presentation software, or lyrics projection software,
|
||||
|
|
|
@ -0,0 +1,95 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<ui version="4.0">
|
||||
<class>MediaFilesDialog</class>
|
||||
<widget class="QDialog" name="MediaFilesDialog">
|
||||
<property name="windowModality">
|
||||
<enum>Qt::ApplicationModal</enum>
|
||||
</property>
|
||||
<property name="geometry">
|
||||
<rect>
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>400</width>
|
||||
<height>300</height>
|
||||
</rect>
|
||||
</property>
|
||||
<property name="windowTitle">
|
||||
<string>Select Media File(s)</string>
|
||||
</property>
|
||||
<property name="modal">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
<layout class="QVBoxLayout" name="filesVerticalLayout">
|
||||
<property name="spacing">
|
||||
<number>8</number>
|
||||
</property>
|
||||
<property name="margin">
|
||||
<number>8</number>
|
||||
</property>
|
||||
<item>
|
||||
<widget class="QLabel" name="selectLabel">
|
||||
<property name="text">
|
||||
<string>Select one or more audio files from the list below, and click OK to import them into this song.</string>
|
||||
</property>
|
||||
<property name="wordWrap">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QListView" name="fileListView">
|
||||
<property name="alternatingRowColors">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QDialogButtonBox" name="buttonBox">
|
||||
<property name="orientation">
|
||||
<enum>Qt::Horizontal</enum>
|
||||
</property>
|
||||
<property name="standardButtons">
|
||||
<set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</widget>
|
||||
<resources>
|
||||
<include location="../images/openlp-2.qrc"/>
|
||||
</resources>
|
||||
<connections>
|
||||
<connection>
|
||||
<sender>buttonBox</sender>
|
||||
<signal>accepted()</signal>
|
||||
<receiver>MediaFilesDialog</receiver>
|
||||
<slot>accept()</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>248</x>
|
||||
<y>254</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>157</x>
|
||||
<y>274</y>
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
<connection>
|
||||
<sender>buttonBox</sender>
|
||||
<signal>rejected()</signal>
|
||||
<receiver>MediaFilesDialog</receiver>
|
||||
<slot>reject()</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>316</x>
|
||||
<y>260</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>286</x>
|
||||
<y>274</y>
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
</connections>
|
||||
</ui>
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
2310
resources/i18n/hu.ts
2310
resources/i18n/hu.ts
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
1051
resources/i18n/ru.ts
1051
resources/i18n/ru.ts
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -46,14 +46,14 @@ VERS = {
|
|||
'sqlalchemy': '0.5',
|
||||
# pyenchant 1.6 required on Windows
|
||||
'enchant': '1.6' if is_win else '1.3'
|
||||
}
|
||||
}
|
||||
|
||||
# pywin32
|
||||
WIN32_MODULES = [
|
||||
'win32com',
|
||||
'win32ui',
|
||||
'pywintypes',
|
||||
]
|
||||
]
|
||||
|
||||
MODULES = [
|
||||
'PyQt4',
|
||||
|
@ -72,13 +72,15 @@ MODULES = [
|
|||
'enchant',
|
||||
'BeautifulSoup',
|
||||
'mako',
|
||||
]
|
||||
'migrate',
|
||||
]
|
||||
|
||||
|
||||
OPTIONAL_MODULES = [
|
||||
('sqlite', ' (SQLite 2 support)'),
|
||||
('MySQLdb', ' (MySQL support)'),
|
||||
('psycopg2', ' (PostgreSQL support)'),
|
||||
('pytest', ' (testing framework)'),
|
||||
]
|
||||
|
||||
w = sys.stdout.write
|
||||
|
|
|
@ -186,25 +186,6 @@ def update_export_at_pootle(source_filename):
|
|||
page = urllib.urlopen(REVIEW_URL)
|
||||
page.close()
|
||||
|
||||
|
||||
def download_file(source_filename, dest_filename):
|
||||
"""
|
||||
Download a file and save it to disk.
|
||||
|
||||
``source_filename``
|
||||
The file to download.
|
||||
|
||||
``dest_filename``
|
||||
The new local file name.
|
||||
"""
|
||||
print_verbose(u'Downloading from: %s' % (SERVER_URL + source_filename))
|
||||
page = urllib.urlopen(SERVER_URL + source_filename)
|
||||
content = page.read().decode('utf8')
|
||||
page.close()
|
||||
file = open(dest_filename, u'w')
|
||||
file.write(content.encode('utf8'))
|
||||
file.close()
|
||||
|
||||
def download_translations():
|
||||
"""
|
||||
This method downloads the translation files from the Pootle server.
|
||||
|
@ -219,7 +200,7 @@ def download_translations():
|
|||
filename = os.path.join(os.path.abspath(u'..'), u'resources', u'i18n',
|
||||
language_file)
|
||||
print_verbose(u'Get Translation File: %s' % filename)
|
||||
download_file(language_file, filename)
|
||||
urllib.urlretrieve(SERVER_URL + language_file, filename)
|
||||
print_quiet(u' Done.')
|
||||
|
||||
def prepare_project():
|
||||
|
@ -304,7 +285,7 @@ def create_translation(language):
|
|||
if not language.endswith(u'.ts'):
|
||||
language += u'.ts'
|
||||
filename = os.path.join(os.path.abspath(u'..'), u'resources', u'i18n', language)
|
||||
download_file(u'en.ts', filename)
|
||||
urllib.urlretrieve(SERVER_URL + u'en.ts', filename)
|
||||
print_quiet(u' ** Please Note **')
|
||||
print_quiet(u' In order to get this file into OpenLP and onto the '
|
||||
u'Pootle translation server you will need to subscribe to the '
|
||||
|
|
|
@ -0,0 +1,45 @@
|
|||
#!/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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Millar, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
|
||||
"""
|
||||
Configuration file for pytest framework.
|
||||
"""
|
||||
|
||||
from openlp.core import main as openlp_main
|
||||
|
||||
|
||||
# Test function argument to make openlp gui instance persistent for all tests.
|
||||
# All test cases have to access the same instance. To allow create multiple
|
||||
# instances it would be necessary use diffrent configuraion and data files.
|
||||
# Created instance will use your OpenLP settings.
|
||||
def pytest_funcarg__openlpapp(request):
|
||||
def setup():
|
||||
return openlp_main(['--testing'])
|
||||
def teardown(app):
|
||||
pass
|
||||
return request.cached_setup(setup=setup, teardown=teardown, scope='session')
|
|
@ -0,0 +1,59 @@
|
|||
#!/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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Miller, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
|
||||
"""
|
||||
This script is used to run set of automated tests of OpenLP. To start tests,
|
||||
simply run this script::
|
||||
|
||||
@:~$ ./run.py
|
||||
|
||||
"""
|
||||
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
TESTS_PATH = os.path.dirname(os.path.abspath(__file__))
|
||||
SRC_PATH = os.path.join(TESTS_PATH, '..')
|
||||
|
||||
PYTEST_OPTIONS = [TESTS_PATH]
|
||||
|
||||
# Extend python PATH with openlp source
|
||||
sys.path.insert(0, SRC_PATH)
|
||||
|
||||
# Python testing framework
|
||||
# http://pytest.org
|
||||
import pytest
|
||||
|
||||
|
||||
def main():
|
||||
print 'pytest options:', PYTEST_OPTIONS
|
||||
pytest.main(PYTEST_OPTIONS)
|
||||
|
||||
|
||||
if __name__ == u'__main__':
|
||||
main()
|
|
@ -0,0 +1,36 @@
|
|||
#!/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, Gerald Britton, Jonathan #
|
||||
# Corwin, Michael Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, #
|
||||
# Armin Köhler, Joshua Millar, Stevan Pettit, Andreas Preikschat, Mattias #
|
||||
# Põldaru, Christian Richter, Philip Ridout, Simon Scudder, Jeffrey Smith, #
|
||||
# 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 #
|
||||
###############################################################################
|
||||
|
||||
from openlp.core import OpenLP
|
||||
from openlp.core.ui.mainwindow import MainWindow
|
||||
|
||||
|
||||
def test_start_app(openlpapp):
|
||||
assert type(openlpapp) == OpenLP
|
||||
assert type(openlpapp.mainWindow) == MainWindow
|
||||
assert unicode(openlpapp.mainWindow.windowTitle()) == u'OpenLP 2.0'
|
Loading…
Reference in New Issue