r1519

documentation/manual/source/dualmonitors.rst

@@ -1,3 +1,5 @@
+.. _dualmonitors:
+
 ==================
 Dual Monitor Setup
 ==================
@@ -32,6 +34,14 @@ projector hooked up to your computer as the second monitor. With the option of
 extending your desktop across the second monitor, or your operating system's 
 equivalent.
 
+**Special Note For Projectors Using USB Connections**
+
+Users have reported experiencing difficulties when using a projector with a USB
+connection, as third party software is often required to properly configure
+dual monitors. If possible, it is best to use a direct output (VGA, DVI, HDMI,
+S-Video) from your machine's video card. If a USB connection is your only option
+please consult the manufacturer's manual for instructions on a proper setup.
+
 Microsoft Windows
 -----------------
 

documentation/manual/source/index.rst

@@ -6,20 +6,36 @@
 Welcome to the OpenLP 2.0 User Manual
 =====================================
 
-Contents:
+Getting Started With OpenLP
+---------------------------
 
 .. toctree::
    :maxdepth: 2
 
    introduction
-   glossary
-   wizard
-   dualmonitors
-   configure
+   installation
+
+Reference Manual
+----------------
+
+.. toctree::
+   :maxdepth: 2
+
+   alert
    bibles
-   themes
+   configure
+   dualmonitors
+   wizard
+   glossary
    mediamanager
    songs
-   alert
+   themes
+
+Questions and Troubleshooting
+-----------------------------
+
+.. toctree::
+   :maxdepth: 2
+
    faq
    troubleshooting

documentation/manual/source/installation.rst

@@ -0,0 +1,66 @@
+Installing OpenLP
+=================
+
+Microsoft Windows
+-----------------
+
+Installing OpenLP is identical over all supported versions of Windows. After
+downloading the file from the `download page <http://www.openlp.org/en/download.html>`_ 
+open the file by double clicking when the download is complete. After opening 
+the downloaded file agree to open the unverified file if you are prompted.
+
+Next select your language and click :guilabel:`OK`
+
+.. image:: pics/selectlanguage.png
+
+After reading the welcome message click :guilabel:`Next` to continue the
+installation.
+
+.. image:: pics/welcome.png
+
+Agree to the license agreement. Click :guilabel:`Next` to continue.
+
+.. image:: pics/license.png
+
+Select the install location for OpenLP. Choosing the default location is
+generally the best choice. Click :guilabel:`Next` to continue.
+
+.. image:: pics/installlocation.png
+
+Select a start menu folder for OpenLP to be visible in. The default location
+here is generally the best choice. Click :guilabel:`Next` to continue.
+
+.. image:: pics/startmenufolder.png
+
+Select if you want to create a desktop or Quick Launch icon. Click :guilabel:`Next`
+to continue.
+
+.. image:: pics/additionaltask.png
+
+Review your previous choices. If you need to make any changes click the
+:guilabel:`Back button` to get to the previous choices, or click :guilabel:`Install`
+
+.. image:: pics/readytoinstall.png
+
+The progress bar will update you on how far along the installation has gone.
+
+.. image:: pics/progress.png
+
+When the install is complete you will have the option to launch OpenLP. After
+making your selection click :guilabel:`Finish`
+
+Mac OS X
+--------
+
+Installing OpenLP on OS X is very simple. After downloading the correct file
+from the OpenLP `download page <http://www.openlp.org/en/download.html>`_ 
+double click on the .dmg file. Drag the OpenLP icon over to the Applications
+folder and you will be ready to use OpenLP. OpenLP will be available in your
+Applications folder.
+
+.. image:: pics/osxinstall.png
+
+Linux
+-----
+
+Installation process on Linux distributions vary by distribution. See the OpenLP `download page <http://www.openlp.org/en/download.html>`_ for distribution specific instructions.

documentation/manual/source/troubleshooting.rst

@@ -175,3 +175,23 @@ only download the section you search for. If you do not have an internet
 connection where you intend to use OpenLP you will need another scripture
 source. For more information about acquiring Bibles please see :ref:`bibleimporter`.
 
+OpenLP is using a large amount of RAM when showing a presentation
+-----------------------------------------------------------------
+
+OpenLP uses a large amount of RAM when showing a presentation due to the way it
+handles presentations. OpenLP itself is unable to show those presentations or
+load the presentation files, so it interacts with the presentation through
+either Microsoft PowerPoint or LibreOffice Impress. In order to show the slides
+in the slide controller, OpenLP requests that the presentation application
+export the slides to images, and then uses those images as slides. This results
+in a large amount of RAM being used, especially in presentations with more than
+about 20 slides.
+
+OpenLP is not displaying correctly, or is not on the correct screen
+-------------------------------------------------------------------
+
+Please read the documentation on :ref:`dualmonitors`. It is very important to 
+have dual monitors setup properly for OpenLP to function as expected.
+
+
+

openlp.pyw

@@ -46,7 +46,7 @@ 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
+    get_application_version, DelayStartThread
 
 log = logging.getLogger()
 
@@ -130,6 +130,7 @@ class OpenLP(QtGui.QApplication):
             u'general/update check', QtCore.QVariant(True)).toBool()
         if update_check:
             VersionThread(self.mainWindow).start()
+        DelayStartThread(self.mainWindow).start()
         return self.exec_()
 
     def isAlreadyRunning(self):
@@ -240,8 +241,14 @@ def main():
             + "/qt4_plugins")
     # i18n Set Language
     language = LanguageManager.get_language()
-    appTranslator = LanguageManager.get_translator(language)
-    app.installTranslator(appTranslator)
+    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())
@@ -250,4 +257,4 @@ if __name__ == u'__main__':
     """
     Instantiate and run the application.
     """
-    main()
+    main()

openlp/core/lib/__init__.py

@@ -37,6 +37,7 @@ log = logging.getLogger(__name__)
 
 base_html_expands = []
 
+# Hex Color tags from http://www.w3schools.com/html/html_colornames.asp
 base_html_expands.append({u'desc': u'Red', u'start tag': u'{r}',
     u'start html': u'<span style="-webkit-text-fill-color:red">',
     u'end tag': u'{/r}', u'end html': u'</span>', u'protected': True})
