HEAD

openlp/core/lib/__init__.py

@@ -38,62 +38,47 @@ log = logging.getLogger(__name__)
 # TODO make external and configurable in alpha 4 via a settings dialog
 html_expands = []
 
-html_expands.append({u'desc':u'Red', u'start tag':u'{r}', \
+html_expands.append({u'desc':u'Red', u'start tag':u'{r}',
-                          u'start html':u'<span style="-webkit-text-fill-color:red">', \
+    u'start html':u'<span style="-webkit-text-fill-color:red">',
-                          u'end tag':u'{/r}', u'end html':u'</span>', \
+    u'end tag':u'{/r}', u'end html':u'</span>', u'protected':False})
-                          u'protected':False})
+html_expands.append({u'desc':u'Black', u'start tag':u'{b}',
-html_expands.append({u'desc':u'Black', u'start tag':u'{b}', \
+    u'start html':u'<span style="-webkit-text-fill-color:black">',
-                          u'start html':u'<span style="-webkit-text-fill-color:black">', \
+    u'end tag':u'{/b}', u'end html':u'</span>', u'protected':False})
-                          u'end tag':u'{/b}', u'end html':u'</span>', \
+html_expands.append({u'desc':u'Blue', u'start tag':u'{bl}',
-                          u'protected':False})
+    u'start html':u'<span style="-webkit-text-fill-color:blue">',
-html_expands.append({u'desc':u'Blue', u'start tag':u'{bl}', \
+    u'end tag':u'{/bl}', u'end html':u'</span>', u'protected':False})
-                          u'start html':u'<span style="-webkit-text-fill-color:blue">', \
+html_expands.append({u'desc':u'Yellow', u'start tag':u'{y}',
-                          u'end tag':u'{/bl}', u'end html':u'</span>', \
+    u'start html':u'<span style="-webkit-text-fill-color:yellow">',
-                          u'protected':False})
+    u'end tag':u'{/y}', u'end html':u'</span>', u'protected':False})
-html_expands.append({u'desc':u'Yellow', u'start tag':u'{y}', \
+html_expands.append({u'desc':u'Green', u'start tag':u'{g}',
-                          u'start html':u'<span style="-webkit-text-fill-color:yellow">', \
+    u'start html':u'<span style="-webkit-text-fill-color:green">',
-                          u'end tag':u'{/y}', u'end html':u'</span>', \
+    u'end tag':u'{/g}', u'end html':u'</span>', u'protected':False})
-                          u'protected':False})
+html_expands.append({u'desc':u'Pink', u'start tag':u'{pk}',
-html_expands.append({u'desc':u'Green', u'start tag':u'{g}', \
+    u'start html':u'<span style="-webkit-text-fill-color:#CC33CC">',
-                          u'start html':u'<span style="-webkit-text-fill-color:green">', \
+    u'end tag':u'{/pk}', u'end html':u'</span>', u'protected':False})
-                          u'end tag':u'{/g}', u'end html':u'</span>', \
+html_expands.append({u'desc':u'Orange', u'start tag':u'{o}',
-                          u'protected':False})
+    u'start html':u'<span style="-webkit-text-fill-color:#CC0033">',
-html_expands.append({u'desc':u'Pink', u'start tag':u'{pk}', \
+    u'end tag':u'{/o}', u'end html':u'</span>', u'protected':False})
-                          u'start html':u'<span style="-webkit-text-fill-color:#CC33CC">', \
+html_expands.append({u'desc':u'Purple', u'start tag':u'{pp}',
-                          u'end tag':u'{/pk}', u'end html':u'</span>', \
+    u'start html':u'<span style="-webkit-text-fill-color:#9900FF">',
-                          u'protected':False})
+    u'end tag':u'{/pp}', u'end html':u'</span>', u'protected':False})
-html_expands.append({u'desc':u'Orange', u'start tag':u'{o}', \
+html_expands.append({u'desc':u'White', u'start tag':u'{w}',
-                          u'start html':u'<span style="-webkit-text-fill-color:#CC0033">', \
+    u'start html':u'<span style="-webkit-text-fill-color:white">',
-                          u'end tag':u'{/o}', u'end html':u'</span>', \
+    u'end tag':u'{/w}', u'end html':u'</span>', u'protected':False})
-                          u'protected':False})
+html_expands.append({u'desc':u'Superscript', u'start tag':u'{su}',
-html_expands.append({u'desc':u'Purple', u'start tag':u'{pp}', \
+    u'start html':u'<sup>', u'end tag':u'{/su}', u'end html':u'</sup>',
-                          u'start html':u'<span style="-webkit-text-fill-color:#9900FF">', \
-                          u'end tag':u'{/pp}', u'end html':u'</span>', \
-                          u'protected':False})
-html_expands.append({u'desc':u'White', u'start tag':u'{w}', \
-                          u'start html':u'<span style="-webkit-text-fill-color:white">', \
-                          u'end tag':u'{/w}', u'end html':u'</span>', \
-                          u'protected':False})
-html_expands.append({u'desc':u'Superscript', u'start tag':u'{su}', \
-                          u'start html':u'<sup>', \
-                          u'end tag':u'{/su}', u'end html':u'</sup>', \
     u'protected':True})
-html_expands.append({u'desc':u'Subscript', u'start tag':u'{sb}', \
+html_expands.append({u'desc':u'Subscript', u'start tag':u'{sb}',
-                          u'start html':u'<sub>', \
+    u'start html':u'<sub>', u'end tag':u'{/sb}', u'end html':u'</sub>',
-                          u'end tag':u'{/sb}', u'end html':u'</sub>', \
     u'protected':True})
-html_expands.append({u'desc':u'Paragraph', u'start tag':u'{p}', \
+html_expands.append({u'desc':u'Paragraph', u'start tag':u'{p}',
-                          u'start html':u'<p>', \
+    u'start html':u'<p>', u'end tag':u'{/p}', u'end html':u'</p>',
-                          u'end tag':u'{/p}', u'end html':u'</p>', \
     u'protected':True})
-html_expands.append({u'desc':u'Bold', u'start tag':u'{st}', \
+html_expands.append({u'desc':u'Bold', u'start tag':u'{st}',
-                          u'start html':u'<strong>', \
+    u'start html':u'<strong>', u'end tag':u'{/st}', u'end html':u'</strong>',
-                          u'end tag':u'{/st}', \
-                          u'end html':u'</strong>', \
     u'protected':True})
-html_expands.append({u'desc':u'Italics', u'start tag':u'{it}', \
+html_expands.append({u'desc':u'Italics', u'start tag':u'{it}',
-                          u'start html':u'<em>', \
+    u'start html':u'<em>', u'end tag':u'{/it}', u'end html':u'</em>',
-                          u'end tag':u'{/it}', u'end html':u'</em>', \
     u'protected':True})
 
 def translate(context, text, comment=None):

openlp/core/lib/htmlbuilder.py

@@ -81,17 +81,14 @@ body {
 </style>
 <script language="javascript">
     var timer = null;
+    var video_timer = null;
     var transition = %s;
 
     function show_video(state, path, volume, loop){
         var vid = document.getElementById('video');
-        if(path != null)
+        if(path != null){
             vid.src = path;
-        if(loop != null){
+            vid.load();
-            if(loop)
-                vid.loop = 'loop';
-            else
-                vid.loop = '';
         }
         if(volume != null){
             vid.volume = volume;
@@ -100,23 +97,55 @@ body {
             case 'play':
                 vid.play();
                 vid.style.display = 'block';
+                if(loop)
+                    video_timer = setInterval('video_loop()', 200);
                 break;
             case 'pause':
+                if(video_timer!=null){
+                    clearInterval(video_timer);
+                    video_timer = null;
+                }
                 vid.pause();
                 vid.style.display = 'block';
                 break;
             case 'stop':
+                if(video_timer!=null){
+                    clearInterval(video_timer);
+                    video_timer = null;
+                }
                 vid.pause();
                 vid.style.display = 'none';
+                vid.load();
                 break;
             case 'close':
+                if(video_timer!=null){
+                    clearInterval(video_timer);
+                    video_timer = null;
+                }
                 vid.pause();
                 vid.style.display = 'none';
                 vid.src = '';
                 break;
         }
     }
-
+    function video_loop(){
+        // The preferred method would be to use the video tag loop attribute
+        // But QtWebKit doesn't support this. Neither does it support the
+        // onended event, hence the setInterval()
+        // In addition, setting the currentTime attribute to zero to restart
+        // the video raises an INDEX_SIZE_ERROR: DOM Exception 1
+        // To complicate it further, sometimes vid.currentTime stops 
+        // slightly short of vid.duration and vid.ended is intermittent!
+        //
+        // Note, currently the background may go black between loops. Not 
+        // desirable. Need to investigate using two <video>'s, and hiding/
+        // preloading one, and toggle between the two when looping.
+        var vid = document.getElementById('video');
+        if(vid.ended||vid.currentTime+0.2>=vid.duration){
+            vid.load();
+            vid.play();
+        } 
+    }
     function show_image(src){
         var img = document.getElementById('image');
         img.src = src;

openlp/core/lib/mediamanageritem.py

@@ -432,7 +432,7 @@ class MediaManagerItem(QtGui.QWidget):
         raise NotImplementedError(u'MediaManagerItem.onDeleteClick needs to '
             u'be defined by the plugin')
 
-    def generateSlideData(self, service_item, item):
+    def generateSlideData(self, service_item, item=None):
         raise NotImplementedError(u'MediaManagerItem.generateSlideData needs '
             u'to be defined by the plugin')
 

openlp/core/ui/aboutdialog.py

@@ -450,7 +450,7 @@ class Ui_AboutDialog(object):
             '\n'
             'Each version is given a distinguishing version number. If the '
             'Program specifies a version number of this License which applies '
-            'to it and \"any later version\', you have the option of '
+            'to it and "any later version", you have the option of '
             'following the terms and conditions either of that version or of '
             'any later version published by the Free Software Foundation. If '
             'the Program does not specify a version number of this License, '
@@ -565,3 +565,4 @@ class Ui_AboutDialog(object):
         self.contributeButton.setText(translate('OpenLP.AboutForm',
             'Contribute'))
         self.closeButton.setText(translate('OpenLP.AboutForm', 'Close'))
+

openlp/core/ui/maindisplay.py

@@ -120,7 +120,7 @@ class MainDisplay(DisplayWidget):
         self.setScene(self.scene)
         self.webView = QtWebKit.QGraphicsWebView()
         self.scene.addItem(self.webView)
-        self.webView.resize(self.screen[u'size'].width(), \
+        self.webView.resize(self.screen[u'size'].width(),
             self.screen[u'size'].height())
         self.page = self.webView.page()
         self.frame = self.page.mainFrame()
@@ -303,6 +303,9 @@ class MainDisplay(DisplayWidget):
         Generates a preview of the image displayed.
         """
         log.debug(u'preview for %s', self.isLive)
+        # We must have a service item to preview
+        if not hasattr(self, u'serviceItem'):
+            return
         if self.isLive:
             # Wait for the fade to finish before geting the preview.
             # Important otherwise preview will have incorrect text if at all !
@@ -336,7 +339,7 @@ class MainDisplay(DisplayWidget):
         self.loaded = False
         self.initialFrame = False
         self.serviceItem = serviceItem
-        html = build_html(self.serviceItem, self.screen, self.parent.alertTab,\
+        html = build_html(self.serviceItem, self.screen, self.parent.alertTab,
             self.isLive)
         self.webView.setHtml(html)
         if serviceItem.foot_text and serviceItem.foot_text:

openlp/core/ui/plugindialog.py

@@ -93,6 +93,7 @@ class Ui_PluginViewDialog(object):
         self.pluginListButtonBox.setStandardButtons(QtGui.QDialogButtonBox.Ok)
         self.pluginListButtonBox.setObjectName(u'pluginListButtonBox')
         self.pluginLayout.addWidget(self.pluginListButtonBox)
+        self.versionNumberLabel.setText(u'')
         self.retranslateUi(pluginViewDialog)
         QtCore.QObject.connect(self.pluginListButtonBox,
             QtCore.SIGNAL(u'accepted()'), pluginViewDialog.close)
@@ -105,8 +106,6 @@ class Ui_PluginViewDialog(object):
             translate('OpenLP.PluginForm', 'Plugin Details'))
         self.versionLabel.setText(
             translate('OpenLP.PluginForm', 'Version:'))
-        self.versionNumberLabel.setText(
-            translate('OpenLP.PluginForm', 'TextLabel'))
         self.aboutLabel.setText(
             translate('OpenLP.PluginForm', 'About:'))
         self.statusLabel.setText(
@@ -115,3 +114,4 @@ class Ui_PluginViewDialog(object):
             translate('OpenLP.PluginForm', 'Active'))
         self.statusComboBox.setItemText(1,
             translate('OpenLP.PluginForm', 'Inactive'))
+

openlp/core/ui/servicemanager.py

@@ -279,7 +279,8 @@ class ServiceManager(QtGui.QWidget):
         self.editAction.setVisible(False)
         self.maintainAction.setVisible(False)
         self.notesAction.setVisible(False)
-        if serviceItem[u'service_item'].is_capable(ItemCapabilities.AllowsEdit):
+        if serviceItem[u'service_item'].is_capable(ItemCapabilities.AllowsEdit) \
+            and hasattr(serviceItem[u'service_item'], u'editId'):
             self.editAction.setVisible(True)
         if serviceItem[u'service_item']\
             .is_capable(ItemCapabilities.AllowsMaintain):

openlp/core/ui/slidecontroller.py

@@ -209,7 +209,7 @@ class SlideController(QtGui.QWidget):
             self.Toolbar.addToolbarSeparator(u'Close Separator')
             self.Toolbar.addToolbarButton(
                 u'Edit Song', u':/general/general_edit.png',
-                translate('OpenLP.SlideController', 'Edit and re-preview Song'),
+                translate('OpenLP.SlideController', 'Edit and re-preview song'),
                 self.onEditSong)
         if isLive:
             self.Toolbar.addToolbarSeparator(u'Loop Separator')
@@ -269,11 +269,11 @@ class SlideController(QtGui.QWidget):
         if isLive:
             self.SongMenu = QtGui.QToolButton(self.Toolbar)
             self.SongMenu.setText(translate('OpenLP.SlideController',
-                'Go to'))
+                'Go To'))
             self.SongMenu.setPopupMode(QtGui.QToolButton.InstantPopup)
             self.Toolbar.addToolbarWidget(u'Song Menu', self.SongMenu)
             self.SongMenu.setMenu(QtGui.QMenu(
-                translate('OpenLP.SlideController', 'Go to'),
+                translate('OpenLP.SlideController', 'Go To'),
                 self.Toolbar))
             self.Toolbar.makeWidgetsInvisible([u'Song Menu'])
         # Screen preview area

openlp/core/utils/__init__.py

@@ -112,7 +112,11 @@ class AppLocation(object):
             The directory type you want, for instance the data directory.
         """
         if dir_type == AppLocation.AppDir:
-            return os.path.abspath(os.path.split(sys.argv[0])[0])
+            if hasattr(sys, u'frozen') and sys.frozen == 1:
+                app_path = os.path.abspath(os.path.split(sys.argv[0])[0])
+            else:
+                app_path = os.path.split(openlp.__file__)[0]
+            return app_path
         elif dir_type == AppLocation.ConfigDir:
             if sys.platform == u'win32':
                 path = os.path.join(os.getenv(u'APPDATA'), u'openlp')

openlp/core/utils/languagemanager.py

@@ -55,7 +55,7 @@ class LanguageManager(object):
         if LanguageManager.AutoLanguage:
             language = QtCore.QLocale.system().name()
         lang_path = AppLocation.get_directory(AppLocation.AppDir)
-        lang_path = os.path.join(lang_path, u'resources', u'i18n')
+        lang_path = os.path.join(lang_path, u'i18n')
         app_translator = QtCore.QTranslator()
         if app_translator.load("openlp_" + language, lang_path):
             return app_translator
@@ -66,7 +66,7 @@ class LanguageManager(object):
         Find all available language files in this OpenLP install
         """
         trans_dir = AppLocation.get_directory(AppLocation.AppDir)
-        trans_dir = QtCore.QDir(os.path.join(trans_dir, u'openlp', u'i18n'))
+        trans_dir = QtCore.QDir(os.path.join(trans_dir, u'i18n'))
         file_names = trans_dir.entryList(QtCore.QStringList("*.qm"),
                 QtCore.QDir.Files, QtCore.QDir.Name)
         for name in file_names:

openlp/plugins/bibles/lib/mediaitem.py

@@ -678,7 +678,8 @@ class BibleMediaItem(MediaManagerItem):
                         self.dual_search_results[count].text)
                 }
                 bible_text = u' %s %d:%d (%s, %s)' % (verse.book.name,
-                    verse.chapter, verse.verse, version.value, dual_version.value)
+                    verse.chapter, verse.verse, version.value,
+                    dual_version.value)
             else:
                 vdict = {
                     'book': QtCore.QVariant(verse.book.name),

openlp/plugins/bibles/lib/opensong.py

@@ -89,7 +89,7 @@ class OpenSongBible(BibleDB):
                         Receiver.send_message(u'openlp_process_events')
                     self.wizard.incrementProgressBar(
                         QtCore.QString('%s %s %s' % (
-                            translate('BiblesPlugin.Opensong', 'Importing'), \
+                            translate('BiblesPlugin.Opensong', 'Importing'),
                             db_book.name, chapter.attrib[u'n'])))
                     self.session.commit()
         except IOError:

openlp/plugins/presentations/lib/mediaitem.py

@@ -212,7 +212,7 @@ class PresentationMediaItem(MediaManagerItem):
                         self, translate('PresentationPlugin.MediaItem',
                         'Unsupported File'),
                         translate('PresentationPlugin.MediaItem',
-                        'This type of presentation is not supported'))
+                        'This type of presentation is not supported.'))
                     continue
             item_name = QtGui.QListWidgetItem(filename)
             item_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(file))

openlp/plugins/songs/forms/editsongdialog.py

@@ -258,10 +258,11 @@ class Ui_EditSongDialog(object):
         self.TopicBookLayout.addWidget(self.TopicGroupBox)
         self.SongBookGroup = QtGui.QGroupBox(self.TopicBookWidget)
         self.SongBookGroup.setObjectName(u'SongBookGroup')
-        self.SongbookLayout = QtGui.QGridLayout(self.SongBookGroup)
+        self.SongbookLayout = QtGui.QFormLayout(self.SongBookGroup)
         self.SongbookLayout.setMargin(8)
         self.SongbookLayout.setSpacing(8)
         self.SongbookLayout.setObjectName(u'SongbookLayout')
+        self.SongbookNameLabel = QtGui.QLabel(self.SongBookGroup)
         self.SongbookCombo = QtGui.QComboBox(self.SongBookGroup)
         sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.MinimumExpanding,
             QtGui.QSizePolicy.Fixed)
@@ -272,13 +273,11 @@ class Ui_EditSongDialog(object):
         self.SongbookCombo.setEditable(True)
         self.SongbookCombo.setSizePolicy(sizePolicy)
         self.SongbookCombo.setObjectName(u'SongbookCombo')
-        self.SongbookLayout.addWidget(self.SongbookCombo, 0, 0, 1, 1)
+        self.SongbookLayout.addRow(self.SongbookNameLabel, self.SongbookCombo)
         self.songBookNumberLabel = QtGui.QLabel(self.SongBookGroup)
-        self.SongbookLayout.addWidget(self.songBookNumberLabel, 0, 1, 1, 1)
         self.songBookNumberEdit = QtGui.QLineEdit(self.SongBookGroup)
-        self.songBookNumberLabel.setBuddy(self.songBookNumberEdit)
+        self.SongbookLayout.addRow(self.songBookNumberLabel,
-        self.songBookNumberEdit.setMaximumWidth(35)
+            self.songBookNumberEdit)
-        self.SongbookLayout.addWidget(self.songBookNumberEdit, 0, 2, 1, 1)
         self.TopicBookLayout.addWidget(self.SongBookGroup)
         self.AuthorsTabLayout.addWidget(self.TopicBookWidget)
         self.SongTabWidget.addTab(self.AuthorsTab, u'')
@@ -446,8 +445,10 @@ class Ui_EditSongDialog(object):
             translate('SongsPlugin.EditSongForm', 'R&emove'))
         self.SongBookGroup.setTitle(
             translate('SongsPlugin.EditSongForm', 'Song Book'))
+        self.SongbookNameLabel.setText(translate('SongsPlugin.EditSongForm',
+            'Book:'))
         self.songBookNumberLabel.setText(translate('SongsPlugin.EditSongForm',
-            'Song No.:'))
+            'Number:'))
         self.SongTabWidget.setTabText(
             self.SongTabWidget.indexOf(self.AuthorsTab),
             translate('SongsPlugin.EditSongForm',

openlp/plugins/songs/lib/cclifileimport.py

@@ -81,14 +81,15 @@ class CCLIFileImport(SongImport):
                 lines = infile.readlines()
                 ext = os.path.splitext(filename)[1]
                 if ext.lower() == ".usr":
-                    log.info(u'SongSelect .usr format file found %s: ' ,  filename)
+                    log.info(u'SongSelect .usr format file found %s: ',
+                        filename)
                     self.do_import_usr_file(lines)
                 elif ext.lower() == ".txt":
-                    log.info(u'SongSelect .txt format file found %s: ', filename)
+                    log.info(u'SongSelect .txt format file found %s: ',
+                        filename)
                     self.do_import_txt_file(lines)
                 else:
                     log.info(u'Extension %s is not valid', filename)
-                    pass
                 song_count += 1
             if self.stop_import_flag:
                 return False
@@ -175,7 +176,7 @@ class CCLIFileImport(SongImport):
             verse_text = unicode(words_list[counter])
             verse_text = verse_text.replace("/n",  "\n")
             if len(verse_text) > 0:
-                self.add_verse(verse_text, verse_type);
+                self.add_verse(verse_text, verse_type)
         #Handle multiple authors
         author_list = song_author.split(u'/')
         if len(author_list) < 2:
@@ -238,12 +239,12 @@ class CCLIFileImport(SongImport):
         line_number = 0
         verse_text = u''
         song_comments = u''
-        song_copyright = u'';
+        song_copyright = u''
         verse_start = False
         for line in textList:
             clean_line = line.strip()
             if not clean_line:
-                if line_number==0:
+                if line_number == 0:
                     continue
                 elif verse_start:
                     if verse_text:
@@ -252,11 +253,11 @@ class CCLIFileImport(SongImport):
                         verse_start = False
             else:
                 #line_number=0, song title
-                if line_number==0:
+                if line_number == 0:
                     song_name = clean_line
                     line_number += 1
                 #line_number=1, verses
-                elif line_number==1:
+                elif line_number == 1:
                     #line_number=1, ccli number, first line after verses
                     if clean_line.startswith(u'CCLI'):
                         line_number += 1
@@ -285,15 +286,16 @@ class CCLIFileImport(SongImport):
                         verse_text = verse_text + line
                 else:
                     #line_number=2, copyright
-                    if line_number==2:
+                    if line_number == 2:
                         line_number += 1
                         song_copyright = clean_line
                     #n=3, authors
-                    elif line_number==3:
+                    elif line_number == 3:
                         line_number += 1
                         song_author = clean_line
                     #line_number=4, comments lines before last line
-                    elif (line_number==4) and (not clean_line.startswith(u'CCL')):
+                    elif (line_number == 4) and \
+                        (not clean_line.startswith(u'CCL')):
                         song_comments = song_comments + clean_line
         # split on known separators
         author_list = song_author.split(u'/')
@@ -307,4 +309,3 @@ class CCLIFileImport(SongImport):
         self.ccli_number = song_ccli
         self.comments = song_comments
         self.finish()
-        

openlp/plugins/songs/lib/opensongimport.py

@@ -30,6 +30,7 @@ from zipfile import ZipFile
 from lxml import objectify
 from lxml.etree import Error, LxmlError
 
+from openlp.core.lib import translate
 from openlp.plugins.songs.lib.songimport import SongImport
 
 log = logging.getLogger(__name__)
@@ -170,7 +171,7 @@ class OpenSongImport(SongImport):
         self.authors = []
         try:
             tree = objectify.parse(file)
-        except Error, LxmlError:
+        except (Error, LxmlError):
             log.exception(u'Error parsing XML')
             return
         root = tree.getroot()
@@ -276,7 +277,8 @@ class OpenSongImport(SongImport):
             if len(our_verse_order) > 0:
                 order = our_verse_order
             else:
-                log.warn(u'No verse order available for %s, skipping.', self.title)
+                log.warn(u'No verse order available for %s, skipping.',
+                    self.title)
         for tag in order:
             if len(tag) == 1:
                 tag = tag + u'1' # Assume it's no.1 if it's not there

openlp/plugins/songs/lib/wowimport.py

@@ -119,7 +119,7 @@ class WowImport(SongImport):
                 # TODO: check that it is a valid words of worship file (could 
                 # check header for WoW File Song Word)
                 self.author = u''
-                self.copyright= u''
+                self.copyright = u''
                 # Get the song title
                 self.file_name = os.path.split(file)[1]
                 self.import_wizard.incrementProgressBar(

scripts/translation_utils.py

@@ -24,13 +24,31 @@
 # with this program; if not, write to the Free Software Foundation, Inc., 59  #
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
-# Short description
-# Steps for creating languages:
-# 1. make sure that the openlp_en.ts file exist
-# 2. go to scripts folder and start:
-#     python translation_utils.py -a
-###############################################################################
 
+"""
+This script is used to maintain the translation files in OpenLP. It downloads
+the latest translation files from the Pootle translation server, updates the
+local translation files from both the source code and the files from Pootle,
+and can also generate the compiled translation files.
+
+Create New Language
+-------------------
+
+To create a new language, simply run this script with the ``-a`` command line
+option::
+
+    @:~$ ./translation_utils.py -a
+
+Update Translation Files
+------------------------
+
+The best way to update the translations is to download the files from Pootle,
+and then update the local files using both the downloaded files and the source.
+This is done easily via the ``-d``, ``-p`` and ``-u`` options::
+
+    @:~$ ./translation_utils.py -dpu
+
+"""
 import os
 import urllib
 import re
@@ -39,201 +57,277 @@ from optparse import OptionParser
 from PyQt4 import QtCore
 from BeautifulSoup import BeautifulSoup
 
-class TranslationUtils(object):
+SERVER_URL = u'http://pootle.projecthq.biz/export/openlp/'
+IGNORED_PATHS = [u'scripts']
+IGNORED_FILES = [u'setup.py']
+
+verbose_mode = False
+
+class Command(object):
+    """
+    Provide an enumeration of commands.
+    """
+    Download = 1
+    Create = 2
+    Prepare = 3
+    Update = 4
+    Generate = 5
+
+class CommandStack(object):
+    """
+    This class provides an iterable stack.
+    """
     def __init__(self):
-        self.ignore_paths = [u'./scripts']
+        self.current_index = 0
-        self.ignore_files = [u'setup.py']
+        self.data = []
-        self.server_url = u'http://pootle.projecthq.biz/export/openlp/'
-        self.cmd_stack = []
-        self.stack_count = 0
-        self.verbose = False
 
+    def __len__(self):
+        return len(self.data)
 
-    def process_stack(self):
+    def __getitem__(self, index):
-        if len(self.cmd_stack) > 0:
+        if self.data[index].get(u'arguments'):
-            if len(self.cmd_stack) == self.stack_count:
+            return self.data[index][u'command'], self.data[index][u'arguments']
-                print u'Process %d commands' % self.stack_count
-            print u'%d. ' % (self.stack_count-len(self.cmd_stack)+1),
-            command = self.cmd_stack.pop(0)
-            if len(command) > 1:
-                command[0](command[1])
         else:
-                command[0]()
+            return self.data[index][u'command']
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        if self.current_index == len(self.data):
+            raise StopIteration
         else:
-            print "Finished all commands"
+            current_item = self.data[self.current_index][u'command']
+            self.current_index += 1
+            return current_item
+
+    def append(self, command, **kwargs):
+        data = {u'command': command}
+        if u'arguments' in kwargs:
+            data[u'arguments'] = kwargs[u'arguments']
+        self.data.append(data)
+
+    def reset(self):
+        self.current_index = 0
 
 
-    def downloadTranslations(self):
+def print_verbose(text):
-        print 'Download Translation files from HQ-Server'
+    """
-        page = urllib.urlopen(u'%s' % (self.server_url))
+    This method checks to see if we are in verbose mode, and if so prints
-        soup = BeautifulSoup(page)
+    ``text`` out.
-        languages = soup.findAll(text=re.compile(".*\.ts"))
-        for language in languages:
-            filename = os.path.join(u'..', u'resources', u'i18n',
-                u'openlp_%s' % language)
-            self.printVerbose(u'Get Translation File: %s' % filename)
-            self.get_and_write_file(language, filename)
-        print u'  done'
-        self.process_stack()
 
-    def get_and_write_file(self, language, filename):
+    ``text``
-        page = urllib.urlopen(u'%s%s' % (self.server_url, language))
+        The text to print.
+    """
+    global verbose_mode
+    if verbose_mode:
+        print u'    %s' % text
+
+def run(command):
+    """
+    This method runs an external application.
+
+    ``command``
+        The command to run.
+    """
+    print_verbose(command)
+    process = QtCore.QProcess()
+    process.start(command)
+    while (process.waitForReadyRead()):
+        print_verbose(u'ReadyRead: %s' % QtCore.QString(process.readAll()))
+    print_verbose(u'Error(s):\n%s' % process.readAllStandardError())
+    print_verbose(u'Output:\n%s' % process.readAllStandardOutput())
+    print u'   Done.'
+
+def download_file(source_filename, dest_filename):
+    """
+    Download a file and save it to disk.
+
+    ``source_filename``
+        The file to download.
+
+    ``dest_filename``
+        The new local file name.
+    """
+    print_verbose(u'Downloading from: %s' % (SERVER_URL + source_filename))
+    page = urllib.urlopen(SERVER_URL + source_filename)
     content = page.read().decode('utf8')
     page.close()
-        file = open(filename, u'w')
+    file = open(dest_filename, u'w')
     file.write(content.encode('utf8'))
     file.close()
 
-    def creation(self, language):
+def download_translations():
-        print "Create new Translation File"
     """
-            Use this option to create a new translation file
+    This method downloads the translation files from the Pootle server.
-            this function: 
-                * create the new *.ts file
     """
-        filename = os.path.join(u'..', u'resources', u'i18n',
+    print 'Download translation files from Pootle'
-                u'openlp_%s.ts' % language)
+    page = urllib.urlopen(SERVER_URL)
-        self.get_and_write_file(u'en.ts', filename)
+    soup = BeautifulSoup(page)
-        self.printVerbose("""
+    languages = soup.findAll(text=re.compile(r'.*\.ts'))
-            Please remind: For permanent providing this language:
+    for language in languages:
-            this language name have to append to the global list 
+        filename = os.path.join(os.path.abspath(u'..'), u'resources', u'i18n',
-            variable "translations" in this file
+            language)
-            and this file have to be uploaded to the Pootle Server
+        print_verbose(u'Get Translation File: %s' % filename)
-            Please contact the developers!
+        download_file(language, filename)
-            """)
+    print u'   Done.'
-        print u'  done'
-        self.process_stack()
 
-        
+def prepare_project():
-    def preparation(self):
+    """
+    This method creates the project file needed to update the translation files
+    and compile them into .qm files.
+    """
     print u'Generating the openlp.pro file'
-        stringlist = []
+    lines = []
-        start_dir = os.path.join(u'..')
+    start_dir = os.path.abspath(u'..')
+    start_dir = start_dir + os.sep
+    print_verbose(u'Starting directory: %s' % start_dir)
     for root, dirs, files in os.walk(start_dir):
         for file in files:
-                path = u'%s' % root
+            path = root.replace(start_dir, u'').replace(u'\\', u'/') #.replace(u'..', u'.')
-                path = path.replace('\\','/')
-                path = path.replace('..','.')
-                
             if file.startswith(u'hook-') or file.startswith(u'test_'):
                continue
-
+            ignore = False
-                cond = False
+            for ignored_path in IGNORED_PATHS:
-                for search in self.ignore_paths:
+                if path.startswith(ignored_path):
-                    if path.startswith(search):
+                    ignore = True
-                        cond = True
+                    break
-                if cond:
+            if ignore:
                 continue
-                cond = False
+            ignore = False
-                for search in self.ignore_files:
+            for ignored_file in IGNORED_FILES:
-                    if search == file:
+                if file == ignored_file:
-                        cond = True
+                    ignore = True
-                if cond:
+                    break
+            if ignore:
                 continue
-                
+            if file.endswith(u'.py') or file.endswith(u'.pyw'):
-                if file.endswith(u'.py'):
+                if path:
                     line = u'%s/%s' % (path, file)
-                    self.printVerbose(u'Parsing "%s"' % line)
+                else:
-                    stringlist.append(u'SOURCES      += %s' % line)
+                    line = file
-                elif file.endswith(u'.pyw'):
+                print_verbose(u'Parsing "%s"' % line)
-                    line = u'%s/%s' % (path, file)
+                lines.append(u'SOURCES      += %s' % line)
-                    self.printVerbose(u'Parsing "%s"' % line)
-                    stringlist.append(u'SOURCES      += %s' % line)
             elif file.endswith(u'.ts'):
                 line = u'%s/%s' % (path, file)
-                    self.printVerbose(u'Parsing "%s"' % line)
+                print_verbose(u'Parsing "%s"' % line)
-                    stringlist.append(u'TRANSLATIONS += %s' % line)
+                lines.append(u'TRANSLATIONS += %s' % line)
-                
+    lines.sort()
-        stringlist.sort()
+    file = open(os.path.join(start_dir, u'openlp.pro'), u'w')
-        self.write_file(os.path.join(start_dir, u'openlp.pro'), stringlist)
+    file.write(u'\n'.join(lines).encode('utf8'))
-        print u'  done'
-        self.process_stack()
-
-    def update(self):
-        print u'Update the translation files'
-        cmd = u'pylupdate4 -verbose -noobsolete ../openlp.pro'
-        self.start_cmd(cmd)
-
-    def generate(self):
-        print u'Generate the related *.qm files'
-        cmd = u'lrelease ../openlp.pro'
-        self.start_cmd(cmd)
-        
-    def write_file(self, filename, stringlist):
-        content = u''
-        for line in stringlist:
-            content = u'%s%s\n' % (content, line)
-        file = open(filename, u'w')
-        file.write(content.encode('utf8'))
     file.close()
+    print u'   Done.'
 
-    def printVerbose(self, data):
+def update_translations():
-        if self.verbose:
+    print u'Update the translation files'
-            print u'    %s' % data
+    if not os.path.exists(os.path.join(os.path.abspath(u'..'), u'openlp.pro')):
+        print u'You have no generated a project file yet, please run this ' + \
+            u'script with the -p option.'
+        return
+    else:
+        os.chdir(os.path.abspath(u'..'))
+        run(u'pylupdate4 -verbose -noobsolete openlp.pro')
 
-    def start_cmd(self, command):
+def generate_binaries():
-        self.printVerbose(command)
+    print u'Generate the related *.qm files'
-        self.process = QtCore.QProcess()
+    if not os.path.exists(os.path.join(os.path.abspath(u'..'), u'openlp.pro')):
-        self.process.start(command)
+        print u'You have no generated a project file yet, please run this ' + \
-        while (self.process.waitForReadyRead()):
+            u'script with the -p option. It is also recommended that you ' + \
-            self.printVerbose(u'ReadyRead: %s' % QtCore.QString(self.process.readAll()))
+            u'this script with the -u option to update the translation ' + \
-        self.printVerbose(self.process.readAllStandardError())
+            u'files as well.'
-        self.printVerbose(self.process.readAllStandardOutput())
+        return
-        print u'  done'
+    else:
-        self.process_stack()
+        os.chdir(os.path.abspath(u'..'))
+        run(u'lrelease openlp.pro')
 
+def create_translation(language):
+    """
+    This method creates a new translation file.
+
+    ``language``
+        The language file to create.
+    """
+    print "Create new Translation File"
+    filename = os.path.join(os.path.abspath(u'..'), u'resources', u'i18n', language)
+    download_file(u'en.ts', filename)
+    print u'\n** Please Note **\n'
+    print u'In order to get this file into OpenLP and onto the Pootle ' + \
+        u'translation server you will need to subscribe to the OpenLP' + \
+        u'Translators mailing list, and request that your language file ' + \
+        u'be added to the project.\n'
+    print u'   Done'
+
+def process_stack(command_stack):
+    """
+    This method looks at the commands in the command stack, and processes them
+    in the order they are in the stack.
+
+    ``command_stack``
+        The command stack to process.
+    """
+    if command_stack:
+        print u'Processing %d commands...' % len(command_stack)
+        for command in command_stack:
+            print u'%d.' % (command_stack.current_index),
+            if command == Command.Download:
+                download_translations()
+            elif command == Command.Prepare:
+                prepare_project()
+            elif command == Command.Update:
+                update_translations()
+            elif command == Command.Generate:
+                generate_binaries()
+            elif command == Command.Create:
+                command, arguments = command_stack[command_stack.current_index]
+                create_translation(*arguments)
+        print u'Finished processing commands.'
+    else:
+        print u'No commands to process.'
 
 def main():
-    # start Main Class
+    global verbose_mode
-    Util = TranslationUtils()
-    
     # Set up command line options.
-    usage = u'''
+    usage = u'%prog [options]\nOptions are parsed in the order they are ' + \
-        This script handle the translation files for OpenLP.
+        u'listed below. If no options are given, "-dpug" will be used.\n\n' + \
-        Usage: %prog [options]
+        u'This script is used to manage OpenLP\'s translation files.'
-        If no option will be used, options "-d -p -u -g" will be set automatically
-        '''
     parser = OptionParser(usage=usage)
-    parser.add_option('-d', '--download-ts', action='store_true',
+    parser.add_option('-d', '--download-ts', dest='download',
-        dest='download', help='Load languages from Pootle Server')
+        action='store_true', help='download language files from Pootle')
-    parser.add_option('-c', '--create', metavar='lang',
+    parser.add_option('-c', '--create', dest=u'create', metavar='LANG',
-        help='creation of new translation file, Parameter: language (e.g. "en_GB"')
+        help='create a new translation file for language LANG, e.g. "en_GB"')
-    parser.add_option('-p', '--prepare', action='store_true', dest='prepare',
+    parser.add_option('-p', '--prepare', dest='prepare', action='store_true',
-        help='preparation (generate pro file)')
+        help='generate a project file, used to update the translations')
     parser.add_option('-u', '--update', action='store_true', dest='update',
-        help='update translation files')
+        help='update translation files (needs a project file)')
-    parser.add_option('-g', '--generate', action='store_true', dest='generate',
+    parser.add_option('-g', '--generate', dest='generate', action='store_true',
-        help='generate qm files')
+        help='compile .ts files into .qm files')
-    parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
+    parser.add_option('-v', '--verbose', dest='verbose', action='store_true',
-        help='Give more informations while processing')
+        help='show extra information while processing translations')
-
     (options, args) = parser.parse_args()
+    # Create and populate the command stack
+    command_stack = CommandStack()
     if options.download:
-        Util.cmd_stack.append([Util.downloadTranslations])
+        command_stack.append(Command.Download)
     if options.create:
-        Util.cmd_stack.append([Util.creation, u'%s' % options.create])
+        command_stack.append(Command.Create, arguments=[options.create])
     if options.prepare:
-        Util.cmd_stack.append([Util.preparation])
+        command_stack.append(Command.Prepare)
     if options.update:
-        Util.cmd_stack.append([Util.update])
+        command_stack.append(Command.Update)
     if options.generate:
-        Util.cmd_stack.append([Util.generate])
+        command_stack.append(Command.Generate)
-    if options.verbose:
+    verbose_mode = options.verbose
-        Util.verbose = True
+    if not command_stack:
-
+        command_stack.append(Command.Download)
-    if len(Util.cmd_stack) == 0:
+        command_stack.append(Command.Prepare)
-        Util.cmd_stack.append([Util.downloadTranslations])
+        command_stack.append(Command.Update)
-        Util.cmd_stack.append([Util.preparation])
+        command_stack.append(Command.Generate)
-        Util.cmd_stack.append([Util.update])
+    # Process the commands
-        Util.cmd_stack.append([Util.generate])
+    process_stack(command_stack)
-
-    Util.stack_count = len(Util.cmd_stack)
-    Util.process_stack()
-    
-
 
 if __name__ == u'__main__':
     if os.path.split(os.path.abspath(u'.'))[1] != u'scripts':
         print u'You need to run this script from the scripts directory.'
     else:
         main()
+