@@ -53,13 +54,13 @@ base_html_expands.append({u'desc': u'Green', u'start tag': u'{g}',
     u'start html': u'<span style="-webkit-text-fill-color:green">',
     u'end tag': u'{/g}', u'end html': u'</span>', u'protected': True})
 base_html_expands.append({u'desc': u'Pink', u'start tag': u'{pk}',
-    u'start html': u'<span style="-webkit-text-fill-color:#CC33CC">',
+    u'start html': u'<span style="-webkit-text-fill-color:#FFC0CB">',
     u'end tag': u'{/pk}', u'end html': u'</span>', u'protected': True})
 base_html_expands.append({u'desc': u'Orange', u'start tag': u'{o}',
-    u'start html': u'<span style="-webkit-text-fill-color:#CC0033">',
+    u'start html': u'<span style="-webkit-text-fill-color:#FFA500">',
     u'end tag': u'{/o}', u'end html': u'</span>', u'protected': True})
 base_html_expands.append({u'desc': u'Purple', u'start tag': u'{pp}',
-    u'start html': u'<span style="-webkit-text-fill-color:#9900FF">',
+    u'start html': u'<span style="-webkit-text-fill-color:#800080">',
     u'end tag': u'{/pp}', u'end html': u'</span>', u'protected': True})
 base_html_expands.append({u'desc': u'White', u'start tag': u'{w}',
     u'start html': u'<span style="-webkit-text-fill-color:white">',
@@ -84,7 +85,8 @@ base_html_expands.append({u'desc': u'Underline', u'start tag': u'{u}',
     u'end tag': u'{/u}', u'end html': u'</span>', u'protected': True})
 
 def translate(context, text, comment=None,
-    encoding=QtCore.QCoreApplication.CodecForTr, n=-1):
+    encoding=QtCore.QCoreApplication.CodecForTr, n=-1,
+    translate=QtCore.QCoreApplication.translate):
     """
     A special shortcut method to wrap around the Qt4 translation functions.
     This abstracts the translation procedure so that we can change it if at a
@@ -101,8 +103,7 @@ def translate(context, text, comment=None,
         An identifying string for when the same text is used in different roles
         within the same context.
     """
-    return QtCore.QCoreApplication.translate(
-        context, text, comment, encoding, n)
+    return translate(context, text, comment, encoding, n)
 
 def get_text_file_string(text_file):
     """
@@ -289,6 +290,5 @@ from htmlbuilder import build_html, build_lyrics_format_css, \
 from toolbar import OpenLPToolbar
 from dockwidget import OpenLPDockWidget
 from renderer import Renderer
-from rendermanager import RenderManager
 from mediamanageritem import MediaManagerItem
 from openlp.core.utils.actions import ActionList

openlp/core/lib/mediamanageritem.py

@@ -34,7 +34,7 @@ from PyQt4 import QtCore, QtGui
 from openlp.core.lib import SettingsManager, OpenLPToolbar, ServiceItem, \
     StringContent, build_icon, translate, Receiver, ListWidgetWithDnD
 from openlp.core.lib.ui import UiStrings, context_menu_action, \
-    context_menu_separator
+    context_menu_separator, critical_error_message_box
 
 log = logging.getLogger(__name__)
 
@@ -333,7 +333,21 @@ class MediaManagerItem(QtGui.QWidget):
         log.info(u'New files(s) %s', unicode(files))
         if files:
             Receiver.send_message(u'cursor_busy')
-            self.loadList(files)
+            names = []
+            for count in range(0, self.listView.count()):
+                names.append(self.listView.item(count).text())
+            newFiles = []
+            for file in files:
+                filename = os.path.split(unicode(file))[1]
+                if filename in names:
+                    critical_error_message_box(
+                        UiStrings().Duplicate,
+                        unicode(translate('OpenLP.MediaManagerItem',
+                        'Duplicate file name %s.\nFilename already exists in '
+                        'list')) % filename)
+                else:
+                    newFiles.append(file)
+            self.loadList(newFiles)
             lastDir = os.path.split(unicode(files[0]))[0]
             SettingsManager.set_last_dir(self.settingsSection, lastDir)
             SettingsManager.set_list(self.settingsSection,
@@ -554,4 +568,4 @@ class MediaManagerItem(QtGui.QWidget):
                 item_id = remoteItem
         else:
             item_id = (item.data(QtCore.Qt.UserRole)).toInt()[0]
-        return item_id
+        return item_id

openlp/core/lib/plugin.py

@@ -161,7 +161,7 @@ class Plugin(QtCore.QObject):
         self.log = logging.getLogger(self.name)
         self.previewController = plugin_helpers[u'preview']
         self.liveController = plugin_helpers[u'live']
-        self.renderManager = plugin_helpers[u'render']
+        self.renderer = plugin_helpers[u'renderer']
         self.serviceManager = plugin_helpers[u'service']
         self.settingsForm = plugin_helpers[u'settings form']
         self.mediadock = plugin_helpers[u'toolbox']
@@ -359,4 +359,4 @@ class Plugin(QtCore.QObject):
         use of the singular name of the plugin object so must only be called
         after this has been set.
         """
-        self.textStrings[name] = {u'title': title, u'tooltip': tooltip}
+        self.textStrings[name] = {u'title': title, u'tooltip': tooltip}

openlp/core/lib/renderer.py

@@ -23,46 +23,260 @@
 # with this program; if not, write to the Free Software Foundation, Inc., 59  #
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
-"""
-The :mod:`renderer` module enables OpenLP to take the input from plugins and
-format it for the output display.
-"""
+
 import logging
 
-from PyQt4 import QtWebKit
+from PyQt4 import QtCore, QtWebKit
 
-from openlp.core.lib import expand_tags, build_lyrics_format_css, \
-    build_lyrics_outline_css, Receiver
+from openlp.core.lib import ServiceItem, ImageManager, expand_tags, \
+    build_lyrics_format_css, build_lyrics_outline_css, Receiver, \
+    ItemCapabilities
+from openlp.core.lib.theme import ThemeLevel
+from openlp.core.ui import MainDisplay
 
 log = logging.getLogger(__name__)
 
+VERSE = u'The Lord said to {r}Noah{/r}: \n' \
+    'There\'s gonna be a {su}floody{/su}, {sb}floody{/sb}\n' \
+    'The Lord said to {g}Noah{/g}:\n' \
+    'There\'s gonna be a {st}floody{/st}, {it}floody{/it}\n' \
+    'Get those children out of the muddy, muddy \n' \
+    '{r}C{/r}{b}h{/b}{bl}i{/bl}{y}l{/y}{g}d{/g}{pk}' \
+    'r{/pk}{o}e{/o}{pp}n{/pp} of the Lord\n'
+FOOTER = [u'Arky Arky (Unknown)', u'Public Domain', u'CCLI 123456']
+
+HTML_END = u'</div></body></html>'
+
 class Renderer(object):
     """
-    Genarates a pixmap image of a array of text. The Text is formatted to
-    make sure it fits on the screen and if not extra frames are generated.
+    Class to pull all Renderer interactions into one place. The plugins will
+    call helper methods to do the rendering but this class will provide
+    display defense code.
+
+    ``theme_manager``
+        The ThemeManager instance, used to get the current theme details.
+
+    ``screens``
+        Contains information about the Screens.
+
+    ``screen_number``
+        Defaults to *0*. The index of the output/display screen.
     """
     log.info(u'Renderer Loaded')
 
-    def __init__(self):
+    def __init__(self, theme_manager, screens):
         """
-        Initialise the renderer.
+        Initialise the render manager.
         """
-        self._rect = None
-        self.theme_name = None
-        self._theme = None
+        log.debug(u'Initilisation started')
+        self.screens = screens
+        self.image_manager = ImageManager()
+        self.display = MainDisplay(self, screens, False)
+        self.display.imageManager = self.image_manager
+        self.theme_manager = theme_manager
+        self.service_theme = u''
+        self.theme_level = u''
+        self.override_background = None
+        self.theme_data = None
+        self.force_page = False
 
-    def set_theme(self, theme):
+    def update_display(self):
         """
-        Set the theme to be used.
+        Updates the render manager's information about the current screen.
+        """
+        log.debug(u'Update Display')
+        self._calculate_default(self.screens.current[u'size'])
+        self.display = MainDisplay(self, self.screens, False)
+        self.display.imageManager = self.image_manager
+        self.display.setup()
+        self.bg_frame = None
+        self.theme_data = None
+        self.image_manager.update_display(self.width, self.height)
+
+    def set_global_theme(self, global_theme, theme_level=ThemeLevel.Global):
+        """
+        Set the global-level theme and the theme level.
+
+        ``global_theme``
+            The global-level theme to be set.
+
+        ``theme_level``
+            Defaults to *``ThemeLevel.Global``*. The theme level, can be
+            ``ThemeLevel.Global``, ``ThemeLevel.Service`` or
+            ``ThemeLevel.Song``.
+        """
+        self.global_theme = global_theme
+        self.theme_level = theme_level
+        self.global_theme_data = \
+            self.theme_manager.getThemeData(self.global_theme)
+        self.theme_data = None
+
+    def set_service_theme(self, service_theme):
+        """
+        Set the service-level theme.
+
+        ``service_theme``
+            The service-level theme to be set.
+        """
+        self.service_theme = service_theme
+        self.theme_data = None
+
+    def set_override_theme(self, override_theme, override_levels=False):
+        """
+        Set the appropriate theme depending on the theme level.
+        Called by the service item when building a display frame
 
         ``theme``
-            The theme to be used.
-        """
-        log.debug(u'set theme')
-        self._theme = theme
-        self.theme_name = theme.theme_name
+            The name of the song-level theme. None means the service
+            item wants to use the given value.
 
-    def set_text_rectangle(self, rect_main, rect_footer):
+        ``override_levels``
+            Used to force the theme data passed in to be used.
+
+        """
+        log.debug(u'set override theme to %s', override_theme)
+        theme_level = self.theme_level
+        if override_levels:
+            theme_level = ThemeLevel.Song
+        if theme_level == ThemeLevel.Global:
+            theme = self.global_theme
+        elif theme_level == ThemeLevel.Service:
+            if self.service_theme == u'':
+                theme = self.global_theme
+            else:
+                theme = self.service_theme
+        else:
+            # Images have a theme of -1
+            if override_theme and override_theme != -1:
+                theme = override_theme
+            elif theme_level == ThemeLevel.Song or \
+                theme_level == ThemeLevel.Service:
+                if self.service_theme == u'':
+                    theme = self.global_theme
+                else:
+                    theme = self.service_theme
+            else:
+                theme = self.global_theme
+        log.debug(u'theme is now %s', theme)
+        # Force the theme to be the one passed in.
+        if override_levels:
+            self.theme_data = override_theme
+        else:
+            self.theme_data = self.theme_manager.getThemeData(theme)
+        self._calculate_default(self.screens.current[u'size'])
+        self._build_text_rectangle(self.theme_data)
+        self.image_manager.add_image(self.theme_data.theme_name,
+            self.theme_data.background_filename)
+        return self._rect, self._rect_footer
+
+    def generate_preview(self, theme_data, force_page=False):
+        """
+        Generate a preview of a theme.
+
+        ``theme_data``
+            The theme to generated a preview for.
+
+        ``force_page``
+            Flag to tell message lines per page need to be generated.
+        """
+        log.debug(u'generate preview')
+        # save value for use in format_slide
+        self.force_page = force_page
+        # set the default image size for previews
+        self._calculate_default(self.screens.preview[u'size'])
+        # build a service item to generate preview
+        serviceItem = ServiceItem()
+        serviceItem.theme = theme_data
+        if self.force_page:
+            # make big page for theme edit dialog to get line count
+            serviceItem.add_from_text(u'', VERSE + VERSE + VERSE, FOOTER)
+        else:
+            self.image_manager.del_image(theme_data.theme_name)
+            serviceItem.add_from_text(u'', VERSE, FOOTER)
+        serviceItem.renderer = self
+        serviceItem.raw_footer = FOOTER
+        serviceItem.render(True)
+        if not self.force_page:
+            self.display.buildHtml(serviceItem)
+            raw_html = serviceItem.get_rendered_frame(0)
+            preview = self.display.text(raw_html)
+            # Reset the real screen size for subsequent render requests
+            self._calculate_default(self.screens.current[u'size'])
+            return preview
+
+    def format_slide(self, text, line_break, item):
+        """
+        Calculate how much text can fit on a slide.
+
+        ``text``
+            The words to go on the slides.
+
+        ``line_break``
+            Add line endings after each line of text used for bibles.
+        """
+        log.debug(u'format slide')
+        # clean up line endings
+        lines = self._lines_split(text)
+        pages = self._paginate_slide(lines, line_break, self.force_page)
+        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')
+                    new_pages = self._paginate_slide(lines, line_break,
+                        self.force_page)
+                    pages.extend(new_pages)
+            # Bibles
+            elif item.is_capable(ItemCapabilities.AllowsWordSplit):
+                pages = self._paginate_slide_words(text, line_break)
+        return pages
+
+    def _calculate_default(self, screen):
+        """
+        Calculate the default dimentions of the screen.
+
+        ``screen``
+            The QSize of the screen.
+        """
+        log.debug(u'calculate default %s', screen)
+        self.width = screen.width()
+        self.height = screen.height()
+        self.screen_ratio = float(self.height) / float(self.width)
+        log.debug(u'calculate default %d, %d, %f',
+            self.width, self.height, self.screen_ratio)
+        # 90% is start of footer
+        self.footer_start = int(self.height * 0.90)
+
+    def _build_text_rectangle(self, theme):
+        """
+        Builds a text block using the settings in ``theme``
+        and the size of the display screen.height.
+        Note the system has a 10 pixel border round the screen
+
+        ``theme``
+            The theme to build a text block for.
+        """
+        log.debug(u'_build_text_rectangle')
+        main_rect = None
+        footer_rect = None
+        if not theme.font_main_override:
+            main_rect = QtCore.QRect(10, 0, self.width - 20, self.footer_start)
+        else:
+            main_rect = QtCore.QRect(theme.font_main_x, theme.font_main_y,
+                theme.font_main_width - 1, theme.font_main_height - 1)
+        if not theme.font_footer_override:
+            footer_rect = QtCore.QRect(10, self.footer_start, self.width - 20,
+                self.height - self.footer_start)
+        else:
+            footer_rect = QtCore.QRect(theme.font_footer_x,
+                theme.font_footer_y, theme.font_footer_width - 1,
+                theme.font_footer_height - 1)
+        self._set_text_rectangle(main_rect, footer_rect)
+
+    def _set_text_rectangle(self, rect_main, rect_footer):
         """
         Sets the rectangle within which text should be rendered.
 
@@ -77,9 +291,9 @@ class Renderer(object):
         self._rect_footer = rect_footer
         self.page_width = self._rect.width()
         self.page_height = self._rect.height()
-        if self._theme.font_main_shadow:
-            self.page_width -= int(self._theme.font_main_shadow_size)
-            self.page_height -= int(self._theme.font_main_shadow_size)
+        if self.theme_data.font_main_shadow:
+            self.page_width -= int(self.theme_data.font_main_shadow_size)
+            self.page_height -= int(self.theme_data.font_main_shadow_size)
         self.web = QtWebKit.QWebView()
         self.web.setVisible(False)
         self.web.resize(self.page_width, self.page_height)
@@ -89,59 +303,146 @@ class Renderer(object):
             u'*{margin: 0; padding: 0; border: 0;} '\
             u'#main {position:absolute; top:0px; %s %s}</style><body>' \
             u'<div id="main">' % \
-            (build_lyrics_format_css(self._theme, self.page_width,
-            self.page_height), build_lyrics_outline_css(self._theme))
+            (build_lyrics_format_css(self.theme_data, self.page_width,
+            self.page_height), build_lyrics_outline_css(self.theme_data))
 
-    def format_slide(self, words, line_break, force_page=False):
+    def _paginate_slide(self, lines, line_break, force_page=False):
         """
         Figure out how much text can appear on a slide, using the current
         theme settings.
 
-        ``words``
-            The words to be fitted on the slide.
+        ``lines``
+            The words to be fitted on the slide split into lines.
 
         ``line_break``
-            Add line endings after each line of text used for bibles.
+            Add line endings after each line of text (used for bibles).
 
         ``force_page``
             Flag to tell message lines in page.
 
         """
-        log.debug(u'format_slide - Start')
+        log.debug(u'_paginate_slide - Start')
         line_end = u''
         if line_break:
             line_end = u'<br>'
-        words = words.replace(u'\r\n', u'\n')
-        verses_text = words.split(u'\n')
-        text = []
-        for verse in verses_text:
-            lines = verse.split(u'\n')
-            for line in lines:
-                text.append(line)
         formatted = []
         html_text = u''
         styled_text = u''
         line_count = 0
-        for line in text:
+        for line in lines:
             if line_count != -1:
                 line_count += 1
             styled_line = expand_tags(line) + line_end
             styled_text += styled_line
-            html = self.page_shell + styled_text + u'</div></body></html>'
+            html = self.page_shell + styled_text + HTML_END
             self.web.setHtml(html)
             # Text too long so go to next page
             if self.web_frame.contentsSize().height() > self.page_height:
                 if force_page and line_count > 0:
                     Receiver.send_message(u'theme_line_count', line_count)
                 line_count = -1
-                if html_text.endswith(u'<br>'):
-                    html_text = html_text[:len(html_text)-4]
+                while html_text.endswith(u'<br>'):
+                    html_text = html_text[:-4]
                 formatted.append(html_text)
                 html_text = u''
                 styled_text = styled_line
             html_text += line + line_end
-        if html_text.endswith(u'<br>'):
-            html_text = html_text[:len(html_text)-4]
+        while html_text.endswith(u'<br>'):
+            html_text = html_text[:-4]
         formatted.append(html_text)
-        log.debug(u'format_slide - End')
+        log.debug(u'_paginate_slide - End')
         return formatted
+
+    def _paginate_slide_words(self, text, line_break):
+        """
+        Figure out how much text can appear on a slide, using the current
+        theme settings. This version is to handle text which needs to be split
+        into words to get it to fit.
+
+        ``text``
+            The words to be fitted on the slide split into lines.
+
+        ``line_break``
+            Add line endings after each line of text used for bibles.
+
+        """
+        log.debug(u'_paginate_slide_words - Start')
+        line_end = u''
+        if line_break:
+            line_end = u'<br>'
+        formatted = []
+        previous_html = u''
+        previous_raw = u''
+        lines = text.split(u'\n')
+        for line in lines:
+            styled_line = expand_tags(line)
+            html = self.page_shell + previous_html + styled_line + HTML_END
+            self.web.setHtml(html)
+            # Text too long so go to next page
+            if self.web_frame.contentsSize().height() > self.page_height:
+                # Check if there was a verse before the current one and append
+                # it, when it fits on the page.
+                if previous_html:
+                    html = self.page_shell + previous_html + HTML_END
+                    self.web.setHtml(html)
+                    if self.web_frame.contentsSize().height() <= \
+                        self.page_height:
+                        while previous_raw.endswith(u'<br>'):
+                            previous_raw = previous_raw[:-4]
+                        formatted.append(previous_raw)
+                        previous_html = u''
+                        previous_raw = u''
+                        html = self.page_shell + styled_line + HTML_END
+                        self.web.setHtml(html)
+                        # Now check if the current verse will fit, if it does
+                        # not we have to start to process the verse word by
+                        # word.
+                        if self.web_frame.contentsSize().height() <= \
+                            self.page_height:
+                            previous_html = styled_line + line_end
+                            previous_raw = line + line_end
+                            continue
+                words = self._words_split(line)
+                for word in words:
+                    styled_word = expand_tags(word)
+                    html = self.page_shell + previous_html + styled_word + \
+                        HTML_END
+                    self.web.setHtml(html)
+                    # Text too long so go to next page
+                    if self.web_frame.contentsSize().height() > \
+                        self.page_height:
+                        while previous_raw.endswith(u'<br>'):
+                            previous_raw = previous_raw[:-4]
+                        formatted.append(previous_raw)
+                        previous_html = u''
+                        previous_raw = u''
+                    previous_html += styled_word
+                    previous_raw += word
+                previous_html += line_end
+                previous_raw += line_end
+            else:
+                previous_html += styled_line + line_end
+                previous_raw += line + line_end
+        while previous_raw.endswith(u'<br>'):
+            previous_raw = previous_raw[:-4]
+        formatted.append(previous_raw)
+        log.debug(u'_paginate_slide_words - End')
+        return formatted
+
+    def _words_split(self, line):
+        """
+        Split the slide up by word so can wrap better
+        """
+        # this parse we are to be wordy
+        line = line.replace(u'\n', u' ')
+        words = line.split(u' ')
+        return [word + u' ' for word in words]
+
+    def _lines_split(self, text):
+        """
+        Split the slide up by physical line
+        """
+        # this parse we do not want to use this so remove it
+        text = text.replace(u'\n[---]', u'')
+        lines = text.split(u'\n')
+        return [line.replace(u'[---]', u'') for line in lines]

openlp/core/lib/rendermanager.py

@@ -1,261 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4
-
-###############################################################################
-# OpenLP - Open Source Lyrics Projection                                      #
-# --------------------------------------------------------------------------- #
-# Copyright (c) 2008-2011 Raoul Snyman                                        #
-# Portions copyright (c) 2008-2011 Tim Bentley, Jonathan Corwin, Michael      #
-# Gorven, Scott Guerrieri, Matthias Hub, Meinert Jordan, Armin Köhler,        #
-# Andreas Preikschat, Mattias Põldaru, Christian Richter, Philip Ridout,      #
-# Maikel Stuivenberg, Martin Thompson, Jon Tibble, Frode Woldsund             #
-# --------------------------------------------------------------------------- #
-# This program is free software; you can redistribute it and/or modify it     #
-# under the terms of the GNU General Public License as published by the Free  #
-# Software Foundation; version 2 of the License.                              #
-#                                                                             #
-# This program is distributed in the hope that it will be useful, but WITHOUT #
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
-# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
-# more details.                                                               #
-#                                                                             #
-# You should have received a copy of the GNU General Public License along     #
-# with this program; if not, write to the Free Software Foundation, Inc., 59  #
-# Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
-###############################################################################
-
-import logging
-
-from PyQt4 import QtCore
-
-from openlp.core.lib import Renderer, ServiceItem, ImageManager
-from openlp.core.lib.theme import ThemeLevel
-from openlp.core.ui import MainDisplay
-
-log = logging.getLogger(__name__)
-
-VERSE = u'The Lord said to {r}Noah{/r}: \n' \
-    'There\'s gonna be a {su}floody{/su}, {sb}floody{/sb}\n' \
-    'The Lord said to {g}Noah{/g}:\n' \
-    'There\'s gonna be a {st}floody{/st}, {it}floody{/it}\n' \
-    'Get those children out of the muddy, muddy \n' \
-    '{r}C{/r}{b}h{/b}{bl}i{/bl}{y}l{/y}{g}d{/g}{pk}' \
-    'r{/pk}{o}e{/o}{pp}n{/pp} of the Lord\n'
-FOOTER = [u'Arky Arky (Unknown)', u'Public Domain', u'CCLI 123456']
-
-class RenderManager(object):
-    """
-    Class to pull all Renderer interactions into one place. The plugins will
-    call helper methods to do the rendering but this class will provide
-    display defense code.
-
-    ``theme_manager``
-        The ThemeManager instance, used to get the current theme details.
-
-    ``screens``
-        Contains information about the Screens.
-
-    ``screen_number``
-        Defaults to *0*. The index of the output/display screen.
-    """
-    log.info(u'RenderManager Loaded')
-
-    def __init__(self, theme_manager, screens):
-        """
-        Initialise the render manager.
-        """
-        log.debug(u'Initilisation started')
-        self.screens = screens
-        self.image_manager = ImageManager()
-        self.display = MainDisplay(self, screens, False)
-        self.display.imageManager = self.image_manager
-        self.theme_manager = theme_manager
-        self.renderer = Renderer()
-        self.calculate_default(self.screens.current[u'size'])
-        self.theme = u''
-        self.service_theme = u''
-        self.theme_level = u''
-        self.override_background = None
-        self.theme_data = None
-        self.force_page = False
-
-    def update_display(self):
-        """
-        Updates the render manager's information about the current screen.
-        """
-        log.debug(u'Update Display')
-        self.calculate_default(self.screens.current[u'size'])
-        self.display = MainDisplay(self, self.screens, False)
-        self.display.imageManager = self.image_manager
-        self.display.setup()
-        self.renderer.bg_frame = None
-        self.theme_data = None
-        self.image_manager.update_display(self.width, self.height)
-
-    def set_global_theme(self, global_theme, theme_level=ThemeLevel.Global):
-        """
-        Set the global-level theme and the theme level.
-
-        ``global_theme``
-            The global-level theme to be set.
-
-        ``theme_level``
-            Defaults to *``ThemeLevel.Global``*. The theme level, can be
-            ``ThemeLevel.Global``, ``ThemeLevel.Service`` or
-            ``ThemeLevel.Song``.
-        """
-        self.global_theme = global_theme
-        self.theme_level = theme_level
-        self.global_theme_data = \
-            self.theme_manager.getThemeData(self.global_theme)
-        self.theme_data = None
-
-    def set_service_theme(self, service_theme):
-        """
-        Set the service-level theme.
-
-        ``service_theme``
-            The service-level theme to be set.
-        """
-        self.service_theme = service_theme
-        self.theme_data = None
-
-    def set_override_theme(self, theme, overrideLevels=False):
-        """
-        Set the appropriate theme depending on the theme level.
-        Called by the service item when building a display frame
-
-        ``theme``
-            The name of the song-level theme. None means the service
-            item wants to use the given value.
-
-        ``overrideLevels``
-            Used to force the theme data passed in to be used.
-
-        """
-        log.debug(u'set override theme to %s', theme)
-        theme_level = self.theme_level
-        if overrideLevels:
-            theme_level = ThemeLevel.Song
-        if theme_level == ThemeLevel.Global:
-            self.theme = self.global_theme
-        elif theme_level == ThemeLevel.Service:
-            if self.service_theme == u'':
-                self.theme = self.global_theme
-            else:
-                self.theme = self.service_theme
-        else:
-            # Images have a theme of -1
-            if theme and theme != -1:
-                self.theme = theme
-            elif theme_level == ThemeLevel.Song or \
-                theme_level == ThemeLevel.Service:
-                if self.service_theme == u'':
-                    self.theme = self.global_theme
-                else:
-                    self.theme = self.service_theme
-            else:
-                self.theme = self.global_theme
-        if self.theme != self.renderer.theme_name or self.theme_data is None \
-            or overrideLevels:
-            log.debug(u'theme is now %s', self.theme)
-            # Force the theme to be the one passed in.
-            if overrideLevels:
-                self.theme_data = theme
-            else:
-                self.theme_data = self.theme_manager.getThemeData(self.theme)
-            self.calculate_default(self.screens.current[u'size'])
-            self.renderer.set_theme(self.theme_data)
-            self.build_text_rectangle(self.theme_data)
-            self.image_manager.add_image(self.theme_data.theme_name,
-                self.theme_data.background_filename)
-        return self.renderer._rect, self.renderer._rect_footer
-
-    def build_text_rectangle(self, theme):
-        """
-        Builds a text block using the settings in ``theme``
-        and the size of the display screen.height.
-
-        ``theme``
-            The theme to build a text block for.
-        """
-        log.debug(u'build_text_rectangle')
-        main_rect = None
-        footer_rect = None
-        if not theme.font_main_override:
-            main_rect = QtCore.QRect(10, 0, self.width - 20, self.footer_start)
-        else:
-            main_rect = QtCore.QRect(theme.font_main_x, theme.font_main_y,
-                theme.font_main_width - 1, theme.font_main_height - 1)
-        if not theme.font_footer_override:
-            footer_rect = QtCore.QRect(10, self.footer_start, self.width - 20,
-                self.height - self.footer_start)
-        else:
-            footer_rect = QtCore.QRect(theme.font_footer_x,
-                theme.font_footer_y, theme.font_footer_width - 1,
-                theme.font_footer_height - 1)
-        self.renderer.set_text_rectangle(main_rect, footer_rect)
-
-    def generate_preview(self, theme_data, force_page=False):
-        """
-        Generate a preview of a theme.
-
-        ``theme_data``
-            The theme to generated a preview for.
-
-        ``force_page``
-            Flag to tell message lines per page need to be generated.
-        """
-        log.debug(u'generate preview')
-        # save value for use in format_slide
-        self.force_page = force_page
-        # set the default image size for previews
-        self.calculate_default(self.screens.preview[u'size'])
-        # build a service item to generate preview
-        serviceItem = ServiceItem()
-        serviceItem.theme = theme_data
-        if self.force_page:
-            # make big page for theme edit dialog to get line count
-            serviceItem.add_from_text(u'', VERSE + VERSE + VERSE, FOOTER)
-        else:
-            self.image_manager.del_image(theme_data.theme_name)
-            serviceItem.add_from_text(u'', VERSE, FOOTER)
-        serviceItem.render_manager = self
-        serviceItem.raw_footer = FOOTER
-        serviceItem.render(True)
-        if not self.force_page:
-            self.display.buildHtml(serviceItem)
-            raw_html = serviceItem.get_rendered_frame(0)
-            preview = self.display.text(raw_html)
-            # Reset the real screen size for subsequent render requests
-            self.calculate_default(self.screens.current[u'size'])
-            return preview
-
-    def format_slide(self, words, line_break):
-        """
-        Calculate how much text can fit on a slide.
-
-        ``words``
-            The words to go on the slides.
-
-        ``line_break``
-            Add line endings after each line of text used for bibles.
-        """
-        log.debug(u'format slide')
-        return self.renderer.format_slide(words, line_break, self.force_page)
-
-    def calculate_default(self, screen):
-        """
-        Calculate the default dimentions of the screen.
-
-        ``screen``
-            The QSize of the screen.
-        """
-        log.debug(u'calculate default %s', screen)
-        self.width = screen.width()
-        self.height = screen.height()
-        self.screen_ratio = float(self.height) / float(self.width)
-        log.debug(u'calculate default %d, %d, %f',
-            self.width, self.height, self.screen_ratio)
-        # 90% is start of footer
-        self.footer_start = int(self.height * 0.90)

openlp/core/lib/serviceitem.py

@@ -63,6 +63,8 @@ class ItemCapabilities(object):
     ProvidesOwnDisplay = 10
     AllowsDetailedTitleDisplay = 11
     AllowsVariableStartTime = 12
+    AllowsVirtualSplit = 13
+    AllowsWordSplit = 14
 
 
 class ServiceItem(object):
@@ -81,7 +83,7 @@ class ServiceItem(object):
             The plugin that this service item belongs to.
         """
         if plugin:
-            self.render_manager = plugin.renderManager
+            self.renderer = plugin.renderer
             self.name = plugin.name
         self.title = u''
         self.shortname = u''
@@ -151,7 +153,7 @@ class ServiceItem(object):
         self.icon = icon
         self.iconic_representation = build_icon(icon)
 
-    def render(self, useOverride=False):
+    def render(self, use_override=False):
         """
         The render method is what generates the frames for the screen and
         obtains the display information from the renderemanager.
@@ -161,24 +163,23 @@ class ServiceItem(object):
         log.debug(u'Render called')
         self._display_frames = []
         self.bg_image_bytes = None
-        line_break = True
-        if self.is_capable(ItemCapabilities.NoLineBreaks):
-            line_break = False
+        line_break = not self.is_capable(ItemCapabilities.NoLineBreaks)
         theme = self.theme if self.theme else None
         self.main, self.footer = \
-            self.render_manager.set_override_theme(theme, useOverride)
-        self.themedata = self.render_manager.renderer._theme
+            self.renderer.set_override_theme(theme, use_override)
+        self.themedata = self.renderer.theme_data
         if self.service_item_type == ServiceItemType.Text:
             log.debug(u'Formatting slides')
             for slide in self._raw_frames:
-                formatted = self.render_manager \
-                    .format_slide(slide[u'raw_slide'], line_break)
+                formatted = self.renderer \
+                    .format_slide(slide[u'raw_slide'], line_break, self)
                 for page in formatted:
-                    self._display_frames.append(
-                        {u'title': clean_tags(page),
+                    self._display_frames.append({
+                        u'title': clean_tags(page),
                         u'text': clean_tags(page.rstrip()),
                         u'html': expand_tags(page.rstrip()),
-                        u'verseTag': slide[u'verseTag'] })
+                        u'verseTag': slide[u'verseTag']
+                    })
         elif self.service_item_type == ServiceItemType.Image or \
             self.service_item_type == ServiceItemType.Command:
             pass
@@ -205,7 +206,7 @@ class ServiceItem(object):
         """
         self.service_item_type = ServiceItemType.Image
         self._raw_frames.append({u'title': title, u'path': path})
-        self.render_manager.image_manager.add_image(title, path)
+        self.renderer.image_manager.add_image(title, path)
         self._new_item()
 
     def add_from_text(self, title, raw_slide, verse_tag=None):
@@ -453,4 +454,5 @@ class ServiceItem(object):
         elif not start and end:
             return end
         else:
-            return u'%s : %s' % (start, end)
+            return u'%s : %s' % (start, end)
+

openlp/core/lib/theme.py

@@ -637,4 +637,4 @@ class ThemeXML(object):
             self.font_footer_shadow_size)
         self.add_display(self.display_horizontal_align,
             self.display_vertical_align,
-            self.display_slide_transition)
+            self.display_slide_transition)

openlp/core/lib/ui.py

@@ -67,6 +67,7 @@ class UiStrings(object):
         self.Default = unicode(translate('OpenLP.Ui', 'Default'))
         self.Delete = translate('OpenLP.Ui', '&Delete')
         self.DisplayStyle = translate('OpenLP.Ui', 'Display style:')
+        self.Duplicate = translate('OpenLP.Ui', 'Duplicate Error')
         self.Edit = translate('OpenLP.Ui', '&Edit')
         self.EmptyField = translate('OpenLP.Ui', 'Empty Field')
         self.Error = translate('OpenLP.Ui', 'Error')
@@ -124,6 +125,7 @@ class UiStrings(object):
         self.Themes = translate('OpenLP.Ui', 'Themes', 'Plural')
         self.Tools = translate('OpenLP.Ui', 'Tools')
         self.Top = translate('OpenLP.Ui', 'Top')
+        self.UnsupportedFile = translate('OpenLP.Ui', 'Unsupported File')
         self.VersePerSlide = translate('OpenLP.Ui', 'Verse Per Slide')
         self.VersePerLine = translate('OpenLP.Ui', 'Verse Per Line')
         self.Version = translate('OpenLP.Ui', 'Version')

openlp/core/ui/advancedtab.py

@@ -41,11 +41,11 @@ class AdvancedTab(SettingsTab):
         """
         Initialise the settings tab
         """
-        generalTranslated = translate('AdvancedTab', 'Advanced')
-        SettingsTab.__init__(self, parent ,u'Advanced', generalTranslated)
+        advancedTranslated = translate('OpenLP.AdvancedTab', 'Advanced')
         self.default_image = u':/graphics/openlp-splash-screen.png'
         self.default_color = u'#ffffff'
         self.icon_path = u':/system/system_settings.png'
+        SettingsTab.__init__(self, parent, u'Advanced', advancedTranslated)
 
     def setupUi(self):
         """
@@ -82,14 +82,6 @@ class AdvancedTab(SettingsTab):
             u'enableAutoCloseCheckBox')
         self.uiLayout.addRow(self.enableAutoCloseCheckBox)
         self.leftLayout.addWidget(self.uiGroupBox)
-        self.hideMouseGroupBox = QtGui.QGroupBox(self.leftColumn)
-        self.hideMouseGroupBox.setObjectName(u'hideMouseGroupBox')
-        self.hideMouseLayout = QtGui.QVBoxLayout(self.hideMouseGroupBox)
-        self.hideMouseLayout.setObjectName(u'hideMouseLayout')
-        self.hideMouseCheckBox = QtGui.QCheckBox(self.hideMouseGroupBox)
-        self.hideMouseCheckBox.setObjectName(u'hideMouseCheckBox')
-        self.hideMouseLayout.addWidget(self.hideMouseCheckBox)
-        self.leftLayout.addWidget(self.hideMouseGroupBox)
         self.leftLayout.addStretch()
         self.defaultImageGroupBox = QtGui.QGroupBox(self.rightColumn)
         self.defaultImageGroupBox.setObjectName(u'defaultImageGroupBox')
@@ -109,26 +101,42 @@ class AdvancedTab(SettingsTab):
         self.defaultBrowseButton.setObjectName(u'defaultBrowseButton')
         self.defaultBrowseButton.setIcon(
             build_icon(u':/general/general_open.png'))
+        self.defaultRevertButton = QtGui.QToolButton(self.defaultImageGroupBox)
+        self.defaultRevertButton.setObjectName(u'defaultRevertButton')
+        self.defaultRevertButton.setIcon(
+            build_icon(u':/general/general_revert.png'))
         self.defaultFileLayout = QtGui.QHBoxLayout()
         self.defaultFileLayout.setObjectName(u'defaultFileLayout')
         self.defaultFileLayout.addWidget(self.defaultFileEdit)
         self.defaultFileLayout.addWidget(self.defaultBrowseButton)
+        self.defaultFileLayout.addWidget(self.defaultRevertButton)
         self.defaultImageLayout.addRow(self.defaultFileLabel,
             self.defaultFileLayout)
         self.rightLayout.addWidget(self.defaultImageGroupBox)
+        self.hideMouseGroupBox = QtGui.QGroupBox(self.leftColumn)
+        self.hideMouseGroupBox.setObjectName(u'hideMouseGroupBox')
+        self.hideMouseLayout = QtGui.QVBoxLayout(self.hideMouseGroupBox)
+        self.hideMouseLayout.setObjectName(u'hideMouseLayout')
+        self.hideMouseCheckBox = QtGui.QCheckBox(self.hideMouseGroupBox)
+        self.hideMouseCheckBox.setObjectName(u'hideMouseCheckBox')
+        self.hideMouseLayout.addWidget(self.hideMouseCheckBox)
+        self.rightLayout.addWidget(self.hideMouseGroupBox)
         self.rightLayout.addStretch()
 
         QtCore.QObject.connect(self.defaultColorButton,
             QtCore.SIGNAL(u'pressed()'), self.onDefaultColorButtonPressed)
         QtCore.QObject.connect(self.defaultBrowseButton,
             QtCore.SIGNAL(u'pressed()'), self.onDefaultBrowseButtonPressed)
+        QtCore.QObject.connect(self.defaultRevertButton,
+            QtCore.SIGNAL(u'pressed()'), self.onDefaultRevertButtonPressed)
 
     def retranslateUi(self):
         """
         Setup the interface translation strings.
         """
         self.tabTitleVisible = UiStrings().Advanced
-        self.uiGroupBox.setTitle(translate('OpenLP.AdvancedTab', 'UI Settings'))
+        self.uiGroupBox.setTitle(
+            translate('OpenLP.AdvancedTab', 'UI Settings'))
         self.recentLabel.setText(
             translate('OpenLP.AdvancedTab',
                 'Number of recent files to display:'))
@@ -150,8 +158,14 @@ class AdvancedTab(SettingsTab):
             'Default Image'))
         self.defaultColorLabel.setText(translate('OpenLP.AdvancedTab',
             'Background color:'))
+        self.defaultColorButton.setToolTip(translate('OpenLP.AdvancedTab',
+            'Click to select a color.'))
         self.defaultFileLabel.setText(translate('OpenLP.AdvancedTab',
             'Image file:'))
+        self.defaultBrowseButton.setToolTip(translate('OpenLP.AdvancedTab',
+            'Browse for an image file to display.'))
+        self.defaultRevertButton.setToolTip(translate('OpenLP.AdvancedTab',
+            'Revert to the default OpenLP logo.'))
 
     def load(self):
         """
@@ -232,4 +246,8 @@ class AdvancedTab(SettingsTab):
             file_filters)
         if filename:
             self.defaultFileEdit.setText(filename)
-        self.defaultFileEdit.setFocus()
+        self.defaultFileEdit.setFocus()
+
+    def onDefaultRevertButtonPressed(self):
+        self.defaultFileEdit.setText(u':/graphics/openlp-splash-screen.png')
+        self.defaultFileEdit.setFocus()

openlp/core/ui/generaltab.py

@@ -362,12 +362,11 @@ class GeneralTab(SettingsTab):
         Receiver.send_message(u'slidecontroller_live_spin_delay',
             self.timeoutSpinBox.value())
         # Reset screens after initial definition
-        if self.overrideChanged:
-            self.screens.override[u'size'] = QtCore.QRect(
-                self.customXValueEdit.value(),
-                self.customYValueEdit.value(),
-                self.customWidthValueEdit.value(),
-                self.customHeightValueEdit.value())
+        self.screens.override[u'size'] = QtCore.QRect(
+            self.customXValueEdit.value(),
+            self.customYValueEdit.value(),
+            self.customWidthValueEdit.value(),
+            self.customHeightValueEdit.value())
         if self.overrideCheckBox.isChecked():
             self.screens.set_override_display()
         else:
@@ -394,4 +393,4 @@ class GeneralTab(SettingsTab):
         """
         Called when the width, height, x position or y position has changed.
         """
-        self.overrideChanged = True
+        self.overrideChanged = True

openlp/core/ui/maindisplay.py

@@ -70,6 +70,8 @@ class MainDisplay(DisplayWidget):
         self.videoHide = False
         self.override = {}
         self.retranslateUi()
+        self.mediaObject = None
+        self.firstTime = True
         self.setStyleSheet(u'border: 0px; margin: 0px; padding: 0px;')
         self.setWindowFlags(QtCore.Qt.FramelessWindowHint | QtCore.Qt.Tool |
             QtCore.Qt.WindowStaysOnTopHint)
@@ -78,6 +80,9 @@ class MainDisplay(DisplayWidget):
                 QtCore.SIGNAL(u'maindisplay_hide'), self.hideDisplay)
             QtCore.QObject.connect(Receiver.get_receiver(),
                 QtCore.SIGNAL(u'maindisplay_show'), self.showDisplay)
+            QtCore.QObject.connect(Receiver.get_receiver(),
+                QtCore.SIGNAL(u'openlp_phonon_creation'),
+                self.createMediaObject)
 
     def retranslateUi(self):
         """
@@ -102,19 +107,9 @@ class MainDisplay(DisplayWidget):
         self.videoWidget.setGeometry(QtCore.QRect(0, 0,
             self.screen[u'size'].width(), self.screen[u'size'].height()))
         log.debug(u'Setup Phonon for monitor %s' % self.screens.monitor_number)
-        self.mediaObject = Phonon.MediaObject(self)
-        self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self.mediaObject)
-        Phonon.createPath(self.mediaObject, self.videoWidget)
-        Phonon.createPath(self.mediaObject, self.audio)
-        QtCore.QObject.connect(self.mediaObject,
-            QtCore.SIGNAL(u'stateChanged(Phonon::State, Phonon::State)'),
-            self.videoState)
-        QtCore.QObject.connect(self.mediaObject,
-            QtCore.SIGNAL(u'finished()'),
-            self.videoFinished)
-        QtCore.QObject.connect(self.mediaObject,
-            QtCore.SIGNAL(u'tick(qint64)'),
-            self.videoTick)
+        if self.isLive:
+            if not self.firstTime:
+                self.createMediaObject()
         log.debug(u'Setup webView for monitor %s' % self.screens.monitor_number)
         self.webView = QtWebKit.QWebView(self)
         self.webView.setGeometry(0, 0,
@@ -142,7 +137,8 @@ class MainDisplay(DisplayWidget):
             image_file = QtCore.QSettings().value(u'advanced/default image',
                 QtCore.QVariant(u':/graphics/openlp-splash-screen.png'))\
                 .toString()
-            background_color = QtGui.QColor(QtCore.QSettings().value(
+            background_color = QtGui.QColor()
+            background_color.setNamedColor(QtCore.QSettings().value(
                 u'advanced/default color',
                 QtCore.QVariant(u'#ffffff')).toString())
             if not background_color.isValid():
@@ -174,6 +170,24 @@ class MainDisplay(DisplayWidget):
         log.debug(
             u'Finished setup for monitor %s' % self.screens.monitor_number)
 
+    def createMediaObject(self):
+        self.firstTime = False
+        log.debug(u'Creating Phonon objects - Start for %s', self.isLive)
+        self.mediaObject = Phonon.MediaObject(self)
+        self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self.mediaObject)
+        Phonon.createPath(self.mediaObject, self.videoWidget)
+        Phonon.createPath(self.mediaObject, self.audio)
+        QtCore.QObject.connect(self.mediaObject,
+            QtCore.SIGNAL(u'stateChanged(Phonon::State, Phonon::State)'),
+            self.videoState)
+        QtCore.QObject.connect(self.mediaObject,
+            QtCore.SIGNAL(u'finished()'),
+            self.videoFinished)
+        QtCore.QObject.connect(self.mediaObject,
+            QtCore.SIGNAL(u'tick(qint64)'),
+            self.videoTick)
+        log.debug(u'Creating Phonon objects - Finished for %s', self.isLive)
+
     def text(self, slide):
         """
         Add the slide text from slideController
@@ -347,6 +361,8 @@ class MainDisplay(DisplayWidget):
         """
         Loads and starts a video to run with the option of sound
         """
+        if not self.mediaObject:
+            self.createMediaObject()
         log.debug(u'video')
         self.webLoaded = True
         self.setGeometry(self.screen[u'size'])

openlp/core/ui/mainwindow.py

@@ -30,7 +30,7 @@ from tempfile import gettempdir
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import RenderManager, build_icon, OpenLPDockWidget, \
+from openlp.core.lib import Renderer, build_icon, OpenLPDockWidget, \
     SettingsManager, PluginManager, Receiver, translate
 from openlp.core.lib.ui import UiStrings, base_action, checkable_action, \
     icon_action, shortcut_action
@@ -122,12 +122,17 @@ class Ui_MainWindow(object):
         self.HelpMenu = QtGui.QMenu(self.MenuBar)
         self.HelpMenu.setObjectName(u'HelpMenu')
         mainWindow.setMenuBar(self.MenuBar)
-        self.StatusBar = QtGui.QStatusBar(mainWindow)
-        self.StatusBar.setObjectName(u'StatusBar')
-        mainWindow.setStatusBar(self.StatusBar)
-        self.DefaultThemeLabel = QtGui.QLabel(self.StatusBar)
-        self.DefaultThemeLabel.setObjectName(u'DefaultThemeLabel')
-        self.StatusBar.addPermanentWidget(self.DefaultThemeLabel)
+        self.statusBar = QtGui.QStatusBar(mainWindow)
+        self.statusBar.setObjectName(u'statusBar')
+        mainWindow.setStatusBar(self.statusBar)
+        self.loadProgressBar = QtGui.QProgressBar(self.statusBar)
+        self.loadProgressBar.setObjectName(u'loadProgressBar')
+        self.statusBar.addPermanentWidget(self.loadProgressBar)
+        self.loadProgressBar.hide()
+        self.loadProgressBar.setValue(0)
+        self.defaultThemeLabel = QtGui.QLabel(self.statusBar)
+        self.defaultThemeLabel.setObjectName(u'defaultThemeLabel')
+        self.statusBar.addPermanentWidget(self.defaultThemeLabel)
         # Create the MediaManager
         self.mediaManagerDock = OpenLPDockWidget(mainWindow,
             u'mediaManagerDock', u':/system/system_mediamanager.png')
@@ -545,9 +550,9 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
             QtCore.SIGNAL(u'openlp_information_message'),
             self.onInformationMessage)
         # warning cyclic dependency
-        # RenderManager needs to call ThemeManager and
-        # ThemeManager needs to call RenderManager
-        self.renderManager = RenderManager(
+        # renderer needs to call ThemeManager and
+        # ThemeManager needs to call Renderer
+        self.renderer = Renderer(
             self.themeManagerContents, self.screens)
         # Define the media Dock Manager
         self.mediaDockManager = MediaDockManager(self.MediaToolBox)
@@ -555,7 +560,7 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         # make the controllers available to the plugins
         self.pluginHelpers[u'preview'] = self.previewController
         self.pluginHelpers[u'live'] = self.liveController
-        self.pluginHelpers[u'render'] = self.renderManager
+        self.pluginHelpers[u'renderer'] = self.renderer
         self.pluginHelpers[u'service'] = self.ServiceManagerContents
         self.pluginHelpers[u'settings form'] = self.settingsForm
         self.pluginHelpers[u'toolbox'] = self.mediaDockManager
@@ -781,7 +786,7 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         their locations
         """
         log.debug(u'screenChanged')
-        self.renderManager.update_display()
+        self.renderer.update_display()
         self.setFocus()
         self.activateWindow()
 
@@ -880,10 +885,10 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         self.setWindowTitle(title)
 
     def showStatusMessage(self, message):
-        self.StatusBar.showMessage(message)
+        self.statusBar.showMessage(message)
 
     def defaultThemeChanged(self, theme):
-        self.DefaultThemeLabel.setText(
+        self.defaultThemeLabel.setText(
             unicode(translate('OpenLP.MainWindow', 'Default Theme: %s')) %
                 theme)
 
@@ -979,7 +984,7 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
             for fileId, filename in enumerate(recentFilesToDisplay):
                 log.debug('Recent file name: %s', filename)
                 action =  base_action(self, u'')
-                action.setText(u'&%d %s' % 
+                action.setText(u'&%d %s' %
                     (fileId + 1, QtCore.QFileInfo(filename).fileName()))
                 action.setData(QtCore.QVariant(filename))
                 self.connect(action, QtCore.SIGNAL(u'triggered()'),
@@ -1008,3 +1013,34 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
             while self.recentFiles.count() > maxRecentFiles:
                 # Don't care what API says takeLast works, removeLast doesn't!
                 self.recentFiles.takeLast()
+
+    def displayProgressBar(self, size):
+        """
+        Make Progress bar visible and set size
+        """
+        self.loadProgressBar.show()
+        self.loadProgressBar.setMaximum(size)
+        self.loadProgressBar.setValue(0)
+        Receiver.send_message(u'openlp_process_events')
+
+    def incrementProgressBar(self):
+        """
+        Increase the Progress Bar value by 1
+        """
+        self.loadProgressBar.setValue(self.loadProgressBar.value() + 1)
+        Receiver.send_message(u'openlp_process_events')
+
+    def finishedProgressBar(self):
+        """
+        Trigger it's removal after 2.5 second
+        """
+        self.timer_id = self.startTimer(2500)
+
+    def timerEvent(self, event):
+        """
+        Remove the Progress bar from view.
+        """
+        if event.timerId() == self.timer_id:
+            self.timer_id = 0
+            self.loadProgressBar.hide()
+            Receiver.send_message(u'openlp_process_events')

openlp/core/ui/printserviceform.py

@@ -46,41 +46,58 @@ http://doc.trolltech.com/4.7/richtext-html-subset.html#css-properties
    color:black;
 }
 
+.item {
+   color:black;
+}
+
 .itemTitle {
    font-weight:600;
    font-size:large;
-   color:black;
 }
 
-.itemText {
-   color:black;
-}
+.itemText {}
 
 .itemFooter {
    font-size:8px;
-   color:black;
 }
 
+.itemNotes {}
+
 .itemNotesTitle {
    font-weight:bold;
    font-size:12px;
-   color:black;
 }
 
 .itemNotesText {
    font-size:11px;
-   color:black;
+}
+
+.media {}
+
+.mediaTitle {
+    font-weight:bold;
+    font-size:11px;
+}
+
+.mediaText {}
+
+.imageList {}
+
+.customNotes {
+   margin-top: 10px;
 }
 
 .customNotesTitle {
    font-weight:bold;
    font-size:11px;
-   color:black;
 }
 
 .customNotesText {
    font-size:11px;
-   color:black;
+}
+
+.newPage {
+    page-break-before:always;
 }
 """
 
@@ -153,86 +170,90 @@ class PrintServiceForm(QtGui.QDialog, Ui_PrintServiceDialog):
         """
         Creates the html text and updates the html of *self.document*.
         """
-        html_data = html.fromstring(
-            u'<title>%s</title>' % unicode(self.titleLineEdit.text()))
+        html_data = self._addElement(u'html')
+        self._addElement(u'head', parent=html_data)
+        self._addElement(u'title', unicode(self.titleLineEdit.text()),
+            html_data.head)
         css_path = os.path.join(
-            AppLocation.get_data_path(), u'servicePrint.css')
-        if not os.path.isfile(css_path):
-            # Create default css file.
-            css_file = open(css_path, u'w')
-            css_file.write(DEFAULT_CSS)
-            css_file.close()
+            AppLocation.get_data_path(), u'service_print.css')
         custom_css = get_text_file_string(css_path)
-        self._addChildToParent(
-            u'style', custom_css, html_data.head, u'type', u'text/css')
-        self._addChildToParent(u'body', parent=html_data)
-        self._addChildToParent(u'span', unicode(self.titleLineEdit.text()),
-            html_data.body, u'class', u'serviceTitle')
+        if not custom_css:
+            custom_css = DEFAULT_CSS
+        self._addElement(u'style', custom_css, html_data.head,
+            attribute=(u'type', u'text/css'))
+        self._addElement(u'body', parent=html_data)
+        self._addElement(u'h1', unicode(self.titleLineEdit.text()),
+            html_data.body, classId=u'serviceTitle')
         for index, item in enumerate(self.serviceManager.serviceItems):
-            item = item[u'service_item']
-            div = self._addChildToParent(u'div', parent=html_data.body)
-            # Add the title of the service item.
-            item_title = self._addChildToParent(
-                u'h2', parent=div, attribute=u'class', value=u'itemTitle')
-            self._addChildToParent(
-                u'img', parent=item_title, attribute=u'src', value=item.icon)
-            self._fromstring(
-                u'<span> %s</span>' % item.get_display_title(), item_title)
-            if self.slideTextCheckBox.isChecked():
-                # Add the text of the service item.
-                if item.is_text():
-                    verse_def = None
-                    for slide in item.get_frames():
-                        if not verse_def or verse_def != slide[u'verseTag']:
-                            p = self._addChildToParent(u'p', parent=div,
-                                attribute=u'class', value=u'itemText')
-                        else:
-                            self._addChildToParent(u'br', parent=p)
-                        self._fromstring(u'<span>%s</span>' % slide[u'html'], p)
-                        verse_def = slide[u'verseTag']
-                    # Break the page before the div element.
-                    if index != 0 and self.pageBreakAfterText.isChecked():
-                        div.set(u'style', u'page-break-before:always')
-                # Add the image names of the service item.
-                elif item.is_image():
-                    ol = self._addChildToParent(u'ol', parent=div)
-                    for slide in range(len(item.get_frames())):
-                        self._addChildToParent(u'li', item.get_frame_title(slide), ol)
-                # add footer
-                if item.foot_text:
-                    self._fromstring(
-                        item.foot_text, div, u'class', u'itemFooter')
-            # Add service items' notes.
-            if self.notesCheckBox.isChecked():
-                if item.notes:
-                    p = self._addChildToParent(u'p', parent=div)
-                    self._addChildToParent(u'span', unicode(
-                        translate('OpenLP.ServiceManager', 'Notes:')), p,
-                        u'class', u'itemNotesTitle')
-                    self._fromstring(u'<span> %s</span>' % item.notes.replace(
-                        u'\n', u'<br />'), p, u'class', u'itemNotesText')
-            # Add play length of media files.
-            if item.is_media() and self.metaDataCheckBox.isChecked():
-                tme = item.media_length
-                if item.end_time > 0:
-                    tme = item.end_time - item.start_time
-                title = self._fromstring(u'<p><strong>%s</strong> </p>' %
-                    translate('OpenLP.ServiceManager', 'Playing time:'), div)
-                self._fromstring(u'<span>%s</span>' %
-                    unicode(datetime.timedelta(seconds=tme)), title)
+            self._addPreviewItem(html_data.body, item[u'service_item'], index)
         # Add the custom service notes:
         if self.footerTextEdit.toPlainText():
-            div = self._addChildToParent(u'div', parent=html_data.body)
-            self._addChildToParent(u'span', translate('OpenLP.ServiceManager',
-                u'Custom Service Notes:'), div, u'class', u'customNotesTitle')
-            self._addChildToParent(
-                u'span', u' %s' % self.footerTextEdit.toPlainText(), div,
-                u'class', u'customNotesText')
+            div = self._addElement(u'div', parent=html_data.body,
+                classId=u'customNotes')
+            self._addElement(u'span', translate('OpenLP.ServiceManager',
+                'Custom Service Notes: '), div, classId=u'customNotesTitle')
+            self._addElement(u'span', self.footerTextEdit.toPlainText(), div,
+                classId=u'customNotesText')
         self.document.setHtml(html.tostring(html_data))
         self.previewWidget.updatePreview()
 
-    def _addChildToParent(self, tag, text=None, parent=None, attribute=None,
-        value=None):
+    def _addPreviewItem(self, body, item, index):
+        div = self._addElement(u'div', classId=u'item', parent=body)
+        # Add the title of the service item.
+        item_title = self._addElement(u'h2', parent=div, classId=u'itemTitle')
+        self._addElement(u'img', parent=item_title,
+            attribute=(u'src', item.icon))
+        self._addElement(u'span', u'&nbsp;' + item.get_display_title(),
+            item_title)
+        if self.slideTextCheckBox.isChecked():
+            # Add the text of the service item.
+            if item.is_text():
+                verse_def = None
+                for slide in item.get_frames():
+                    if not verse_def or verse_def != slide[u'verseTag']:
+                        p = self._addElement(u'div', parent=div,
+                            classId=u'itemText')
+                    else:
+                        self._addElement(u'br', parent=p)
+                    self._addElement(u'p', slide[u'html'], p)
+                    verse_def = slide[u'verseTag']
+                # Break the page before the div element.
+                if index != 0 and self.pageBreakAfterText.isChecked():
+                    div.set(u'class', u'item newPage')
+            # Add the image names of the service item.
+            elif item.is_image():
+                ol = self._addElement(u'ol', parent=div, classId=u'imageList')
+                for slide in range(len(item.get_frames())):
+                    self._addElement(u'li', item.get_frame_title(slide), ol)
+            # add footer
+            foot_text = item.foot_text
+            foot_text = foot_text.partition(u'<br>')[2]
+            if foot_text:
+                foot = self._addElement(u'div', foot_text, parent=div,
+                    classId=u'itemFooter')
+        # Add service items' notes.
+        if self.notesCheckBox.isChecked():
+            if item.notes:
+                p = self._addElement(u'div', classId=u'itemNotes', parent=div)
+                self._addElement(u'span',
+                    translate('OpenLP.ServiceManager', 'Notes: '), p,
+                    classId=u'itemNotesTitle')
+                notes = self._addElement(u'span',
+                    item.notes.replace(u'\n', u'<br />'), p,
+                    classId=u'itemNotesText')
+        # Add play length of media files.
+        if item.is_media() and self.metaDataCheckBox.isChecked():
+            tme = item.media_length
+            if item.end_time > 0:
+                tme = item.end_time - item.start_time
+            title = self._addElement(u'div', classId=u'media', parent=div)
+            self._addElement(u'span', translate('OpenLP.ServiceManager',
+                'Playing time: '), title, classId=u'mediaTitle')
+            self._addElement(u'span', unicode(datetime.timedelta(seconds=tme)),
+                title, classId=u'mediaText')
+
+    def _addElement(self, tag, text=None, parent=None, classId=None,
+        attribute=None):
         """
         Creates a html element. If ``text`` is given, the element's text will
         set and if a ``parent`` is given, the element is appended.
@@ -246,30 +267,22 @@ class PrintServiceForm(QtGui.QDialog, Ui_PrintServiceDialog):
         ``parent``
             The parent element. Defaults to ``None``.
 
-        ``attribute``
-            An optional attribute, for instance ``u'class``.
+        ``classId``
+            Value for the class attribute
 
-        ``value``
-            The value for the given ``attribute``. It does not have a meaning,
-            if the attribute is left to its default.
+        ``attribute``
+            Tuple name/value pair to add as an optional attribute
         """
-        element = html.Element(tag)
         if text is not None:
-            element.text = unicode(text)
+            element = html.fragment_fromstring(unicode(text), create_parent=tag)
+        else:
+            element = html.Element(tag)
         if parent is not None:
             parent.append(element)
+        if classId is not None:
+            element.set(u'class', classId)
         if attribute is not None:
-            element.set(attribute, value if value is not None else u'')
-        return element
-
-    def _fromstring(self, string, parent, attribute=None, value=None):
-        """
-        This is used to create a child html element from a string.
-        """
-        element = html.fromstring(string)
-        if attribute is not None:
-            element.set(attribute, value if value is not None else u'')
-        parent.append(element)
+            element.set(attribute[0], attribute[1])
         return element
 
     def paintRequested(self, printer):
@@ -380,4 +393,4 @@ class PrintServiceForm(QtGui.QDialog, Ui_PrintServiceDialog):
             QtCore.QVariant(self.metaDataCheckBox.isChecked()))
         settings.setValue(u'print notes',
             QtCore.QVariant(self.notesCheckBox.isChecked()))
-        settings.endGroup()
+        settings.endGroup()

openlp/core/ui/servicemanager.py

@@ -460,7 +460,11 @@ class ServiceManager(QtGui.QWidget):
         service = []
         write_list = []
         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()})
             if not item[u'service_item'].uses_file():
@@ -501,6 +505,7 @@ class ServiceManager(QtGui.QWidget):
         log.debug(u'ServiceManager.saveFile - allowZip64 is %s' % allow_zip_64)
         zip = None
         success = True
+        self.mainwindow.incrementProgressBar()
         try:
             zip = zipfile.ZipFile(path_file_name, 'w', zipfile.ZIP_STORED,
                 allow_zip_64)
@@ -516,6 +521,8 @@ class ServiceManager(QtGui.QWidget):
         finally:
             if zip:
                 zip.close()
+        self.mainwindow.finishedProgressBar()
+        Receiver.send_message(u'cursor_normal')
         if success:
             self.mainwindow.addRecentFile(path_file_name)
             self.setModified(False)
@@ -576,13 +583,15 @@ class ServiceManager(QtGui.QWidget):
                 items = cPickle.load(fileTo)
                 fileTo.close()
                 self.newFile()
+                self.mainwindow.displayProgressBar(len(items))
                 for item in items:
+                    self.mainwindow.incrementProgressBar()
                     serviceItem = ServiceItem()
                     serviceItem.from_service = True
-                    serviceItem.render_manager = self.mainwindow.renderManager
+                    serviceItem.renderer = self.mainwindow.renderer
                     serviceItem.set_from_service(item, self.servicePath)
                     self.validateItem(serviceItem)
-                    self.addServiceItem(serviceItem)
+                    self.addServiceItem(serviceItem, repaint=False)
                     if serviceItem.is_capable(ItemCapabilities.OnLoadUpdate):
                         Receiver.send_message(u'%s_service_load' %
                             serviceItem.name.lower(), serviceItem)
@@ -592,7 +601,6 @@ class ServiceManager(QtGui.QWidget):
                 self.setModified(False)
                 QtCore.QSettings().setValue(
                     'service/last file', QtCore.QVariant(fileName))
-                Receiver.send_message(u'cursor_normal')
             else:
                 critical_error_message_box(
                     message=translate('OpenLP.ServiceManager',
@@ -623,6 +631,9 @@ class ServiceManager(QtGui.QWidget):
                 fileTo.close()
             if zip:
                 zip.close()
+        self.mainwindow.finishedProgressBar()
+        Receiver.send_message(u'cursor_normal')
+        self.repaintServiceList(-1, -1)
 
     def loadLastFile(self):
         """
@@ -665,17 +676,17 @@ class ServiceManager(QtGui.QWidget):
         action = self.menu.exec_(self.serviceManagerList.mapToGlobal(point))
         if action == self.editAction:
             self.remoteEdit()
-        if action == self.maintainAction:
+        elif action == self.maintainAction:
             self.onServiceItemEditForm()
-        if action == self.deleteAction:
+        elif action == self.deleteAction:
             self.onDeleteFromService()
-        if action == self.notesAction:
+        elif action == self.notesAction:
             self.onServiceItemNoteForm()
-        if action == self.timeAction:
+        elif action == self.timeAction:
             self.onStartTimeForm()
-        if action == self.previewAction:
+        elif action == self.previewAction:
             self.makePreview()
-        if action == self.liveAction:
+        elif action == self.liveAction:
             self.makeLive()
 
     def onServiceItemNoteForm(self):
@@ -686,6 +697,7 @@ class ServiceManager(QtGui.QWidget):
             self.serviceItems[item][u'service_item'].notes = \
                 self.serviceNoteForm.textEdit.toPlainText()
             self.repaintServiceList(item, -1)
+            self.setModified()
 
     def onStartTimeForm(self):
         item = self.findServiceItem()[0]
@@ -789,7 +801,7 @@ class ServiceManager(QtGui.QWidget):
         # Top Item was selected so set the last one
         if setLastItem:
             lastItem.setSelected(True)
-        self.setModified(True)
+        self.setModified()
 
     def onMoveSelectionDown(self):
         """
@@ -811,7 +823,7 @@ class ServiceManager(QtGui.QWidget):
             serviceIterator += 1
         if setSelected:
             firstItem.setSelected(True)
-        self.setModified(True)
+        self.setModified()
 
     def onCollapseAll(self):
         """
@@ -855,7 +867,7 @@ class ServiceManager(QtGui.QWidget):
             self.serviceItems.remove(self.serviceItems[item])
             self.serviceItems.insert(0, temp)
             self.repaintServiceList(0, child)
-        self.setModified(True)
+        self.setModified()
 
     def onServiceUp(self):
         """
@@ -867,7 +879,7 @@ class ServiceManager(QtGui.QWidget):
             self.serviceItems.remove(self.serviceItems[item])
             self.serviceItems.insert(item - 1, temp)
             self.repaintServiceList(item - 1, child)
-        self.setModified(True)
+        self.setModified()
 
     def onServiceDown(self):
         """
@@ -879,7 +891,7 @@ class ServiceManager(QtGui.QWidget):
             self.serviceItems.remove(self.serviceItems[item])
             self.serviceItems.insert(item + 1, temp)
             self.repaintServiceList(item + 1, child)
-        self.setModified(True)
+        self.setModified()
 
     def onServiceEnd(self):
         """
@@ -891,7 +903,7 @@ class ServiceManager(QtGui.QWidget):
             self.serviceItems.remove(self.serviceItems[item])
             self.serviceItems.insert(len(self.serviceItems), temp)
             self.repaintServiceList(len(self.serviceItems) - 1, child)
-        self.setModified(True)
+        self.setModified()
 
     def onDeleteFromService(self):
         """
@@ -901,7 +913,7 @@ class ServiceManager(QtGui.QWidget):
         if item != -1:
             self.serviceItems.remove(self.serviceItems[item])
             self.repaintServiceList(item - 1, -1)
-        self.setModified(True)
+        self.setModified()
 
     def repaintServiceList(self, serviceItem, serviceItemChild):
         """
@@ -988,7 +1000,7 @@ class ServiceManager(QtGui.QWidget):
         """
         log.debug(u'onThemeComboBoxSelected')
         self.service_theme = unicode(self.themeComboBox.currentText())
-        self.mainwindow.renderManager.set_service_theme(self.service_theme)
+        self.mainwindow.renderer.set_service_theme(self.service_theme)
         QtCore.QSettings().setValue(
             self.mainwindow.serviceSettingsSection + u'/service theme',
             QtCore.QVariant(self.service_theme))
@@ -1000,7 +1012,7 @@ class ServiceManager(QtGui.QWidget):
         sure the theme combo box is in the correct state.
         """
         log.debug(u'themeChange')
-        if self.mainwindow.renderManager.theme_level == ThemeLevel.Global:
+        if self.mainwindow.renderer.theme_level == ThemeLevel.Global:
             self.toolbar.actions[u'ThemeLabel'].setVisible(False)
             self.toolbar.actions[u'ThemeWidget'].setVisible(False)
         else:
@@ -1015,7 +1027,7 @@ class ServiceManager(QtGui.QWidget):
         Receiver.send_message(u'cursor_busy')
         log.debug(u'regenerateServiceItems')
         # force reset of renderer as theme data has changed
-        self.mainwindow.renderManager.themedata = None
+        self.mainwindow.renderer.themedata = None
         if self.serviceItems:
             tempServiceItems = self.serviceItems
             self.serviceManagerList.clear()
@@ -1026,7 +1038,7 @@ class ServiceManager(QtGui.QWidget):
                     item[u'service_item'], False, expand=item[u'expanded'])
             # Set to False as items may have changed rendering
             # does not impact the saved song so True may also be valid
-            self.setModified(True)
+            self.setModified()
         Receiver.send_message(u'cursor_normal')
 
     def serviceItemUpdate(self, message):
@@ -1037,7 +1049,7 @@ class ServiceManager(QtGui.QWidget):
         for item in self.serviceItems:
             if item[u'service_item']._uuid == uuid:
                 item[u'service_item'].edit_id = int(editId)
-        self.setModified(True)
+        self.setModified()
 
     def replaceServiceItem(self, newItem):
         """
@@ -1053,9 +1065,10 @@ class ServiceManager(QtGui.QWidget):
                 self.repaintServiceList(itemcount + 1, 0)
                 self.mainwindow.liveController.replaceServiceManagerItem(
                     newItem)
-        self.setModified(True)
+        self.setModified()
 
-    def addServiceItem(self, item, rebuild=False, expand=None, replace=False):
+    def addServiceItem(self, item, rebuild=False, expand=None, replace=False,
+        repaint=True):
         """
         Add a Service item to the list
 
@@ -1088,7 +1101,8 @@ class ServiceManager(QtGui.QWidget):
                     self.serviceItems.append({u'service_item': item,
                         u'order': len(self.serviceItems) + 1,
                         u'expanded': expand})
-                self.repaintServiceList(len(self.serviceItems) - 1, -1)
+                if repaint:
+                    self.repaintServiceList(len(self.serviceItems) - 1, -1)
             else:
                 self.serviceItems.insert(self.dropPosition,
                     {u'service_item': item, u'order': self.dropPosition,
@@ -1098,7 +1112,7 @@ class ServiceManager(QtGui.QWidget):
             if rebuild:
                 self.mainwindow.liveController.replaceServiceManagerItem(item)
         self.dropPosition = 0
-        self.setModified(True)
+        self.setModified()
 
     def makePreview(self):
         """
@@ -1235,7 +1249,7 @@ class ServiceManager(QtGui.QWidget):
                 self.serviceItems.remove(serviceItem)
                 self.serviceItems.insert(endpos, serviceItem)
                 self.repaintServiceList(endpos, child)
-                self.setModified(True)
+                self.setModified()
             else:
                 # we are not over anything so drop
                 replace = False
@@ -1277,7 +1291,7 @@ class ServiceManager(QtGui.QWidget):
                 self.onThemeChangeAction, context=QtCore.Qt.WidgetShortcut)
             self.themeMenu.addAction(action)
         find_and_set_in_combo_box(self.themeComboBox, self.service_theme)
-        self.mainwindow.renderManager.set_service_theme(self.service_theme)
+        self.mainwindow.renderer.set_service_theme(self.service_theme)
         self.regenerateServiceItems()
 
     def onThemeChangeAction(self):

openlp/core/ui/shortcutlistdialog.py

@@ -28,6 +28,24 @@ from PyQt4 import QtCore, QtGui
 
 from openlp.core.lib import translate, build_icon
 
+class CaptureShortcutButton(QtGui.QPushButton):
+    """
+    A class to encapsulate a ``QPushButton``.
+    """
+    def __init__(self, *args):
+        QtGui.QPushButton.__init__(self, *args)
+        self.setCheckable(True)
+
+    def keyPressEvent(self, event):
+        """
+        Block the ``Key_Space`` key, so that the button will not change the
+        checked state.
+        """
+        if event.key() == QtCore.Qt.Key_Space and self.isChecked():
+            # Ignore the event, so that the parent can take care of this.
+            event.ignore()
+
+
 class Ui_ShortcutListDialog(object):
     def setupUi(self, shortcutListDialog):
         shortcutListDialog.setObjectName(u'shortcutListDialog')
@@ -56,12 +74,11 @@ class Ui_ShortcutListDialog(object):
         self.detailsLayout.addWidget(self.customRadioButton, 1, 0, 1, 1)
         self.primaryLayout = QtGui.QHBoxLayout()
         self.primaryLayout.setObjectName(u'primaryLayout')
-        self.primaryPushButton = QtGui.QPushButton(shortcutListDialog)
+        self.primaryPushButton = CaptureShortcutButton(shortcutListDialog)
         self.primaryPushButton.setObjectName(u'primaryPushButton')
         self.primaryPushButton.setMinimumSize(QtCore.QSize(84, 0))
         self.primaryPushButton.setIcon(
             build_icon(u':/system/system_configure_shortcuts.png'))
-        self.primaryPushButton.setCheckable(True)
         self.primaryLayout.addWidget(self.primaryPushButton)
         self.clearPrimaryButton = QtGui.QToolButton(shortcutListDialog)
         self.clearPrimaryButton.setObjectName(u'clearPrimaryButton')
@@ -72,9 +89,8 @@ class Ui_ShortcutListDialog(object):
         self.detailsLayout.addLayout(self.primaryLayout, 1, 1, 1, 1)
         self.alternateLayout = QtGui.QHBoxLayout()
         self.alternateLayout.setObjectName(u'alternateLayout')
-        self.alternatePushButton = QtGui.QPushButton(shortcutListDialog)
+        self.alternatePushButton = CaptureShortcutButton(shortcutListDialog)
         self.alternatePushButton.setObjectName(u'alternatePushButton')
-        self.alternatePushButton.setCheckable(True)
         self.alternatePushButton.setIcon(
             build_icon(u':/system/system_configure_shortcuts.png'))
         self.alternateLayout.addWidget(self.alternatePushButton)

openlp/core/ui/shortcutlistform.py

@@ -71,7 +71,9 @@ class ShortcutListForm(QtGui.QDialog, Ui_ShortcutListDialog):
             QtCore.SIGNAL(u'clicked(bool)'), self.onCustomRadioButtonClicked)
 
     def keyPressEvent(self, event):
-        if self.primaryPushButton.isChecked() or \
+        if event.key() == QtCore.Qt.Key_Space:
+            self.keyReleaseEvent(event)
+        elif self.primaryPushButton.isChecked() or \
             self.alternatePushButton.isChecked():
             event.ignore()
         elif event.key() == QtCore.Qt.Key_Escape:
@@ -163,6 +165,7 @@ class ShortcutListForm(QtGui.QDialog, Ui_ShortcutListDialog):
         self.customRadioButton.setChecked(True)
         if toggled:
             self.alternatePushButton.setChecked(False)
+            self.primaryPushButton.setText(u'')
             return
         action = self._currentItemAction()
         if action is None:
@@ -181,6 +184,7 @@ class ShortcutListForm(QtGui.QDialog, Ui_ShortcutListDialog):
         self.customRadioButton.setChecked(True)
         if toggled:
             self.primaryPushButton.setChecked(False)
+            self.alternatePushButton.setText(u'')
             return
         action = self._currentItemAction()
         if action is None:
@@ -211,10 +215,11 @@ class ShortcutListForm(QtGui.QDialog, Ui_ShortcutListDialog):
         self.primaryPushButton.setChecked(column in [0, 1])
         self.alternatePushButton.setChecked(column not in [0, 1])
         if column in [0, 1]:
+            self.primaryPushButton.setText(u'')
             self.primaryPushButton.setFocus(QtCore.Qt.OtherFocusReason)
         else:
+            self.alternatePushButton.setText(u'')
             self.alternatePushButton.setFocus(QtCore.Qt.OtherFocusReason)
-        self.onCurrentItemChanged(item)
 
     def onCurrentItemChanged(self, item=None, previousItem=None):
         """
@@ -247,6 +252,12 @@ class ShortcutListForm(QtGui.QDialog, Ui_ShortcutListDialog):
             elif len(shortcuts) == 2:
                 primary_text = shortcuts[0].toString()
                 alternate_text = shortcuts[1].toString()
+        # When we are capturing a new shortcut, we do not want, the buttons to
+        # display the current shortcut.
+        if self.primaryPushButton.isChecked():
+            primary_text = u''
+        if self.alternatePushButton.isChecked():
+            alternate_text = u''
         self.primaryPushButton.setText(primary_text)
         self.alternatePushButton.setText(alternate_text)
         self.primaryLabel.setText(primary_label_text)

openlp/core/ui/slidecontroller.py

@@ -180,16 +180,25 @@ class SlideController(QtGui.QWidget):
             self.hideMenu.menu().addAction(self.themeScreen)
             self.hideMenu.menu().addAction(self.desktopScreen)
             self.toolbar.addToolbarSeparator(u'Loop Separator')
-            self.toolbar.addToolbarButton(
+            startLoop = self.toolbar.addToolbarButton(
                 # Does not need translating - control string.
                 u'Start Loop', u':/media/media_time.png',
                 translate('OpenLP.SlideController', 'Start continuous loop'),
                 self.onStartLoop)
-            self.toolbar.addToolbarButton(
+            action_list = ActionList.get_instance()
+            action_list.add_action(startLoop, UiStrings().LiveToolbar)
+            stopLoop = self.toolbar.addToolbarButton(
                 # Does not need translating - control string.
                 u'Stop Loop', u':/media/media_stop.png',
                 translate('OpenLP.SlideController', 'Stop continuous loop'),
                 self.onStopLoop)
+            action_list.add_action(stopLoop, UiStrings().LiveToolbar)
+            self.toogleLoop = shortcut_action(self, u'toogleLoop',
+                [QtGui.QKeySequence(u'L')], self.onToggleLoop,
+                category=UiStrings().LiveToolbar)
+            self.toogleLoop.setText(translate('OpenLP.SlideController',
+                'Start/Stop continuous loop'))
+            self.addAction(self.toogleLoop)
             self.delaySpinBox = QtGui.QSpinBox()
             self.delaySpinBox.setMinimum(1)
             self.delaySpinBox.setMaximum(180)
@@ -268,15 +277,16 @@ class SlideController(QtGui.QWidget):
         self.slideLayout.setSpacing(0)
         self.slideLayout.setMargin(0)
         self.slideLayout.setObjectName(u'SlideLayout')
-        self.mediaObject = Phonon.MediaObject(self)
-        self.video = Phonon.VideoWidget()
-        self.video.setVisible(False)
-        self.audio = Phonon.AudioOutput(Phonon.VideoCategory, self.mediaObject)
-        Phonon.createPath(self.mediaObject, self.video)
-        Phonon.createPath(self.mediaObject, self.audio)
         if not self.isLive:
+            self.mediaObject = Phonon.MediaObject(self)
+            self.video = Phonon.VideoWidget()
+            self.video.setVisible(False)
+            self.audio = Phonon.AudioOutput(Phonon.VideoCategory,
+                self.mediaObject)
+            Phonon.createPath(self.mediaObject, self.video)
+            Phonon.createPath(self.mediaObject, self.audio)
             self.video.setGeometry(QtCore.QRect(0, 0, 300, 225))
-        self.slideLayout.insertWidget(0, self.video)
+            self.slideLayout.insertWidget(0, self.video)
         # Actual preview screen
         self.slidePreview = QtGui.QLabel(self)
         sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
@@ -380,18 +390,21 @@ class SlideController(QtGui.QWidget):
         action_list.add_action(self.previousItem)
         action_list.add_action(self.nextItem)
         self.previousService = shortcut_action(parent, u'previousService',
-            [QtCore.Qt.Key_Left], self.servicePrevious, UiStrings().LiveToolbar)
-        self.previousService.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
+            [QtCore.Qt.Key_Left], self.servicePrevious,
+            category=UiStrings().LiveToolbar,
+            context=QtCore.Qt.WidgetWithChildrenShortcut)
         self.previousService.setText(
             translate('OpenLP.SlideController', 'Previous Service'))
         self.nextService = shortcut_action(parent, 'nextService',
-            [QtCore.Qt.Key_Right], self.serviceNext, UiStrings().LiveToolbar)
-        self.nextService.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
+            [QtCore.Qt.Key_Right], self.serviceNext,
+            category=UiStrings().LiveToolbar,
+            context=QtCore.Qt.WidgetWithChildrenShortcut)
         self.nextService.setText(
             translate('OpenLP.SlideController', 'Next Service'))
         self.escapeItem = shortcut_action(parent, 'escapeItem',
-            [QtCore.Qt.Key_Escape], self.liveEscape, UiStrings().LiveToolbar)
-        self.escapeItem.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
+            [QtCore.Qt.Key_Escape], self.liveEscape,
+            category=UiStrings().LiveToolbar,
+            context=QtCore.Qt.WidgetWithChildrenShortcut)
         self.escapeItem.setText(
             translate('OpenLP.SlideController', 'Escape Item'))
 
@@ -412,7 +425,7 @@ class SlideController(QtGui.QWidget):
         """
         # rebuild display as screen size changed
         self.display = MainDisplay(self, self.screens, self.isLive)
-        self.display.imageManager = self.parent.renderManager.image_manager
+        self.display.imageManager = self.parent.renderer.image_manager
         self.display.alertTab = self.alertTab
         self.display.setup()
         if self.isLive:
@@ -491,6 +504,9 @@ class SlideController(QtGui.QWidget):
         self.mediabar.setVisible(False)
         self.toolbar.makeWidgetsInvisible([u'Song Menu'])
         self.toolbar.makeWidgetsInvisible(self.loopList)
+        self.toogleLoop.setEnabled(False)
+        self.toolbar.actions[u'Start Loop'].setEnabled(False)
+        self.toolbar.actions[u'Stop Loop'].setEnabled(False)
         self.toolbar.actions[u'Stop Loop'].setVisible(False)
         if item.is_text():
             if QtCore.QSettings().value(
@@ -500,6 +516,9 @@ class SlideController(QtGui.QWidget):
         if item.is_capable(ItemCapabilities.AllowsLoop) and \
             len(item.get_frames()) > 1:
             self.toolbar.makeWidgetsVisible(self.loopList)
+            self.toogleLoop.setEnabled(True)
+            self.toolbar.actions[u'Start Loop'].setEnabled(True)
+            self.toolbar.actions[u'Stop Loop'].setEnabled(True)
         if item.is_media():
             self.toolbar.setVisible(False)
             self.mediabar.setVisible(True)
@@ -614,19 +633,19 @@ class SlideController(QtGui.QWidget):
                 label.setScaledContents(True)
                 if self.serviceItem.is_command():
                     image = resize_image(frame[u'image'],
-                        self.parent.renderManager.width,
-                        self.parent.renderManager.height)
+                        self.parent.renderer.width,
+                        self.parent.renderer.height)
                 else:
                     # If current slide set background to image
                     if framenumber == slideno:
                         self.serviceItem.bg_image_bytes = \
-                            self.parent.renderManager.image_manager. \
+                            self.parent.renderer.image_manager. \
                             get_image_bytes(frame[u'title'])
-                    image = self.parent.renderManager.image_manager. \
+                    image = self.parent.renderer.image_manager. \
                         get_image(frame[u'title'])
                 label.setPixmap(QtGui.QPixmap.fromImage(image))
                 self.previewListWidget.setCellWidget(framenumber, 0, label)
-                slideHeight = width * self.parent.renderManager.screen_ratio
+                slideHeight = width * self.parent.renderer.screen_ratio
                 row += 1
             text.append(unicode(row))
             self.previewListWidget.setItem(framenumber, 0, item)
@@ -992,6 +1011,15 @@ class SlideController(QtGui.QWidget):
                         self.previewListWidget.rowCount() - 1)
             self.slideSelected()
 
+    def onToggleLoop(self, toggled):
+        """
+        Toggles the loop state.
+        """
+        if self.toolbar.actions[u'Start Loop'].isVisible():
+            self.onStartLoop()
+        else:
+            self.onStopLoop()
+
     def onStartLoop(self):
         """
         Start the timer loop running and store the timer id
@@ -1150,4 +1178,4 @@ class SlideController(QtGui.QWidget):
         elif self.desktopScreen.isChecked():
             return HideMode.Screen
         else:
-            return None
+            return None

openlp/core/ui/themeform.py

@@ -56,6 +56,7 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
         self.setupUi(self)
         self.registerFields()
         self.updateThemeAllowed = True
+        self.temp_background_filename = u''
         QtCore.QObject.connect(self.backgroundComboBox,
             QtCore.SIGNAL(u'currentIndexChanged(int)'),
             self.onBackgroundComboBoxCurrentIndexChanged)
@@ -279,6 +280,7 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
         Run the wizard.
         """
         log.debug(u'Editing theme %s' % self.theme.theme_name)
+        self.temp_background_filename = u''
         self.updateThemeAllowed = False
         self.setDefaults()
         self.updateThemeAllowed = True
@@ -432,6 +434,16 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
         # do not allow updates when screen is building for the first time.
         if self.updateThemeAllowed:
             self.theme.background_type = BackgroundType.to_string(index)
+            if self.theme.background_type != \
+                BackgroundType.to_string(BackgroundType.Image) and \
+                self.temp_background_filename == u'':
+                self.temp_background_filename = self.theme.background_filename
+                self.theme.background_filename = u''
+            if self.theme.background_type == \
+                BackgroundType.to_string(BackgroundType.Image) and \
+                self.temp_background_filename != u'':
+                self.theme.background_filename = self.temp_background_filename
+                self.temp_background_filename = u''
             self.setBackgroundPageValues()
 
     def onGradientComboBoxCurrentIndexChanged(self, index):
@@ -589,4 +601,4 @@ class ThemeForm(QtGui.QWizard, Ui_ThemeWizard):
             QtGui.QColor(field), self)
         if new_color.isValid():
             field = new_color.name()
-        return field
+        return field

openlp/core/ui/thememanager.py

@@ -127,8 +127,8 @@ class ThemeManager(QtGui.QWidget):
         QtCore.QObject.connect(self.themeListWidget,
             QtCore.SIGNAL(u'doubleClicked(QModelIndex)'),
             self.changeGlobalFromScreen)
-        QtCore.QObject.connect(self.themeListWidget,
-            QtCore.SIGNAL(u'itemClicked(QListWidgetItem *)'),
+        QtCore.QObject.connect(self.themeListWidget, QtCore.SIGNAL(
+            u'currentItemChanged(QListWidgetItem *, QListWidgetItem *)'),
             self.checkListState)
         QtCore.QObject.connect(Receiver.get_receiver(),
             QtCore.SIGNAL(u'theme_update_global'), self.changeGlobalFromTab)
@@ -170,6 +170,8 @@ class ThemeManager(QtGui.QWidget):
         """
         If Default theme selected remove delete button.
         """
+        if item is None:
+            return
         realThemeName = unicode(item.data(QtCore.Qt.UserRole).toString())
         themeName = unicode(item.text())
         # If default theme restrict actions
@@ -660,7 +662,7 @@ class ThemeManager(QtGui.QWidget):
 
     def generateImage(self, themeData, forcePage=False):
         """
-        Call the RenderManager to build a Sample Image
+        Call the renderer to build a Sample Image
 
         ``themeData``
             The theme to generated a preview for.
@@ -669,7 +671,7 @@ class ThemeManager(QtGui.QWidget):
             Flag to tell message lines per page need to be generated.
         """
         log.debug(u'generateImage \n%s ', themeData)
-        return self.mainwindow.renderManager.generate_preview(
+        return self.mainwindow.renderer.generate_preview(
             themeData, forcePage)
 
     def getPreviewImage(self, theme):
@@ -748,7 +750,8 @@ class ThemeManager(QtGui.QWidget):
                             'Theme %s is used in the %s plugin.')) % \
                             (theme, plugin.name))
                         return False
-        return True
+            return True
+        return False
 
     def _migrateVersion122(self, xml_data):
         """
@@ -806,4 +809,5 @@ class ThemeManager(QtGui.QWidget):
             vAlignCorrection = VerticalType.Bottom
         newtheme.display_horizontal_align = theme.HorizontalAlign
         newtheme.display_vertical_align = vAlignCorrection
-        return newtheme.extract_xml()
+        return newtheme.extract_xml()
+

openlp/core/ui/themestab.py

@@ -149,7 +149,7 @@ class ThemesTab(SettingsTab):
         settings.setValue(u'global theme',
             QtCore.QVariant(self.global_theme))
         settings.endGroup()
-        self.mainwindow.renderManager.set_global_theme(
+        self.mainwindow.renderer.set_global_theme(
             self.global_theme, self.theme_level)
         Receiver.send_message(u'theme_update_global', self.global_theme)
 
@@ -167,7 +167,7 @@ class ThemesTab(SettingsTab):
 
     def onDefaultComboBoxChanged(self, value):
         self.global_theme = unicode(self.DefaultComboBox.currentText())
-        self.mainwindow.renderManager.set_global_theme(
+        self.mainwindow.renderer.set_global_theme(
             self.global_theme, self.theme_level)
         self.__previewGlobalTheme()
 
@@ -188,7 +188,7 @@ class ThemesTab(SettingsTab):
         for theme in theme_list:
             self.DefaultComboBox.addItem(theme)
         find_and_set_in_combo_box(self.DefaultComboBox, self.global_theme)
-        self.mainwindow.renderManager.set_global_theme(
+        self.mainwindow.renderer.set_global_theme(
             self.global_theme, self.theme_level)
         if self.global_theme is not u'':
             self.__previewGlobalTheme()
@@ -203,4 +203,4 @@ class ThemesTab(SettingsTab):
         if not preview.isNull():
             preview = preview.scaled(300, 255, QtCore.Qt.KeepAspectRatio,
                 QtCore.Qt.SmoothTransformation)
-        self.DefaultListView.setPixmap(preview)
+        self.DefaultListView.setPixmap(preview)

openlp/core/utils/__init__.py

@@ -101,6 +101,20 @@ class VersionThread(QtCore.QThread):
             Receiver.send_message(u'openlp_version_check', u'%s' % version)
 
 
+class DelayStartThread(QtCore.QThread):
+    """
+    A special Qt thread class to build things after OpenLP has started
+    """
+    def __init__(self, parent):
+        QtCore.QThread.__init__(self, parent)
+
+    def run(self):
+        """
+        Run the thread.
+        """
+        Receiver.send_message(u'openlp_phonon_creation')
+
+
 class AppLocation(object):
     """
     The :class:`AppLocation` class is a static class which retrieves a

openlp/core/utils/languagemanager.py

@@ -28,6 +28,7 @@ The :mod:`languagemanager` module provides all the translation settings and
 language file loading for OpenLP.
 """
 import logging
+import sys
 
 from PyQt4 import QtCore, QtGui
 
@@ -55,8 +56,14 @@ class LanguageManager(object):
             language = QtCore.QLocale.system().name()
         lang_path = AppLocation.get_directory(AppLocation.LanguageDir)
         app_translator = QtCore.QTranslator()
-        if app_translator.load(language, lang_path):
-            return app_translator
+        app_translator.load(language, lang_path)
+        # A translator for buttons and other default strings provided by Qt.
+        if sys.platform != u'win32' and sys.platform != u'darwin':
+            lang_path = QtCore.QLibraryInfo.location(
+                QtCore.QLibraryInfo.TranslationsPath)
+        default_translator = QtCore.QTranslator()
+        default_translator.load(u'qt_%s' % language, lang_path)
+        return app_translator, default_translator
 
     @staticmethod
     def find_qm_files():

openlp/plugins/bibles/lib/mediaitem.py

@@ -72,76 +72,85 @@ class BibleMediaItem(MediaManagerItem):
         self.hasDeleteIcon = False
         self.addToServiceItem = False
 
+    def addSearchTab(self, prefix, name):
+        """
+        Creates and adds generic search tab.
+
+        ``prefix``
+            The prefix of the tab, this is either ``quick`` or ``advanced``.
+
+        ``name``
+            The translated string to display.
+        """
+        tab = QtGui.QWidget()
+        tab.setObjectName(prefix + u'Tab')
+        layout = QtGui.QGridLayout(tab)
+        layout.setObjectName(prefix + u'Layout')
+        versionLabel = QtGui.QLabel(tab)
+        versionLabel.setObjectName(prefix + u'VersionLabel')
+        layout.addWidget(versionLabel, 0, 0, QtCore.Qt.AlignRight)
+        versionComboBox = media_item_combo_box(tab, prefix + u'VersionComboBox')
+        versionLabel.setBuddy(versionComboBox)
+        layout.addWidget(versionComboBox, 0, 1, 1, 2)
+        secondLabel = QtGui.QLabel(tab)
+        secondLabel.setObjectName(prefix + u'SecondLabel')
+        layout.addWidget(secondLabel, 1, 0, QtCore.Qt.AlignRight)
+        secondComboBox = media_item_combo_box(tab, prefix + u'SecondComboBox')
+        versionLabel.setBuddy(secondComboBox)
+        layout.addWidget(secondComboBox, 1, 1, 1, 2)
+        searchButtonLayout = QtGui.QHBoxLayout()
+        searchButtonLayout.setObjectName(prefix + u'SearchButtonLayout')
+        searchButtonLayout.addStretch()
+        searchButton = QtGui.QPushButton(tab)
+        searchButton.setObjectName(prefix + u'SearchButton')
+        searchButtonLayout.addWidget(searchButton)
+        self.searchTabWidget.addTab(tab, name)
+        setattr(self, prefix + u'Tab', tab)
+        setattr(self, prefix + u'Layout', layout)
+        setattr(self, prefix + u'VersionLabel', versionLabel)
+        setattr(self, prefix + u'VersionComboBox', versionComboBox)
+        setattr(self, prefix + u'SecondLabel', secondLabel)
+        setattr(self, prefix + u'SecondComboBox', secondComboBox)
+        setattr(self, prefix + u'SearchButtonLayout', searchButtonLayout)
+        setattr(self, prefix + u'SearchButton', searchButton)
+
     def addEndHeaderBar(self):
         self.searchTabWidget = QtGui.QTabWidget(self)
         self.searchTabWidget.setSizePolicy(
             QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Minimum)
-        self.searchTabWidget.setObjectName(u'SearchTabWidget')
+        self.searchTabWidget.setObjectName(u'searchTabWidget')
         # Add the Quick Search tab.
-        self.quickTab = QtGui.QWidget()
-        self.quickTab.setObjectName(u'quickTab')
-        self.quickLayout = QtGui.QFormLayout(self.quickTab)
-        self.quickLayout.setObjectName(u'quickLayout')
-        self.quickVersionLabel = QtGui.QLabel(self.quickTab)
-        self.quickVersionLabel.setObjectName(u'quickVersionLabel')
-        self.quickVersionComboBox = media_item_combo_box(self.quickTab,
-            u'quickVersionComboBox')
-        self.quickVersionLabel.setBuddy(self.quickVersionComboBox)
-        self.quickLayout.addRow(self.quickVersionLabel,
-            self.quickVersionComboBox)
-        self.quickSecondLabel = QtGui.QLabel(self.quickTab)
-        self.quickSecondLabel.setObjectName(u'quickSecondLabel')
-        self.quickSecondComboBox = media_item_combo_box(self.quickTab,
-            u'quickSecondComboBox')
-        self.quickSecondLabel.setBuddy(self.quickSecondComboBox)
-        self.quickLayout.addRow(self.quickSecondLabel, self.quickSecondComboBox)
+        self.addSearchTab(
+            u'quick', translate('BiblesPlugin.MediaItem', 'Quick'))
         self.quickSearchLabel = QtGui.QLabel(self.quickTab)
         self.quickSearchLabel.setObjectName(u'quickSearchLabel')
+        self.quickLayout.addWidget(
+            self.quickSearchLabel, 2, 0, QtCore.Qt.AlignRight)
         self.quickSearchEdit = SearchEdit(self.quickTab)
         self.quickSearchEdit.setObjectName(u'quickSearchEdit')
         self.quickSearchLabel.setBuddy(self.quickSearchEdit)
-        self.quickLayout.addRow(self.quickSearchLabel, self.quickSearchEdit)
+        self.quickLayout.addWidget(self.quickSearchEdit, 2, 1, 1, 2)
         self.quickLayoutLabel = QtGui.QLabel(self.quickTab)
         self.quickLayoutLabel.setObjectName(u'quickClearLabel')
+        self.quickLayout.addWidget(
+            self.quickLayoutLabel, 3, 0, QtCore.Qt.AlignRight)
         self.quickLayoutComboBox = media_item_combo_box(self.quickTab,
             u'quickLayoutComboBox')
         self.quickLayoutComboBox.addItems([u'', u'', u''])
-        self.quickLayout.addRow(self.quickLayoutLabel, self.quickLayoutComboBox)
+        self.quickLayout.addWidget(self.quickLayoutComboBox, 3, 1, 1, 2)
         self.quickClearLabel = QtGui.QLabel(self.quickTab)
         self.quickClearLabel.setObjectName(u'quickClearLabel')
+        self.quickLayout.addWidget(
+            self.quickClearLabel, 4, 0, QtCore.Qt.AlignRight)
         self.quickClearComboBox = media_item_combo_box(self.quickTab,
             u'quickClearComboBox')
-        self.quickLayout.addRow(self.quickClearLabel, self.quickClearComboBox)
-        self.quickSearchButtonLayout = QtGui.QHBoxLayout()
-        self.quickSearchButtonLayout.setObjectName(u'quickSearchButtonLayout')
-        self.quickSearchButtonLayout.addStretch()
-        self.quickSearchButton = QtGui.QPushButton(self.quickTab)
-        self.quickSearchButton.setObjectName(u'quickSearchButton')
-        self.quickSearchButtonLayout.addWidget(self.quickSearchButton)
-        self.quickLayout.addRow(self.quickSearchButtonLayout)
-        self.searchTabWidget.addTab(self.quickTab,
-            translate('BiblesPlugin.MediaItem', 'Quick'))
+        self.quickLayout.addWidget(self.quickClearComboBox, 4, 1, 1, 2)
+        self.quickLayout.addLayout(self.quickSearchButtonLayout, 6, 1, 1, 2)
+        # Add a QWidget, so that the quick tab has as many rows as the advanced
+        # tab.
+        self.quickLayout.addWidget(QtGui.QWidget(), 7, 0)
         # Add the Advanced Search tab.
-        self.advancedTab = QtGui.QWidget()
-        self.advancedTab.setObjectName(u'advancedTab')
-        self.advancedLayout = QtGui.QGridLayout(self.advancedTab)
-        self.advancedLayout.setObjectName(u'advancedLayout')
-        self.advancedVersionLabel = QtGui.QLabel(self.advancedTab)
-        self.advancedVersionLabel.setObjectName(u'advancedVersionLabel')
-        self.advancedLayout.addWidget(self.advancedVersionLabel, 0, 0,
-            QtCore.Qt.AlignRight)
-        self.advancedVersionComboBox = media_item_combo_box(self.advancedTab,
-            u'advancedVersionComboBox')
-        self.advancedVersionLabel.setBuddy(self.advancedVersionComboBox)
-        self.advancedLayout.addWidget(self.advancedVersionComboBox, 0, 1, 1, 2)
-        self.advancedSecondLabel = QtGui.QLabel(self.advancedTab)
-        self.advancedSecondLabel.setObjectName(u'advancedSecondLabel')
-        self.advancedLayout.addWidget(self.advancedSecondLabel, 1, 0,
-            QtCore.Qt.AlignRight)
-        self.advancedSecondComboBox = media_item_combo_box(self.advancedTab,
-            u'advancedSecondComboBox')
-        self.advancedSecondLabel.setBuddy(self.advancedSecondComboBox)
-        self.advancedLayout.addWidget(self.advancedSecondComboBox, 1, 1, 1, 2)
+        self.addSearchTab(u'advanced', UiStrings().Advanced)
         self.advancedBookLabel = QtGui.QLabel(self.advancedTab)
         self.advancedBookLabel.setObjectName(u'advancedBookLabel')
         self.advancedLayout.addWidget(self.advancedBookLabel, 2, 0,
@@ -152,7 +161,7 @@ class BibleMediaItem(MediaManagerItem):
         self.advancedLayout.addWidget(self.advancedBookComboBox, 2, 1, 1, 2)
         self.advancedChapterLabel = QtGui.QLabel(self.advancedTab)
         self.advancedChapterLabel.setObjectName(u'advancedChapterLabel')
-        self.advancedLayout.addWidget(self.advancedChapterLabel, 3, 1)
+        self.advancedLayout.addWidget(self.advancedChapterLabel, 3, 1, 1, 2)
         self.advancedVerseLabel = QtGui.QLabel(self.advancedTab)
         self.advancedVerseLabel.setObjectName(u'advancedVerseLabel')
         self.advancedLayout.addWidget(self.advancedVerseLabel, 3, 2)
@@ -184,16 +193,8 @@ class BibleMediaItem(MediaManagerItem):
             u'advancedClearComboBox')
         self.advancedClearLabel.setBuddy(self.advancedClearComboBox)
         self.advancedLayout.addWidget(self.advancedClearComboBox, 6, 1, 1, 2)
-        self.advancedSearchButtonLayout = QtGui.QHBoxLayout()
-        self.advancedSearchButtonLayout.setObjectName(
-            u'advancedSearchButtonLayout')
-        self.advancedSearchButtonLayout.addStretch()
-        self.advancedSearchButton = QtGui.QPushButton(self.advancedTab)
-        self.advancedSearchButton.setObjectName(u'advancedSearchButton')
-        self.advancedSearchButtonLayout.addWidget(self.advancedSearchButton)
         self.advancedLayout.addLayout(
             self.advancedSearchButtonLayout, 7, 0, 1, 3)
-        self.searchTabWidget.addTab(self.advancedTab, UiStrings().Advanced)
         # Add the search tab widget to the page layout.
         self.pageLayout.addWidget(self.searchTabWidget)
         # Combo Boxes
@@ -213,7 +214,7 @@ class BibleMediaItem(MediaManagerItem):
             QtCore.SIGNAL(u'activated(int)'), self.updateAutoCompleter)
         QtCore.QObject.connect(
             self.quickLayoutComboBox, QtCore.SIGNAL(u'activated(int)'),
-            self.onlayoutStyleComboBoxChanged)
+            self.onLayoutStyleComboBoxChanged)
         # Buttons
         QtCore.QObject.connect(self.advancedSearchButton,
             QtCore.SIGNAL(u'pressed()'), self.onAdvancedSearchButton)
@@ -723,6 +724,7 @@ class BibleMediaItem(MediaManagerItem):
             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: Title
         service_item.title = u', '.join(raw_title)
         # Service Item: Theme
@@ -843,10 +845,10 @@ class BibleMediaItem(MediaManagerItem):
             return u'{su}[%s]{/su}' % verse_text
         return u'{su}%s{/su}' % verse_text
 
-    def onlayoutStyleComboBoxChanged(self):
+    def onLayoutStyleComboBoxChanged(self):
         self.settings.layout_style = self.quickLayoutComboBox.currentIndex()
         self.settings.layoutStyleComboBox.setCurrentIndex(
             self.settings.layout_style)
         QtCore.QSettings().setValue(
             self.settingsSection + u'/verse layout style',
-            QtCore.QVariant(self.settings.layout_style))
+            QtCore.QVariant(self.settings.layout_style))

openlp/plugins/bibles/lib/osis.py

@@ -37,6 +37,9 @@ from openlp.plugins.bibles.lib.db import BibleDB
 
 log = logging.getLogger(__name__)
 
+def replacement(match):
+    return match.group(2).upper()
+
 class OSISBible(BibleDB):
     """
     `OSIS <http://www.bibletechnologies.net/>`_ Bible format importer class.
@@ -60,6 +63,7 @@ class OSISBible(BibleDB):
         self.lg_regex = re.compile(r'<lg(.*?)>')
         self.l_regex = re.compile(r'<l (.*?)>')
         self.w_regex = re.compile(r'<w (.*?)>')
+        self.q_regex = re.compile(r'<q(.*?)>')
         self.q1_regex = re.compile(r'<q(.*?)level="1"(.*?)>')
         self.q2_regex = re.compile(r'<q(.*?)level="2"(.*?)>')
         self.trans_regex = re.compile(r'<transChange(.*?)>(.*?)</transChange>')
@@ -106,6 +110,7 @@ class OSISBible(BibleDB):
                 detect_file.close()
         try:
             osis = codecs.open(self.filename, u'r', details['encoding'])
+            repl = replacement
             for file_record in osis:
                 if self.stop_import_flag:
                     break
@@ -148,12 +153,13 @@ class OSISBible(BibleDB):
                     verse_text = self.rf_regex.sub(u'', verse_text)
                     verse_text = self.lb_regex.sub(u' ', verse_text)
                     verse_text = self.lg_regex.sub(u'', verse_text)
-                    verse_text = self.l_regex.sub(u'', verse_text)
+                    verse_text = self.l_regex.sub(u' ', verse_text)
                     verse_text = self.w_regex.sub(u'', verse_text)
                     verse_text = self.q1_regex.sub(u'"', verse_text)
                     verse_text = self.q2_regex.sub(u'\'', verse_text)
+                    verse_text = self.q_regex.sub(u'', verse_text)
+                    verse_text = self.divine_name_regex.sub(repl, verse_text)
                     verse_text = self.trans_regex.sub(u'', verse_text)
-                    verse_text = self.divine_name_regex.sub(u'', verse_text)
                     verse_text = verse_text.replace(u'</lb>', u'')\
                         .replace(u'</l>', u'').replace(u'<lg>', u'')\
                         .replace(u'</lg>', u'').replace(u'</q>', u'')\

openlp/plugins/custom/forms/editcustomform.py

@@ -169,7 +169,7 @@ class EditCustomForm(QtGui.QDialog, Ui_CustomEditDialog):
             item = self.slideListView.item(row)
             slide_list += item.text()
             if row != self.slideListView.count() - 1:
-                slide_list += u'\n[---]\n'
+                slide_list += u'\n[===]\n'
         self.editSlideForm.setText(slide_list)
         if self.editSlideForm.exec_():
             self.updateSlideList(self.editSlideForm.getText(), True)

openlp/plugins/custom/forms/editcustomslideform.py

@@ -63,7 +63,7 @@ class EditCustomSlideForm(QtGui.QDialog, Ui_CustomSlideEditDialog):
         """
         Returns a list with all slides.
         """
-        return self.slideTextEdit.toPlainText().split(u'\n[---]\n')
+        return self.slideTextEdit.toPlainText().split(u'\n[===]\n')
 
     def onSplitButtonPressed(self):
         """
@@ -71,5 +71,5 @@ class EditCustomSlideForm(QtGui.QDialog, Ui_CustomSlideEditDialog):
         """
         if self.slideTextEdit.textCursor().columnNumber() != 0:
             self.slideTextEdit.insertPlainText(u'\n')
-        self.slideTextEdit.insertPlainText(u'[---]\n')
+        self.slideTextEdit.insertPlainText(u'[===]\n')
         self.slideTextEdit.setFocus()

openlp/plugins/custom/lib/mediaitem.py

@@ -140,6 +140,7 @@ class CustomMediaItem(MediaManagerItem):
         service_item.add_capability(ItemCapabilities.AllowsEdit)
         service_item.add_capability(ItemCapabilities.AllowsPreview)
         service_item.add_capability(ItemCapabilities.AllowsLoop)
+        service_item.add_capability(ItemCapabilities.AllowsVirtualSplit)
         customSlide = self.parent.manager.get_object(CustomSlide, item_id)
         title = customSlide.title
         credit = customSlide.credits

openlp/plugins/images/lib/mediaitem.py

@@ -77,7 +77,7 @@ class ImageMediaItem(MediaManagerItem):
             u'thumbnails')
         check_directory_exists(self.servicePath)
         self.loadList(SettingsManager.load_list(
-            self.settingsSection, self.settingsSection))
+            self.settingsSection, self.settingsSection), True)
 
     def addListViewToToolBar(self):
         MediaManagerItem.addListViewToToolBar(self)
@@ -107,8 +107,12 @@ class ImageMediaItem(MediaManagerItem):
             SettingsManager.set_list(self.settingsSection,
                 self.settingsSection, self.getFileList())
 
-    def loadList(self, list):
+    def loadList(self, list, initialLoad=False):
+        if not initialLoad:
+            self.parent.formparent.displayProgressBar(len(list))
         for imageFile in list:
+            if not initialLoad:
+                self.parent.formparent.incrementProgressBar()
             filename = os.path.split(unicode(imageFile))[1]
             thumb = os.path.join(self.servicePath, filename)
             if os.path.exists(thumb):
@@ -122,6 +126,8 @@ class ImageMediaItem(MediaManagerItem):
             item_name.setIcon(icon)
             item_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(imageFile))
             self.listView.addItem(item_name)
+        if not initialLoad:
+            self.parent.formparent.finishedProgressBar()
 
     def generateSlideData(self, service_item, item=None, xmlVersion=False):
         items = self.listView.selectedIndexes()
@@ -201,4 +207,4 @@ class ImageMediaItem(MediaManagerItem):
                 critical_error_message_box(UiStrings().LiveBGError,
                     unicode(translate('ImagePlugin.MediaItem',
                     'There was a problem replacing your background, '
-                    'the image file "%s" no longer exists.')) % filename)
+                    'the image file "%s" no longer exists.')) % filename)

openlp/plugins/media/lib/mediaitem.py

@@ -50,10 +50,13 @@ class MediaMediaItem(MediaManagerItem):
             u':/media/media_video.png').toImage()
         MediaManagerItem.__init__(self, parent, self, icon)
         self.singleServiceItem = False
-        self.mediaObject = Phonon.MediaObject(self)
+        self.mediaObject = None
         QtCore.QObject.connect(Receiver.get_receiver(),
             QtCore.SIGNAL(u'video_background_replaced'),
             self.videobackgroundReplaced)
+        QtCore.QObject.connect(Receiver.get_receiver(),
+            QtCore.SIGNAL(u'openlp_phonon_creation'),
+            self.createPhonon)
 
     def retranslateUi(self):
         self.onNewPrompt = translate('MediaPlugin.MediaItem', 'Select Media')
@@ -135,10 +138,8 @@ class MediaMediaItem(MediaManagerItem):
         if not self.mediaStateWait(Phonon.StoppedState):
             # Due to string freeze, borrow a message from presentations
             # This will be corrected in 1.9.6
-            critical_error_message_box(
-                translate('PresentationPlugin.MediaItem', 'Unsupported File'),
-                unicode(translate('PresentationPlugin.MediaItem',
-                'Unsupported File')))
+            critical_error_message_box(UiStrings().UnsupportedFile,
+                    UiStrings().UnsupportedFile)
             return False
         # File too big for processing
         if os.path.getsize(filename) <= 52428800: # 50MiB
@@ -149,15 +150,11 @@ class MediaMediaItem(MediaManagerItem):
                 # Due to string freeze, borrow a message from presentations
                 # This will be corrected in 1.9.6
                 self.mediaObject.stop()
-                critical_error_message_box(
-                    translate('PresentationPlugin.MediaItem',
-                    'Unsupported File'),
-                    unicode(translate('PresentationPlugin.MediaItem',
-                    'Unsupported File')))
+                critical_error_message_box(UiStrings().UnsupportedFile,
+                        UiStrings().UnsupportedFile)
                 return False
-            self.mediaLength = self.mediaObject.totalTime() / 1000
             self.mediaObject.stop()
-            service_item.media_length = self.mediaLength
+            service_item.media_length = self.mediaObject.totalTime() / 1000
             service_item.add_capability(
                 ItemCapabilities.AllowsVariableStartTime)
         service_item.title = unicode(self.plugin.nameStrings[u'singular'])
@@ -209,4 +206,9 @@ class MediaMediaItem(MediaManagerItem):
             img = QtGui.QPixmap(u':/media/media_video.png').toImage()
             item_name.setIcon(build_icon(img))
             item_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(file))
-            self.listView.addItem(item_name)
+            self.listView.addItem(item_name)
+
+    def createPhonon(self):
+        log.debug(u'CreatePhonon')
+        if not self.mediaObject:
+            self.mediaObject = Phonon.MediaObject(self)

openlp/plugins/presentations/lib/impresscontroller.py

@@ -219,7 +219,6 @@ class ImpressDocument(PresentationDocument):
         The file name of the presentatios to the run.
         """
         log.debug(u'Load Presentation OpenOffice')
-        #print "s.dsk1 ", self.desktop
         if os.name == u'nt':
             desktop = self.controller.get_com_desktop()
             if desktop is None:
@@ -234,7 +233,10 @@ class ImpressDocument(PresentationDocument):
             return False
         self.desktop = desktop
         properties = []
-        properties.append(self.create_property(u'Minimized', True))
+        if os.name != u'nt':
+            # Recent versions of Impress on Windows won't start the presentation
+            # if it starts as minimized. It seems OK on Linux though.
+            properties.append(self.create_property(u'Minimized', True))
         properties = tuple(properties)
         try:
             self.document = desktop.loadComponentFromURL(url, u'_blank',
@@ -242,9 +244,15 @@ class ImpressDocument(PresentationDocument):
         except:
             log.exception(u'Failed to load presentation %s' % url)
             return False
+        if os.name == u'nt':
+            # As we can't start minimized the Impress window gets in the way.
+            # Either window.setPosSize(0, 0, 200, 400, 12) or .setVisible(False)
+            window = self.document.getCurrentController().getFrame() \
+                .getContainerWindow()
+            window.setVisible(False)
         self.presentation = self.document.getPresentation()
         self.presentation.Display = \
-            self.controller.plugin.renderManager.screens.current_display + 1
+            self.controller.plugin.renderer.screens.current_display + 1
         self.control = None
         self.create_thumbnails()
         return True
@@ -387,14 +395,14 @@ class ImpressDocument(PresentationDocument):
         log.debug(u'start presentation OpenOffice')
         if self.control is None or not self.control.isRunning():
             self.presentation.start()
-            # start() returns before the getCurrentComponent is ready.
-            # Try for 5 seconds
+            self.control = self.presentation.getController()
+            # start() returns before the Component is ready.
+            # Try for 15 seconds
             i = 1
-            while self.desktop.getCurrentComponent() is None and i < 50:
+            while not self.control and i < 150:
                 time.sleep(0.1)
                 i = i + 1
-            self.control = \
-                self.desktop.getCurrentComponent().Presentation.getController()
+                self.control = self.presentation.getController()
         else:
             self.control.activate()
             self.goto_slide(1)

openlp/plugins/presentations/lib/mediaitem.py

@@ -158,7 +158,12 @@ class PresentationMediaItem(MediaManagerItem):
         titles = []
         for file in currlist:
             titles.append(os.path.split(file)[1])
+        Receiver.send_message(u'cursor_busy')
+        if not initialLoad:
+            self.parent.formparent.displayProgressBar(len(list))
         for file in list:
+            if not initialLoad:
+                self.parent.formparent.incrementProgressBar()
             if currlist.count(file) > 0:
                 continue
             filename = os.path.split(unicode(file))[1]
@@ -188,9 +193,7 @@ class PresentationMediaItem(MediaManagerItem):
                 if initialLoad:
                     icon = build_icon(u':/general/general_delete.png')
                 else:
-                    critical_error_message_box(
-                        translate('PresentationPlugin.MediaItem',
-                        'Unsupported File'),
+                    critical_error_message_box(UiStrings().UnsupportedFile,
                         translate('PresentationPlugin.MediaItem',
                         'This type of presentation is not supported.'))
                     continue
@@ -198,6 +201,9 @@ class PresentationMediaItem(MediaManagerItem):
             item_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(file))
             item_name.setIcon(icon)
             self.listView.addItem(item_name)
+        Receiver.send_message(u'cursor_normal')
+        if not initialLoad:
+            self.parent.formparent.finishedProgressBar()
 
     def onDeleteClick(self):
         """
@@ -285,7 +291,7 @@ class PresentationMediaItem(MediaManagerItem):
         "supports" the extension. If none found, then look for a controller
         which "also supports" it instead.
         """
-        filetype = filename.split(u'.')[1]
+        filetype = os.path.splitext(filename)[1][1:]
         if not filetype:
             return None
         for controller in self.controllers:
@@ -296,4 +302,4 @@ class PresentationMediaItem(MediaManagerItem):
             if self.controllers[controller].enabled():
                 if filetype in self.controllers[controller].alsosupports:
                     return controller
-        return None
+        return None

openlp/plugins/presentations/lib/powerpointcontroller.py

@@ -251,14 +251,15 @@ class PowerpointDocument(PresentationDocument):
                         win32ui.GetForegroundWindow().GetDC().GetDeviceCaps(88)
                 except win32ui.error:
                     dpi = 96
-            rendermanager = self.controller.plugin.renderManager
-            rect = rendermanager.screens.current[u'size']
+            renderer = self.controller.plugin.renderer
+            rect = renderer.screens.current[u'size']
             ppt_window = self.presentation.SlideShowSettings.Run()
             ppt_window.Top = rect.y() * 72 / dpi
             ppt_window.Height = rect.height() * 72 / dpi
             ppt_window.Left = rect.x() * 72 / dpi
             ppt_window.Width = rect.width() * 72 / dpi
 
+
     def get_slide_number(self):
         """
         Returns the current slide number.

openlp/plugins/presentations/lib/pptviewcontroller.py

@@ -121,8 +121,8 @@ class PptviewDocument(PresentationDocument):
         The file name of the presentations to run.
         """
         log.debug(u'LoadPresentation')
-        rendermanager = self.controller.plugin.renderManager
-        rect = rendermanager.screens.current[u'size']
+        renderer = self.controller.plugin.renderer
+        rect = renderer.screens.current[u'size']
         rect = RECT(rect.x(), rect.y(), rect.right(), rect.bottom())
         filepath = str(self.filepath.replace(u'/', u'\\'))
         if not os.path.isdir(self.get_temp_folder()):
@@ -244,4 +244,4 @@ class PptviewDocument(PresentationDocument):
         """
         Triggers the previous slide on the running presentation
         """
-        self.controller.process.PrevStep(self.pptid)
+        self.controller.process.PrevStep(self.pptid)

openlp/plugins/songs/forms/editsongform.py

@@ -89,7 +89,7 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
             self.onVerseListViewPressed)
         QtCore.QObject.connect(self.themeAddButton,
             QtCore.SIGNAL(u'clicked()'),
-            self.parent.parent.renderManager.theme_manager.onAddTheme)
+            self.parent.parent.renderer.theme_manager.onAddTheme)
         QtCore.QObject.connect(self.maintenanceButton,
             QtCore.SIGNAL(u'clicked()'), self.onMaintenanceButtonClicked)
         QtCore.QObject.connect(Receiver.get_receiver(),
@@ -576,11 +576,13 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
                     if verse_index is not None:
                         order.append(VerseType.Tags[verse_index] + u'1')
                     else:
-                        order.append(u'') # it matches no verses anyway
+                        # it matches no verses anyway
+                        order.append(u'')
                 else:
                     verse_index = VerseType.from_translated_tag(item[0])
                     if verse_index is None:
-                        order.append(u'') # same as above
+                        # it matches no verses anyway
+                        order.append(u'')
                     else:
                         verse_tag = VerseType.Tags[verse_index]
                         verse_num = item[1:].lower()
@@ -779,4 +781,4 @@ class EditSongForm(QtGui.QDialog, Ui_EditSongDialog):
                     self.song.verse_order)
         except:
             log.exception(u'Problem processing song Lyrics \n%s',
-                sxml.dump_xml())
+                sxml.dump_xml())

openlp/plugins/songs/lib/__init__.py

@@ -257,7 +257,7 @@ def clean_song(manager, song):
     ``song``
         The song object.
     """
-    song.title = song.title.strip() if song.title else u''
+    song.title = song.title.rstrip() if song.title else u''
     if song.alternate_title is None:
         song.alternate_title = u''
     song.alternate_title = song.alternate_title.strip()
@@ -278,24 +278,32 @@ def clean_song(manager, song):
     # List for later comparison.
     compare_order = []
     for verse in verses:
-        type = VerseType.Tags[VerseType.from_loose_input(verse[0][u'type'])]
+        verse_type = VerseType.Tags[VerseType.from_loose_input(
+            verse[0][u'type'])]
         sxml.add_verse_to_lyrics(
-            type,
+            verse_type,
             verse[0][u'label'],
             verse[1],
             verse[0][u'lang'] if verse[0].has_key(u'lang') else None
         )
-        compare_order.append((u'%s%s' % (type, verse[0][u'label'])).upper())
+        compare_order.append((u'%s%s' % (verse_type, verse[0][u'label'])
+            ).upper())
+        if verse[0][u'label'] == u'1':
+            compare_order.append(verse_type.upper())
     song.lyrics = unicode(sxml.extract_xml(), u'utf-8')
     # Rebuild the verse order, to convert translated verse tags, which might
     # have been added prior to 1.9.5.
-    order = song.verse_order.strip().split()
+    if song.verse_order:
+        order = song.verse_order.strip().split()
+    else:
+        order = []
     new_order = []
     for verse_def in order:
-        new_order.append((u'%s%s' % (
-            VerseType.Tags[VerseType.from_loose_input(verse_def[0])],
-            verse_def[1:])).upper()
-        )
+        verse_type = VerseType.Tags[VerseType.from_loose_input(verse_def[0])]
+        if len(verse_def) > 1:
+            new_order.append((u'%s%s' % (verse_type, verse_def[1:])).upper())
+        else:
+            new_order.append(verse_type.upper())
     song.verse_order = u' '.join(new_order)
     # Check if the verse order contains tags for verses which do not exist.
     for order in new_order:

openlp/plugins/songs/lib/mediaitem.py

@@ -347,6 +347,7 @@ class SongMediaItem(MediaManagerItem):
         service_item.add_capability(ItemCapabilities.AllowsLoop)
         service_item.add_capability(ItemCapabilities.OnLoadUpdate)
         service_item.add_capability(ItemCapabilities.AddIfNewItem)
+        service_item.add_capability(ItemCapabilities.AllowsVirtualSplit)
         song = self.parent.manager.get_object(Song, item_id)
         service_item.theme = song.theme_name
         service_item.edit_id = item_id
@@ -472,4 +473,4 @@ class SongMediaItem(MediaManagerItem):
         Locale aware collation of song titles
         """
         return locale.strcoll(unicode(song_1.title.lower()),
-             unicode(song_2.title.lower()))
+             unicode(song_2.title.lower()))

openlp/plugins/songs/lib/opensongimport.py

@@ -193,7 +193,10 @@ class OpenSongImport(SongImport):
         verse_num = u'1'
         # for the case where song has several sections with same marker
         inst = 1
-        lyrics = unicode(root.lyrics)
+        if u'lyrics' in fields:
+            lyrics = unicode(root.lyrics)
+        else:
+            lyrics = u''
         for this_line in lyrics.split(u'\n'):
             # remove comments
             semicolon = this_line.find(u';')
@@ -214,7 +217,7 @@ class OpenSongImport(SongImport):
                 # have we got any digits?
                 # If so, verse number is everything from the digits
                 # to the end (even if there are some alpha chars on the end)
-                match = re.match(u'(.*)(\d+.*)', content)
+                match = re.match(u'(\D*)(\d+.*)', content)
                 if match is not None:
                     verse_tag = match.group(1)
                     verse_num = match.group(2)
@@ -223,12 +226,13 @@ class OpenSongImport(SongImport):
                     # the verse tag
                     verse_tag = content
                     verse_num = u'1'
+                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 \
                     and verses.has_key(verse_tag) \
                     and verses[verse_tag].has_key(verse_num):
                     inst = len(verses[verse_tag][verse_num]) + 1
-                our_verse_order.append([verse_tag, verse_num, inst])
                 continue
             # number at start of line.. it's verse number
             if this_line[0].isdigit():
@@ -241,6 +245,7 @@ class OpenSongImport(SongImport):
                 verses[verse_tag][verse_num] = {}
             if not verses[verse_tag][verse_num].has_key(inst):
                 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 = this_line.replace(u'_', u'')
@@ -252,6 +257,8 @@ class OpenSongImport(SongImport):
             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)
+        if not self.verses:
+            self.add_verse('')
         # figure out the presentation order, if present
         if u'presentation' in fields and root.presentation:
             order = unicode(root.presentation)
@@ -259,7 +266,7 @@ class OpenSongImport(SongImport):
             # and then split into a list on the whitespace
             order = order.lower().split()
             for verse_def in order:
-                match = re.match(u'(.*)(\d+.*)', verse_def)
+                match = re.match(u'(\D*)(\d+.*)', verse_def)
                 if match is not None:
                     verse_tag = match.group(1)
                     verse_num = match.group(2)

openlp/plugins/songs/lib/xml.py

@@ -32,7 +32,7 @@ The basic XML for storing the lyrics in the song database looks like this::
     <song version="1.0">
         <lyrics>
             <verse type="c" label="1" lang="en">
-                <![CDATA[ ... ]]>
+                <![CDATA[Chorus virtual slide 1[---]Chorus  virtual slide 2]]>
             </verse>
         </lyrics>
     </song>
@@ -129,18 +129,31 @@ class SongXML(object):
 
         The returned list has the following format::
 
-            [[{'lang': 'en', 'type': 'v', 'label': '1'}, u"English verse"],
+            [[{'type': 'v', 'label': '1'},
+            u"virtual slide 1[---]virtual slide 2"],
             [{'lang': 'en', 'type': 'c', 'label': '1'}, u"English chorus"]]
         """
         self.song_xml = None
-        if xml[:5] == u'<?xml':
+        verse_list = []
+        if not xml.startswith(u'<?xml') and not xml.startswith(u'<song'):
+            # This is an old style song, without XML. Let's handle it correctly
+            # by iterating through the verses, and then recreating the internal
+            # xml object as well.
+            self.song_xml = objectify.fromstring(u'<song version="1.0" />')
+            self.lyrics = etree.SubElement(self.song_xml, u'lyrics')
+            verses = xml.split(u'\n\n')
+            for count, verse in enumerate(verses):
+                verse_list.append([{u'type': u'v', u'label': unicode(count)},
+                    unicode(verse)])
+                self.add_verse_to_lyrics(u'v', unicode(count), verse)
+            return verse_list
+        elif xml.startswith(u'<?xml'):
             xml = xml[38:]
         try:
             self.song_xml = objectify.fromstring(xml)
         except etree.XMLSyntaxError:
             log.exception(u'Invalid xml %s', xml)
         xml_iter = self.song_xml.getiterator()
-        verse_list = []
         for element in xml_iter:
             if element.tag == u'verse':
                 if element.text is None:
@@ -226,7 +239,6 @@ class OpenLyrics(object):
         Convert the song to OpenLyrics Format.
         """
         sxml = SongXML()
-        verse_list = sxml.get_verses(song.lyrics)
         song_xml = objectify.fromstring(u'<song/>')
         # Append the necessary meta data to the song.
         song_xml.set(u'xmlns', u'http://openlyrics.info/namespace/2009/song')
@@ -268,17 +280,26 @@ class OpenLyrics(object):
             themes = etree.SubElement(properties, u'themes')
             for topic in song.topics:
                 self._add_text_to_element(u'theme', themes, topic.name)
+        # Process the song's lyrics.
         lyrics = etree.SubElement(song_xml, u'lyrics')
+        verse_list = sxml.get_verses(song.lyrics)
         for verse in verse_list:
-            verse_tag = u'%s%s' % (
-                verse[0][u'type'][0].lower(), verse[0][u'label'])
-            element = \
-                self._add_text_to_element(u'verse', lyrics, None, verse_tag)
-            if verse[0].has_key(u'lang'):
-                element.set(u'lang', verse[0][u'lang'])
-            element = self._add_text_to_element(u'lines', element)
-            for line in unicode(verse[1]).split(u'\n'):
-                self._add_text_to_element(u'line', element, line)
+            verse_tag = verse[0][u'type'][0].lower()
+            verse_number = verse[0][u'label']
+            # Create a list with all "virtual" verses.
+            virtual_verses = verse[1].split(u'[---]')
+            for index, virtual_verse in enumerate(virtual_verses):
+                verse_def = verse_tag + verse_number
+                # We need "v1a" because we have more than one virtual verse.
+                if len(virtual_verses) > 1:
+                    verse_def += list(u'abcdefghijklmnopqrstuvwxyz')[index]
+                element = \
+                    self._add_text_to_element(u'verse', lyrics, None, verse_def)
+                if verse[0].has_key(u'lang'):
+                    element.set(u'lang', verse[0][u'lang'])
+                element = self._add_text_to_element(u'lines', element)
+                for line in virtual_verse.strip(u'\n').split(u'\n'):
+                    self._add_text_to_element(u'line', element, line)
         return self._extract_xml(song_xml)
 
     def xml_to_song(self, xml):
@@ -446,6 +467,8 @@ class OpenLyrics(object):
             The song object.
         """
         sxml = SongXML()
+        verses = {}
+        verse_def_list = []
         for verse in lyrics.verse:
             text = u''
             for lines in verse.lines:
@@ -465,7 +488,15 @@ class OpenLyrics(object):
             lang = None
             if self._get(verse, u'lang'):
                 lang = self._get(verse, u'lang')
-            sxml.add_verse_to_lyrics(verse_tag, verse_number, text, lang)
+            if verses.has_key((verse_tag, verse_number, lang)):
+                verses[(verse_tag, verse_number, lang)] += u'\n[---]\n' + text
+            else:
+                verses[(verse_tag, verse_number, lang)] = text
+                verse_def_list.append((verse_tag, verse_number, lang))
+        # We have to use a list to keep the order, as dicts are not sorted.
+        for verse in verse_def_list:
+            sxml.add_verse_to_lyrics(
+                verse[0], verse[1], verses[verse], verse[2])
         song.lyrics = unicode(sxml.extract_xml(), u'utf-8')
         # Process verse order
         if hasattr(properties, u'verseOrder'):

resources/images/openlp-2.qrc

@@ -52,6 +52,7 @@
     <file>general_open.png</file>
     <file>general_save.png</file>
     <file>general_email.png</file>
+    <file>general_revert.png</file>
   </qresource>
   <qresource prefix="slides">
     <file>slide_close.png</file>

scripts/windows-builder.py

@@ -243,6 +243,14 @@ def compile_translations():
             code = lconvert.wait()
             if code != 0:
                 raise Exception('Error running lconvert on %s' % source_path)
+    print u'Copying qm files...'
+    source = os.path.join(site_packages, u'PyQt4', u'translations')
+    files = os.listdir(source)
+    for filename in files:
+        if filename.startswith(u'qt_') and filename.endswith(u'.qm') and \
+            len(filename) == 8:
+            copy(os.path.join(source, filename),
+                os.path.join(dist_path, u'i18n', filename))
 
 def run_sphinx():
     print u'Running Sphinx...'