update

.bzrignore

@@ -14,3 +14,4 @@ dist
 OpenLP.egg-info
 build
 resources/innosetup/Output
+_eric4project

documentation/source/core/lib.rst

@@ -36,12 +36,6 @@
 .. autoclass:: openlp.core.lib.plugin.Plugin
    :members:
 
-:mod:`PluginConfig`
--------------------
-
-.. autoclass:: openlp.core.lib.pluginconfig.PluginConfig
-   :members:
-
 :mod:`PluginManager`
 --------------------
 

openlp.pyw

@@ -34,10 +34,10 @@ from PyQt4 import QtCore, QtGui
 
 log = logging.getLogger()
 
-from openlp.core.lib import Receiver, str_to_bool
+from openlp.core.lib import Receiver
 from openlp.core.resources import qInitResources
 from openlp.core.ui import MainWindow, SplashScreen, ScreenList
-from openlp.core.utils import AppLocation, ConfigHelper, LanguageManager
+from openlp.core.utils import AppLocation, LanguageManager
 
 application_stylesheet = u"""
 QMainWindow::separator
@@ -110,20 +110,17 @@ class OpenLP(QtGui.QApplication):
         finally:
             if fversion:
                 fversion.close()
-        #set the default string encoding
-        try:
-            sys.setappdefaultencoding(u'utf-8')
-        except:
-            pass
         #provide a listener for widgets to reqest a screen update.
         QtCore.QObject.connect(Receiver.get_receiver(),
             QtCore.SIGNAL(u'openlp_process_events'), self.processEvents)
+        self.setOrganizationName(u'OpenLP')
+        self.setOrganizationDomain(u'openlp.org')
         self.setApplicationName(u'OpenLP')
         self.setApplicationVersion(app_version[u'version'])
         if os.name == u'nt':
             self.setStyleSheet(application_stylesheet)
-        show_splash = str_to_bool(ConfigHelper.get_registry().get_value(
+        show_splash = QtCore.QSettings().value(
-            u'general', u'show splash', True))
+            u'general/show splash', QtCore.QVariant(True)).toBool()
         if show_splash:
             self.splash = SplashScreen(self.applicationVersion())
             self.splash.show()
@@ -133,8 +130,8 @@ class OpenLP(QtGui.QApplication):
         # Decide how many screens we have and their size
         for screen in xrange(0, self.desktop().numScreens()):
             screens.add_screen({u'number': screen,
-                            u'size': self.desktop().availableGeometry(screen),
+                u'size': self.desktop().availableGeometry(screen),
-                            u'primary': (self.desktop().primaryScreen() == screen)})
+                u'primary': (self.desktop().primaryScreen() == screen)})
             log.info(u'Screen %d found with resolution %s',
                 screen, self.desktop().availableGeometry(screen))
         # start the main app window
@@ -204,4 +201,4 @@ if __name__ == u'__main__':
     """
     Instantiate and run the application.
     """
-    main()
+    main()

openlp/core/lib/__init__.py

@@ -164,7 +164,6 @@ class ThemeLevel(object):
 
 from eventreceiver import Receiver
 from settingsmanager import SettingsManager
-from pluginconfig import PluginConfig
 from plugin import PluginStatus, Plugin
 from pluginmanager import PluginManager
 from settingstab import SettingsTab

openlp/core/lib/dockwidget.py

@@ -43,8 +43,3 @@ class OpenLPDockWidget(QtGui.QDockWidget):
             self.setObjectName(name)
         self.setFloating(False)
         log.debug(u'Init done')
-
-    def closeEvent(self, event):
-        self.parent.settingsmanager.setUIItemVisibility(
-            self.objectName(), False)
-        event.accept()

openlp/core/lib/mediamanageritem.py

@@ -29,7 +29,8 @@ import os
 from PyQt4 import QtCore, QtGui
 
 from openlp.core.lib.toolbar import *
-from openlp.core.lib import contextMenuAction, contextMenuSeparator
+from openlp.core.lib import contextMenuAction, contextMenuSeparator, \
+    SettingsManager
 from serviceitem import ServiceItem
 
 log = logging.getLogger(__name__)
@@ -69,7 +70,7 @@ class MediaManagerItem(QtGui.QWidget):
         The user visible name for a plugin which should use a suitable
         translation function.
 
-     ``self.ConfigSection``
+     ``self.SettingsSection``
         The section in the configuration where the items in the media
         manager are stored. This could potentially be
         ``self.PluginNameShort.lower()``.
@@ -334,13 +335,15 @@ class MediaManagerItem(QtGui.QWidget):
     def onFileClick(self):
         files = QtGui.QFileDialog.getOpenFileNames(
             self, self.OnNewPrompt,
-            self.parent.config.get_last_dir(), self.OnNewFileMasks)
+            SettingsManager.get_last_dir(self.SettingsSection),
+            self.OnNewFileMasks)
         log.info(u'New files(s) %s', unicode(files))
         if files:
             self.loadList(files)
             dir, filename = os.path.split(unicode(files[0]))
-            self.parent.config.set_last_dir(dir)
+            SettingsManager.set_last_dir(self.SettingsSection, dir)
-            self.parent.config.set_list(self.ConfigSection, self.getFileList())
+            SettingsManager.set_list(
+                self.SettingsSection, self.SettingsSection, self.getFileList())
 
     def getFileList(self):
         count = 0
@@ -451,7 +454,8 @@ class MediaManagerItem(QtGui.QWidget):
             if not service_item:
                 QtGui.QMessageBox.information(self,
                     self.trUtf8('No Service Item Selected'),
-                    self.trUtf8('You must select a existing service item to add to.'))
+                    self.trUtf8(
+                        'You must select an existing service item to add to.'))
             elif self.title.lower() == service_item.name.lower():
                 self.generateSlideData(service_item)
                 self.parent.service_manager.addServiceItem(service_item, 
@@ -460,7 +464,8 @@ class MediaManagerItem(QtGui.QWidget):
                 #Turn off the remote edit update message indicator
                 QtGui.QMessageBox.information(self,
                     self.trUtf8('Invalid Service Item'),
-                    self.trUtf8(unicode('You must select a %s service item.' % self.title)))
+                    self.trUtf8(unicode(
+                        'You must select a %s service item.' % self.title)))
 
     def buildServiceItem(self, item=None):
         """

openlp/core/lib/plugin.py

@@ -24,9 +24,10 @@
 ###############################################################################
 
 import logging
+
 from PyQt4 import QtCore
 
-from openlp.core.lib import PluginConfig, Receiver
+from openlp.core.lib import Receiver
 
 log = logging.getLogger(__name__)
 
@@ -50,13 +51,12 @@ class Plugin(QtCore.QObject):
     ``version``
         The version number of this iteration of the plugin.
 
+    ``settings_section``
+        The namespace to store settings for the plugin.
+
     ``icon``
         An instance of QIcon, which holds an icon for this plugin.
 
-    ``config``
-        An instance of PluginConfig, which allows plugins to read and write to
-        openlp.org's configuration. This is pre-instantiated.
-
     ``log``
         A log object used to log debugging messages. This is pre-instantiated.
 
@@ -78,7 +78,8 @@ class Plugin(QtCore.QObject):
         Add an item to the Export menu.
 
     ``get_settings_tab()``
-        Returns an instance of SettingsTabItem to be used in the Settings dialog.
+        Returns an instance of SettingsTabItem to be used in the Settings
+        dialog.
 
     ``add_to_menu(menubar)``
         A method to add a menu item to anywhere in the menu, given the menu bar.
@@ -115,8 +116,8 @@ class Plugin(QtCore.QObject):
         self.name = name
         if version:
             self.version = version
+        self.settings_section = self.name.lower()
         self.icon = None
-        self.config = PluginConfig(self.name)
         self.weight = 0
         self.status = PluginStatus.Inactive
         # Set up logging
@@ -125,7 +126,7 @@ class Plugin(QtCore.QObject):
         self.live_controller = plugin_helpers[u'live']
         self.render_manager = plugin_helpers[u'render']
         self.service_manager = plugin_helpers[u'service']
-        self.settings = plugin_helpers[u'settings']
+        self.settings_form = plugin_helpers[u'settings form']
         self.mediadock = plugin_helpers[u'toolbox']
         self.maindisplay = plugin_helpers[u'maindisplay']
         QtCore.QObject.connect(Receiver.get_receiver(),
@@ -145,15 +146,17 @@ class Plugin(QtCore.QObject):
         """
         Sets the status of the plugin
         """
-        self.status = int(self.config.get_config(u'status',
+        self.status = QtCore.QSettings().value(
-            PluginStatus.Inactive))
+            self.settings_section + u'/status',
+            QtCore.QVariant(PluginStatus.Inactive)).toInt()[0]
 
     def toggle_status(self, new_status):
         """
         Changes the status of the plugin and remembers it
         """
         self.status = new_status
-        self.config.set_config(u'status', self.status)
+        QtCore.QSettings().setValue(
+            self.settings_section + u'/status', QtCore.QVariant(self.status))
 
     def is_active(self):
         """
@@ -216,7 +219,8 @@ class Plugin(QtCore.QObject):
         """
         Generic Drag and drop handler triggered from service_manager.
         """
-        log.debug(u'process_add_service_event event called for plugin %s' % self.name)
+        log.debug(u'process_add_service_event event called for plugin %s' %
+            self.name)
         self.media_item.onAddClick()
 
     def about(self):
@@ -244,7 +248,7 @@ class Plugin(QtCore.QObject):
         Called by the plugin to remove toolbar
         """
         self.mediadock.remove_dock(self.name)
-        self.settings.removeTab(self.name)
+        self.settings_form.removeTab(self.name)
 
     def insert_toolbox_item(self):
         """
@@ -253,7 +257,7 @@ class Plugin(QtCore.QObject):
         if self.media_item:
             self.mediadock.insert_dock(self.media_item, self.icon, self.weight)
         if self.settings_tab:
-            self.settings.insertTab(self.settings_tab, self.weight)
+            self.settings_form.insertTab(self.settings_tab, self.weight)
 
     def can_delete_theme(self, theme):
         """

openlp/core/lib/pluginconfig.py

@@ -1,194 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4
-
-###############################################################################
-# OpenLP - Open Source Lyrics Projection                                      #
-# --------------------------------------------------------------------------- #
-# Copyright (c) 2008-2010 Raoul Snyman                                        #
-# Portions copyright (c) 2008-2010 Tim Bentley, Jonathan Corwin, Michael      #
-# Gorven, Scott Guerrieri, Christian Richter, Maikel Stuivenberg, Martin      #
-# Thompson, Jon Tibble, Carsten Tinggaard                                     #
-# --------------------------------------------------------------------------- #
-# 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 os
-
-from openlp.core.utils import ConfigHelper
-
-class PluginConfig(object):
-    """
-    This is a generic config helper for plugins.
-    """
-    def __init__(self, plugin_name):
-        """
-        Initialise the plugin config object, setting the section name to the
-        plugin name.
-
-        ``plugin_name``
-            The name of the plugin to use as a section name.
-        """
-        self.section = plugin_name.lower()
-
-    def get_config(self, key, default=None):
-        """
-        Get a configuration value from the configuration registry.
-
-        ``key``
-            The name of configuration to load.
-
-        ``default``
-            Defaults to *None*. The default value to return if there is no
-            other value.
-        """
-        return ConfigHelper.get_config(self.section, key, default)
-
-    def delete_config(self, key):
-        """
-        Delete a configuration value from the configuration registry.
-
-        ``key``
-            The name of the configuration to remove.
-        """
-        return ConfigHelper.delete_config(self.section, key)
-
-    def set_config(self, key, value):
-        """
-        Set a configuration value in the configuration registry.
-
-        ``key``
-            The name of the configuration to save.
-
-        ``value``
-            The value of the configuration to save.
-        """
-        return ConfigHelper.set_config(self.section, key, value)
-
-    def get_data_path(self):
-        """
-        Dynamically build the data file path for a plugin.
-        """
-        #app_data = ConfigHelper.get_data_path()
-        app_data = ConfigHelper.get_data_path()
-        safe_name = self.section.replace(u' ',u'-')
-        plugin_data = self.get_config(u'data path', safe_name)
-        path = os.path.join(app_data, plugin_data)
-        if not os.path.exists(path):
-            os.makedirs(path)
-        return path
-
-    def set_data_path(self, path):
-        """
-        Set the data file path.
-
-        ``path``
-            The path to save.
-        """
-        return self.set_config(u'data path', os.path.basename(path))
-
-    def get_files(self, suffix=None):
-        """
-        Get a list of files from the data files path.
-
-        ``suffix``
-            Defaults to *None*. The extension to search for.
-        """
-        try:
-            files = os.listdir(self.get_data_path())
-        except:
-            return []
-        if suffix:
-            return_files = []
-            for file in files:
-                if file.find(u'.') != -1:
-                    filename = file.split(u'.')
-                    #bname = nme[0]
-                    filesuffix = filename[1].lower()
-                    filesuffix = filesuffix.lower()
-                    # only load files with the correct suffix
-                    if suffix.find(filesuffix) > -1 :
-                        return_files.append(file)
-            return return_files
-        else:
-            # no filtering required
-            return files
-
-    def load_list(self, name):
-        """
-        Load a list from the config file.
-
-        ``name``
-            The name of the list.
-        """
-        list_count = self.get_config(u'%s count' % name)
-        if list_count:
-            list_count = int(list_count)
-        else:
-            list_count = 0
-        list = []
-        if list_count > 0:
-            for counter in range(0, list_count):
-                item = self.get_config(u'%s %d' % (name, counter))
-                if item:
-                    list.append(item)
-        return list
-
-    def set_list(self, name, list):
-        """
-        Save a list to the config file.
-
-        ``name``
-            The name of the list to save.
-
-        ``list``
-            The list of values to save.
-        """
-        old_count = int(self.get_config(u'%s count' % name, int(0)))
-        new_count = len(list)
-        self.set_config(u'%s count' % name, new_count)
-        for counter in range (0, new_count):
-            self.set_config(u'%s %d' % (name, counter), list[counter-1])
-        if old_count > new_count:
-            # Tidy up any old list itrms if list is smaller now
-            for counter in range(new_count, old_count):
-                self.delete_config(u'%s %d' % (name, counter))
-
-    def get_last_dir(self, num=None):
-        """
-        Read the last directory used for plugin.
-
-        ``num``
-            Defaults to *None*. A further qualifier.
-        """
-        if num:
-            name = u'last directory %d' % num
-        else:
-            name = u'last directory'
-        last_dir = self.get_config(name)
-        if not last_dir:
-            last_dir = u''
-        return last_dir
-
-    def set_last_dir(self, directory, num=None):
-        """
-        Save the last directory used for plugin.
-
-        ``num``
-            Defaults to *None*. A further qualifier.
-        """
-        if num:
-            name = u'last directory %d' % num
-        else:
-            name = u'last directory'
-        self.set_config(name, directory)

openlp/core/lib/serviceitem.py

@@ -30,7 +30,7 @@ import uuid
 
 from PyQt4 import QtGui
 
-from openlp.core.lib import build_icon, Receiver, resize_image
+from openlp.core.lib import build_icon, resize_image
 
 log = logging.getLogger(__name__)
 

openlp/core/lib/settingsmanager.py

@@ -23,14 +23,16 @@
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
 
-from openlp.core.lib import str_to_bool
+import os
-from openlp.core.utils import ConfigHelper
+
+from PyQt4 import QtCore
+
+from openlp.core.utils import AppLocation
 
 class SettingsManager(object):
     """
-    Class to control the size of the UI components so they size correctly.
+    Class to control the initial settings for the UI and provide helper
-    This class is created by the main window and then calculates the size of
+    functions for the loading and saving of application settings.
-    individual components.
     """
     def __init__(self, screen):
         self.screen = screen.current
@@ -50,26 +52,131 @@ class SettingsManager(object):
             self.mainwindow_left + self.mainwindow_right) - 100 ) / 2
         self.slidecontroller_image = self.slidecontroller - 50
 
-        self.showMediaManager = str_to_bool(ConfigHelper.get_config(
+        self.showPreviewPanel = QtCore.QSettings().value(
-            u'user interface', u'media manager', True))
+            u'user interface/preview panel', True).toBool()
-        self.showServiceManager = str_to_bool(ConfigHelper.get_config(
-            u'user interface', u'service manager', True))
-        self.showThemeManager = str_to_bool(ConfigHelper.get_config(
-            u'user interface', u'theme manager', True))
-        self.showPreviewPanel = str_to_bool(ConfigHelper.get_config(
-            u'user interface', u'preview panel', True))
-
-    def setUIItemVisibility(self, item=u'', isVisible=True):
-        if item:
-            if item == u'ThemeManagerDock':
-                ConfigHelper.set_config(u'user interface',
-                    u'theme manager', isVisible)
-            elif item == u'ServiceManagerDock':
-                ConfigHelper.set_config(u'user interface',
-                    u'service manager', isVisible)
-            elif item == u'MediaManagerDock':
-                ConfigHelper.set_config(u'user interface',
-                    u'media manager', isVisible)
 
     def togglePreviewPanel(self, isVisible):
-        ConfigHelper.set_config(u'user interface', u'preview panel', isVisible)
+        QtCore.QSettings().setValue(u'user interface/preview panel',
+            QtCore.QVariant(isVisible))
+
+    @staticmethod
+    def get_last_dir(section, num=None):
+        """
+        Read the last directory used for plugin.
+
+        ``section``
+            The section of code calling the method.  This is used in the
+            settings key.
+
+        ``num``
+            Defaults to *None*. A further qualifier.
+        """
+        if num:
+            name = u'last directory %d' % num
+        else:
+            name = u'last directory'
+        last_dir = unicode(QtCore.QSettings().value(
+            section + u'/' + name, QtCore.QVariant(u'')).toString())
+        return last_dir
+
+    @staticmethod
+    def set_last_dir(section, directory, num=None):
+        """
+        Save the last directory used for plugin.
+
+        ``section``
+            The section of code calling the method.  This is used in the
+            settings key.
+
+        ``directory``
+            The directory being stored in the settings.
+
+        ``num``
+            Defaults to *None*. A further qualifier.
+        """
+        if num:
+            name = u'last directory %d' % num
+        else:
+            name = u'last directory'
+        QtCore.QSettings().setValue(
+            section + u'/' + name, QtCore.QVariant(directory))
+
+    @staticmethod
+    def set_list(section, name, list):
+        """
+        Save a list to application settings.
+
+        ``section``
+            The section of the settings to store this list.
+
+        ``name``
+            The name of the list to save.
+
+        ``list``
+            The list of values to save.
+        """
+        settings = QtCore.QSettings()
+        settings.beginGroup(section)
+        old_count = settings.value(
+            u'%s count' % name, QtCore.QVariant(0)).toInt()[0]
+        new_count = len(list)
+        settings.setValue(u'%s count' % name, QtCore.QVariant(new_count))
+        for counter in range (0, new_count):
+            settings.setValue(
+                u'%s %d' % (name, counter), QtCore.QVariant(list[counter-1]))
+        if old_count > new_count:
+            # Tidy up any old list items
+            for counter in range(new_count, old_count):
+                settings.remove(u'%s %d' % (name, counter))
+        settings.endGroup()
+
+    @staticmethod
+    def load_list(section, name):
+        """
+        Load a list from the config file.
+
+        ``section``
+            The section of the settings to load the list from.
+
+        ``name``
+            The name of the list.
+        """
+        settings = QtCore.QSettings()
+        settings.beginGroup(section)
+        list_count = settings.value(
+            u'%s count' % name, QtCore.QVariant(0)).toInt()[0]
+        list = []
+        if list_count:
+            for counter in range(0, list_count):
+                item = unicode(
+                    settings.value(u'%s %d' % (name, counter)).toString())
+                if item:
+                    list.append(item)
+        settings.endGroup()
+        return list
+
+    @staticmethod
+    def get_files(section=None, extension=None):
+        """
+        Get a list of files from the data files path.
+
+        ``section``
+            Defaults to *None*.  The section of code getting the files - used
+            to load from a section's data subdirectory.
+
+        ``extension``
+            Defaults to *None*.  The extension to search for.
+        """
+        path = AppLocation.get_data_path()
+        if section:
+            path = os.path.join(path, section)
+        try:
+            files = os.listdir(path)
+        except:
+            return []
+        if extension:
+            return [file for file in files
+                if extension == os.path.splitext(file)[1]]
+        else:
+            # no filtering required
+            return files

openlp/core/lib/settingstab.py

@@ -25,35 +25,25 @@
 
 from PyQt4 import QtGui
 
-from openlp.core.lib import PluginConfig
-
 class SettingsTab(QtGui.QWidget):
     """
     SettingsTab is a helper widget for plugins to define Tabs for the settings
     dialog.
     """
-    def __init__(self, title, section=None):
+    def __init__(self, title):
         """
         Constructor to create the Settings tab item.
 
         ``title``
-            Defaults to *None*. The title of the tab, which is usually
+            The title of the tab, which is usually displayed on the tab.
-            displayed on the tab.
-
-        ``section``
-            Defaults to *None*. This is the section in the configuration file
-            to write to when the ``save`` method is called.
         """
         QtGui.QWidget.__init__(self)
         self.tabTitle = title
         self.tabTitleVisible = None
+        self.settingsSection = self.tabTitle.lower()
         self.setupUi()
         self.retranslateUi()
         self.initialise()
-        if section is None:
-            self.config = PluginConfig(title)
-        else:
-            self.config = PluginConfig(section)
         self.preLoad()
         self.load()
 

openlp/core/ui/generaltab.py

@@ -25,7 +25,7 @@
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import SettingsTab, str_to_bool, Receiver
+from openlp.core.lib import SettingsTab, Receiver
 
 class GeneralTab(SettingsTab):
     """
@@ -41,12 +41,16 @@ class GeneralTab(SettingsTab):
         values.
         If not set before default to last screen.
         """
-        self.MonitorNumber = int(self.config.get_config(u'monitor',
+        settings = QtCore.QSettings()
-                                                self.screens.monitor_number))
+        settings.beginGroup(self.settingsSection)
+        self.MonitorNumber = settings.value(u'monitor',
+            QtCore.QVariant(self.screens.monitor_number)).toInt()[0]
         self.screens.set_current_display(self.MonitorNumber)
         self.screens.monitor_number = self.MonitorNumber
-        self.DisplayOnMonitor = str_to_bool(self.config.get_config(u'display on monitor', u'True'))
+        self.DisplayOnMonitor = settings.value(
+            u'display on monitor', QtCore.QVariant(True)).toBool()
         self.screens.display = self.DisplayOnMonitor
+        settings.endGroup()
 
     def setupUi(self):
         self.setObjectName(u'GeneralTab')
@@ -151,15 +155,18 @@ class GeneralTab(SettingsTab):
         QtCore.QObject.connect(self.MonitorComboBox,
             QtCore.SIGNAL(u'activated(int)'), self.onMonitorComboBoxChanged)
         QtCore.QObject.connect(self.DisplayOnMonitorCheck,
-            QtCore.SIGNAL(u'stateChanged(int)'), self.onDisplayOnMonitorCheckChanged)
+            QtCore.SIGNAL(u'stateChanged(int)'),
+            self.onDisplayOnMonitorCheckChanged)
         QtCore.QObject.connect(self.WarningCheckBox,
             QtCore.SIGNAL(u'stateChanged(int)'), self.onWarningCheckBoxChanged)
         QtCore.QObject.connect(self.AutoOpenCheckBox,
             QtCore.SIGNAL(u'stateChanged(int)'), self.onAutoOpenCheckBoxChanged)
         QtCore.QObject.connect(self.ShowSplashCheckBox,
-            QtCore.SIGNAL(u'stateChanged(int)'), self.onShowSplashCheckBoxChanged)
+            QtCore.SIGNAL(u'stateChanged(int)'),
+            self.onShowSplashCheckBoxChanged)
         QtCore.QObject.connect(self.SaveCheckServiceCheckBox,
-            QtCore.SIGNAL(u'stateChanged(int)'), self.onSaveCheckServiceCheckBox)
+            QtCore.SIGNAL(u'stateChanged(int)'),
+            self.onSaveCheckServiceCheckBox)
         QtCore.QObject.connect(self.AutoPreviewCheckBox,
             QtCore.SIGNAL(u'stateChanged(int)'), self.onAutoPreviewCheckBox)
         QtCore.QObject.connect(self.NumberEdit,
@@ -171,15 +178,20 @@ class GeneralTab(SettingsTab):
 
     def retranslateUi(self):
         self.MonitorGroupBox.setTitle(self.trUtf8('Monitors'))
-        self.MonitorLabel.setText(self.trUtf8('Select monitor for output display:'))
+        self.MonitorLabel.setText(
-        self.DisplayOnMonitorCheck.setText(self.trUtf8('Display if in single screen'))
+            self.trUtf8('Select monitor for output display:'))
+        self.DisplayOnMonitorCheck.setText(
+            self.trUtf8('Display if in single screen'))
         self.StartupGroupBox.setTitle(self.trUtf8('Application Startup'))
         self.WarningCheckBox.setText(self.trUtf8('Show blank screen warning'))
-        self.AutoOpenCheckBox.setText(self.trUtf8('Automatically open the last service'))
+        self.AutoOpenCheckBox.setText(
+            self.trUtf8('Automatically open the last service'))
         self.ShowSplashCheckBox.setText(self.trUtf8('Show the splash screen'))
         self.SettingsGroupBox.setTitle(self.trUtf8('Application Settings'))
-        self.SaveCheckServiceCheckBox.setText(self.trUtf8('Prompt to save Service before starting New'))
+        self.SaveCheckServiceCheckBox.setText(
-        self.AutoPreviewCheckBox.setText(self.trUtf8('Preview Next Song from Service Manager'))
+            self.trUtf8('Prompt to save Service before starting New'))
+        self.AutoPreviewCheckBox.setText(
+            self.trUtf8('Preview Next Song from Service Manager'))
         self.CCLIGroupBox.setTitle(self.trUtf8('CCLI Details'))
         self.NumberLabel.setText(self.trUtf8('CCLI Number:'))
         self.UsernameLabel.setText(self.trUtf8('SongSelect Username:'))
@@ -216,20 +228,32 @@ class GeneralTab(SettingsTab):
         self.Password = self.PasswordEdit.displayText()
 
     def load(self):
+        settings = QtCore.QSettings()
+        settings.beginGroup(self.settingsSection)
         for screen in self.screens.screen_list:
-            screen_name = u'%s %d' % (self.trUtf8('Screen'), screen[u'number'] + 1)
+            screen_name = u'%s %d' % (self.trUtf8('Screen'),
+                screen[u'number'] + 1)
             if screen[u'primary']:
                 screen_name = u'%s (%s)' % (screen_name, self.trUtf8('primary'))
             self.MonitorComboBox.addItem(screen_name)
         # Get the configs
-        self.Warning = str_to_bool(self.config.get_config(u'blank warning', u'False'))
+        self.Warning = settings.value(
-        self.AutoOpen = str_to_bool(self.config.get_config(u'auto open', u'False'))
+            u'blank warning', QtCore.QVariant(False)).toBool()
-        self.ShowSplash = str_to_bool(self.config.get_config(u'show splash', u'True'))
+        self.AutoOpen = settings.value(
-        self.PromptSaveService = str_to_bool(self.config.get_config(u'save prompt', u'False'))
+            u'auto open', QtCore.QVariant(False)).toBool()
-        self.AutoPreview = str_to_bool(self.config.get_config(u'auto preview', u'False'))
+        self.ShowSplash = settings.value(
-        self.CCLINumber = unicode(self.config.get_config(u'ccli number', u''))
+            u'show splash', QtCore.QVariant(True)).toBool()
-        self.Username = unicode(self.config.get_config(u'songselect username', u''))
+        self.PromptSaveService = settings.value(
-        self.Password = unicode(self.config.get_config(u'songselect password', u''))
+            u'save prompt', QtCore.QVariant(False)).toBool()
+        self.AutoPreview = settings.value(
+            u'auto preview', QtCore.QVariant(False)).toBool()
+        self.CCLINumber = unicode(settings.value(
+            u'ccli number', QtCore.QVariant(u'')).toString())
+        self.Username = unicode(settings.value(
+            u'songselect username', QtCore.QVariant(u'')).toString())
+        self.Password = unicode(settings.value(
+            u'songselect password', QtCore.QVariant(u'')).toString())
+        settings.endGroup()
         self.SaveCheckServiceCheckBox.setChecked(self.PromptSaveService)
         # Set a few things up
         self.MonitorComboBox.setCurrentIndex(self.MonitorNumber)
@@ -243,16 +267,23 @@ class GeneralTab(SettingsTab):
         self.PasswordEdit.setText(self.Password)
 
     def save(self):
-        self.config.set_config(u'monitor', self.MonitorNumber)
+        settings = QtCore.QSettings()
-        self.config.set_config(u'display on monitor', self.DisplayOnMonitor)
+        settings.beginGroup(self.settingsSection)
-        self.config.set_config(u'blank warning', self.Warning)
+        settings.setValue(u'monitor', QtCore.QVariant(self.MonitorNumber))
-        self.config.set_config(u'auto open', self.AutoOpen)
+        settings.setValue(u'display on monitor',
-        self.config.set_config(u'show splash', self.ShowSplash)
+            QtCore.QVariant(self.DisplayOnMonitor))
-        self.config.set_config(u'save prompt', self.PromptSaveService)
+        settings.setValue(u'blank warning', QtCore.QVariant(self.Warning))
-        self.config.set_config(u'auto preview', self.AutoPreview)
+        settings.setValue(u'auto open', QtCore.QVariant(self.AutoOpen))
-        self.config.set_config(u'ccli number', self.CCLINumber)
+        settings.setValue(u'show splash', QtCore.QVariant(self.ShowSplash))
-        self.config.set_config(u'songselect username', self.Username)
+        settings.setValue(u'save prompt',
-        self.config.set_config(u'songselect password', self.Password)
+            QtCore.QVariant(self.PromptSaveService))
+        settings.setValue(u'auto preview', QtCore.QVariant(self.AutoPreview))
+        settings.setValue(u'ccli number', QtCore.QVariant(self.CCLINumber))
+        settings.setValue(u'songselect username',
+            QtCore.QVariant(self.Username))
+        settings.setValue(u'songselect password',
+            QtCore.QVariant(self.Password))
+        settings.endGroup()
         self.screens.display = self.DisplayOnMonitor
         #Monitor Number has changed.
         if self.screens.monitor_number != self.MonitorNumber:

openlp/core/ui/maindisplay.py

@@ -254,14 +254,17 @@ class MainDisplay(DisplayWidget):
         if not self.displayBlank:
             if transition:
                 if self.frame is not None:
-                    self.display_text.setPixmap(QtGui.QPixmap.fromImage(self.frame))
+                    self.display_text.setPixmap(
+                        QtGui.QPixmap.fromImage(self.frame))
                     self.repaint()
                 self.frame = None
                 if frame[u'trans'] is not None:
-                    self.display_text.setPixmap(QtGui.QPixmap.fromImage(frame[u'trans']))
+                    self.display_text.setPixmap(
+                        QtGui.QPixmap.fromImage(frame[u'trans']))
                     self.repaint()
                     self.frame = frame[u'trans']
-                self.display_text.setPixmap(QtGui.QPixmap.fromImage(frame[u'main']))
+                self.display_text.setPixmap(
+                    QtGui.QPixmap.fromImage(frame[u'main']))
                 self.display_frame = frame[u'main']
                 self.repaint()
             else:
@@ -282,7 +285,8 @@ class MainDisplay(DisplayWidget):
         if blanked:
             self.displayBlank = True
             if blankType == HideMode.Blank:
-                self.display_text.setPixmap(QtGui.QPixmap.fromImage(self.blankFrame))
+                self.display_text.setPixmap(
+                    QtGui.QPixmap.fromImage(self.blankFrame))
             elif blankType == HideMode.Theme:
                 theme = self.parent.RenderManager.renderer.bg_frame
                 if not theme:

openlp/core/ui/mainwindow.py

@@ -28,12 +28,11 @@ import time
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.ui import AboutForm, SettingsForm,  \
+from openlp.core.ui import AboutForm, SettingsForm, ServiceManager, \
-    ServiceManager, ThemeManager, SlideController, \
+    ThemeManager, SlideController, PluginForm, MediaDockManager, DisplayManager
-    PluginForm, MediaDockManager, DisplayManager
+from openlp.core.lib import RenderManager, build_icon, OpenLPDockWidget, \
-from openlp.core.lib import translate, RenderManager, PluginConfig, build_icon, \
+    SettingsManager, PluginManager, Receiver, translate
-    OpenLPDockWidget, SettingsManager, PluginManager, Receiver, str_to_bool
+from openlp.core.utils import check_latest_version, AppLocation, add_actions, LanguageManager
-from openlp.core.utils import check_latest_version, AppLocation, LanguageManager,  ConfigHelper
 
 log = logging.getLogger(__name__)
 
@@ -57,11 +56,10 @@ class VersionThread(QtCore.QThread):
     A special Qt thread class to fetch the version of OpenLP from the website.
     This is threaded so that it doesn't affect the loading time of OpenLP.
     """
-    def __init__(self, parent, app_version, generalConfig):
+    def __init__(self, parent, app_version):
         QtCore.QThread.__init__(self, parent)
         self.parent = parent
         self.app_version = app_version
-        self.generalConfig = generalConfig
 
     def run(self):
         """
@@ -69,7 +67,7 @@ class VersionThread(QtCore.QThread):
         """
         time.sleep(1)
         Receiver.send_message(u'maindisplay_blank_check')
-        version = check_latest_version(self.generalConfig, self.app_version)
+        version = check_latest_version(self.app_version)
         #new version has arrived
         if version != self.app_version[u'full']:
             Receiver.send_message(u'openlp_version_check', u'%s' % version)
@@ -163,7 +161,6 @@ class Ui_MainWindow(object):
         self.MediaManagerDock.setWidget(self.MediaManagerContents)
         MainWindow.addDockWidget(
             QtCore.Qt.DockWidgetArea(1), self.MediaManagerDock)
-        self.MediaManagerDock.setVisible(self.settingsmanager.showMediaManager)
         # Create the service manager
         self.ServiceManagerDock = OpenLPDockWidget(MainWindow)
         ServiceManagerIcon = build_icon(u':/system/system_servicemanager.png')
@@ -175,33 +172,32 @@ class Ui_MainWindow(object):
         self.ServiceManagerDock.setWidget(self.ServiceManagerContents)
         MainWindow.addDockWidget(
             QtCore.Qt.DockWidgetArea(2), self.ServiceManagerDock)
-        self.ServiceManagerDock.setVisible(
-            self.settingsmanager.showServiceManager)
         # Create the theme manager
         self.ThemeManagerDock = OpenLPDockWidget(MainWindow)
         ThemeManagerIcon = build_icon(u':/system/system_thememanager.png')
         self.ThemeManagerDock.setWindowIcon(ThemeManagerIcon)
         self.ThemeManagerDock.setObjectName(u'ThemeManagerDock')
+        self.ThemeManagerDock.setMinimumWidth(
+            self.settingsmanager.mainwindow_right)
         self.ThemeManagerContents = ThemeManager(self)
         self.ThemeManagerDock.setWidget(self.ThemeManagerContents)
         MainWindow.addDockWidget(
             QtCore.Qt.DockWidgetArea(2), self.ThemeManagerDock)
-        self.ThemeManagerDock.setVisible(self.settingsmanager.showThemeManager)
         # Create the menu items
         self.FileNewItem = QtGui.QAction(MainWindow)
         self.FileNewItem.setIcon(
             self.ServiceManagerContents.Toolbar.getIconFromTitle(
-            MainWindow.trUtf8('New Service')))
+            u'New Service'))
         self.FileNewItem.setObjectName(u'FileNewItem')
         self.FileOpenItem = QtGui.QAction(MainWindow)
         self.FileOpenItem.setIcon(
             self.ServiceManagerContents.Toolbar.getIconFromTitle(
-            MainWindow.trUtf8('Open Service')))
+            u'Open Service'))
         self.FileOpenItem.setObjectName(u'FileOpenItem')
         self.FileSaveItem = QtGui.QAction(MainWindow)
         self.FileSaveItem.setIcon(
             self.ServiceManagerContents.Toolbar.getIconFromTitle(
-            MainWindow.trUtf8('Save Service')))
+            u'Save Service'))
         self.FileSaveItem.setObjectName(u'FileSaveItem')
         self.FileSaveAsItem = QtGui.QAction(MainWindow)
         self.FileSaveAsItem.setObjectName(u'FileSaveAsItem')
@@ -225,20 +221,18 @@ class Ui_MainWindow(object):
         self.OptionsSettingsItem.setObjectName(u'OptionsSettingsItem')
         self.ViewMediaManagerItem = QtGui.QAction(MainWindow)
         self.ViewMediaManagerItem.setCheckable(True)
-        self.ViewMediaManagerItem.setChecked(
+        self.ViewMediaManagerItem.setChecked(self.MediaManagerDock.isVisible())
-            self.settingsmanager.showMediaManager)
         self.ViewMediaManagerItem.setIcon(MediaManagerIcon)
         self.ViewMediaManagerItem.setObjectName(u'ViewMediaManagerItem')
         self.ViewThemeManagerItem = QtGui.QAction(MainWindow)
         self.ViewThemeManagerItem.setCheckable(True)
-        self.ViewThemeManagerItem.setChecked(
+        self.ViewThemeManagerItem.setChecked(self.ThemeManagerDock.isVisible())
-            self.settingsmanager.showThemeManager)
         self.ViewThemeManagerItem.setIcon(ThemeManagerIcon)
         self.ViewThemeManagerItem.setObjectName(u'ViewThemeManagerItem')
         self.ViewServiceManagerItem = QtGui.QAction(MainWindow)
         self.ViewServiceManagerItem.setCheckable(True)
         self.ViewServiceManagerItem.setChecked(
-            self.settingsmanager.showServiceManager)
+            self.ServiceManagerDock.isVisible())
         self.ViewServiceManagerItem.setIcon(ServiceManagerIcon)
         self.ViewServiceManagerItem.setObjectName(u'ViewServiceManagerItem')
         self.PluginItem = QtGui.QAction(MainWindow)
@@ -263,19 +257,16 @@ class Ui_MainWindow(object):
         self.LanguageGroup = QtGui.QActionGroup(MainWindow)
         qmList = LanguageManager.get_qm_list()
         savedLanguage = LanguageManager.get_language()
+        self.AutoLanguageItem.setChecked(LanguageManager.AutoLanguage)
         self.LanguageItem = {}
         for key in qmList.keys():
             self.LanguageItem[key] = QtGui.QAction(MainWindow)
             self.LanguageItem[key].setObjectName(key)
             self.LanguageItem[key].setCheckable(True)
-            if LanguageManager.AutoLanguage:
+            self.LanguageItem[key].setDisabled(LanguageManager.AutoLanguage)
-                self.AutoLanguageItem.setChecked(True)
-                self.LanguageGroup.setEnabled(False)
-            else:
-                self.AutoLanguageItem.setChecked(False)
-                self.LanguageGroup.setEnabled(True)
             if qmList[key] == savedLanguage:
                 self.LanguageItem[key].setChecked(True)
+            add_actions(self.LanguageGroup, [self.LanguageItem[key]])
         self.ToolsAddToolItem = QtGui.QAction(MainWindow)
         AddToolIcon = build_icon(u':/tools/tools_add.png')
         self.ToolsAddToolItem.setIcon(AddToolIcon)
@@ -289,53 +280,38 @@ class Ui_MainWindow(object):
             self.settingsmanager.showPreviewPanel)
         self.ModeLiveItem = QtGui.QAction(MainWindow)
         self.ModeLiveItem.setObjectName(u'ModeLiveItem')
-        self.FileImportMenu.addAction(self.ImportThemeItem)
+        add_actions(self.FileImportMenu,
-        self.FileImportMenu.addAction(self.ImportLanguageItem)
+            (self.ImportThemeItem, self.ImportLanguageItem))
-        self.FileExportMenu.addAction(self.ExportThemeItem)
+        add_actions(self.FileExportMenu,
-        self.FileExportMenu.addAction(self.ExportLanguageItem)
+            (self.ExportThemeItem, self.ExportLanguageItem))
-        self.FileMenu.addAction(self.FileNewItem)
+        self.FileMenuActions = (self.FileNewItem, self.FileOpenItem,
-        self.FileMenu.addAction(self.FileOpenItem)
+            self.FileSaveItem, self.FileSaveAsItem, None,
-        self.FileMenu.addAction(self.FileSaveItem)
+            self.FileImportMenu.menuAction(), self.FileExportMenu.menuAction(),
-        self.FileMenu.addAction(self.FileSaveAsItem)
+            self.FileExitItem)
-        self.FileMenu.addSeparator()
+        add_actions(self.ViewModeMenu, [self.ModeLiveItem])
-        self.FileMenu.addAction(self.FileImportMenu.menuAction())
+        add_actions(self.OptionsViewMenu, (self.ViewModeMenu.menuAction(),
-        self.FileMenu.addAction(self.FileExportMenu.menuAction())
+            None, self.ViewMediaManagerItem, self.ViewServiceManagerItem,
-        self.FileMenu.addSeparator()
+            self.ViewThemeManagerItem, None, self.action_Preview_Panel))
-        self.FileMenu.addAction(self.FileExitItem)
-        self.ViewModeMenu.addAction(self.ModeLiveItem)
-        self.OptionsViewMenu.addAction(self.ViewModeMenu.menuAction())
-        self.OptionsViewMenu.addSeparator()
-        self.OptionsViewMenu.addAction(self.ViewMediaManagerItem)
-        self.OptionsViewMenu.addAction(self.ViewServiceManagerItem)
-        self.OptionsViewMenu.addAction(self.ViewThemeManagerItem)
-        self.OptionsViewMenu.addSeparator()
-        self.OptionsViewMenu.addAction(self.action_Preview_Panel)
         #i18n add Language Actions
-        self.OptionsLanguageMenu.addAction(self.AutoLanguageItem)
+        add_actions(self.OptionsLanguageMenu, (self.AutoLanguageItem, None))
-        self.OptionsLanguageMenu.addSeparator()
         for item in sorted(self.LanguageItem):
-            self.LanguageGroup.addAction(self.LanguageItem[item])
+            add_actions(self.OptionsLanguageMenu, [self.LanguageItem[item]])
-            self.OptionsLanguageMenu.addAction(self.LanguageItem[item])
+        add_actions(self.OptionsMenu, (self.OptionsLanguageMenu.menuAction(),
-        self.OptionsMenu.addAction(self.OptionsLanguageMenu.menuAction())
+            self.OptionsViewMenu.menuAction(), None, self.OptionsSettingsItem))
-        self.OptionsMenu.addAction(self.OptionsViewMenu.menuAction())
+        add_actions(self.ToolsMenu,
-        self.OptionsMenu.addSeparator()
+            (self.PluginItem, None, self.ToolsAddToolItem))
-        self.OptionsMenu.addAction(self.OptionsSettingsItem)
+        add_actions(self.HelpMenu,
-        self.ToolsMenu.addAction(self.PluginItem)
+            (self.HelpDocumentationItem, self.HelpOnlineHelpItem, None,
-        self.ToolsMenu.addSeparator()
+            self.HelpWebSiteItem, self.HelpAboutItem))
-        self.ToolsMenu.addAction(self.ToolsAddToolItem)
+        add_actions(self.MenuBar,
-        self.HelpMenu.addAction(self.HelpDocumentationItem)
+            (self.FileMenu.menuAction(), self.OptionsMenu.menuAction(),
-        self.HelpMenu.addAction(self.HelpOnlineHelpItem)
+            self.ToolsMenu.menuAction(), self.HelpMenu.menuAction()))
-        self.HelpMenu.addSeparator()
-        self.HelpMenu.addAction(self.HelpWebSiteItem)
-        self.HelpMenu.addAction(self.HelpAboutItem)
-        self.MenuBar.addAction(self.FileMenu.menuAction())
-        self.MenuBar.addAction(self.OptionsMenu.menuAction())
-        self.MenuBar.addAction(self.ToolsMenu.menuAction())
-        self.MenuBar.addAction(self.HelpMenu.menuAction())
         # Initialise the translation
         self.retranslateUi(MainWindow)
         self.MediaToolBox.setCurrentIndex(0)
         # Connect up some signals and slots
+        QtCore.QObject.connect(self.FileMenu,
+            QtCore.SIGNAL(u'aboutToShow()'), self.updateFileMenu)
         QtCore.QObject.connect(self.FileExitItem,
             QtCore.SIGNAL(u'triggered()'), MainWindow.close)
         QtCore.QObject.connect(self.ControlSplitter,
@@ -353,7 +329,7 @@ class Ui_MainWindow(object):
         """
         Set up the translation system
         """
-        MainWindow.mainTitle = translate('MainWindow','OpenLP 2.0')
+        MainWindow.mainTitle = translate('MainWindow', 'OpenLP 2.0')
         MainWindow.language = translate('MainWindow', 'English')
         MainWindow.defaultThemeText = translate('MainWindow', 
             'Default Theme: ')
@@ -402,12 +378,14 @@ class Ui_MainWindow(object):
         self.actionLook_Feel.setText(translate('MainWindow', 'Look && &Feel'))
         self.OptionsSettingsItem.setText(translate('MainWindow', '&Settings'))
         self.ViewMediaManagerItem.setText(translate('MainWindow', '&Media Manager'))
-        self.ViewMediaManagerItem.setToolTip(translate('MainWindow', 'Toggle Media Manager'))
+        self.ViewMediaManagerItem.setToolTip(
+            translate('MainWindow', 'Toggle Media Manager'))
         self.ViewMediaManagerItem.setStatusTip(
             translate('MainWindow', 'Toggle the visibility of the Media Manager'))
         self.ViewMediaManagerItem.setShortcut(translate('MainWindow', 'F8'))
         self.ViewThemeManagerItem.setText(translate('MainWindow', '&Theme Manager'))
-        self.ViewThemeManagerItem.setToolTip(translate('MainWindow', 'Toggle Theme Manager'))
+        self.ViewThemeManagerItem.setToolTip(
+            translate('MainWindow', 'Toggle Theme Manager'))
         self.ViewThemeManagerItem.setStatusTip(
             translate('MainWindow', 'Toggle the visibility of the Theme Manager'))
         self.ViewThemeManagerItem.setShortcut(translate('MainWindow', 'F10'))
@@ -418,7 +396,8 @@ class Ui_MainWindow(object):
             translate('MainWindow', 'Toggle the visibility of the Service Manager'))
         self.ViewServiceManagerItem.setShortcut(translate('MainWindow', 'F9'))
         self.action_Preview_Panel.setText(translate('MainWindow', '&Preview Panel'))
-        self.action_Preview_Panel.setToolTip(translate('MainWindow', 'Toggle Preview Panel'))
+        self.action_Preview_Panel.setToolTip(
+            translate('MainWindow', 'Toggle Preview Panel'))
         self.action_Preview_Panel.setStatusTip(
             translate('MainWindow', 'Toggle the visibility of the Preview Panel'))
         self.action_Preview_Panel.setShortcut(translate('MainWindow', 'F11'))
@@ -461,18 +440,24 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         QtGui.QMainWindow.__init__(self)
         self.screens = screens
         self.applicationVersion = applicationVersion
+        self.generalSettingsSection = u'general'
+        self.uiSettingsSection = u'user interface'
         self.serviceNotSaved = False
         self.settingsmanager = SettingsManager(screens)
-        self.generalConfig = PluginConfig(u'General')
         self.displayManager = DisplayManager(screens)
         self.aboutForm = AboutForm(self, applicationVersion)
         self.settingsForm = SettingsForm(self.screens, self, self)
+        self.recentFiles = []
         # Set up the path with plugins
         pluginpath = AppLocation.get_directory(AppLocation.PluginsDir)
         self.plugin_manager = PluginManager(pluginpath)
         self.plugin_helpers = {}
         # Set up the interface
         self.setupUi(self)
+        # Load settings after setupUi so default UI sizes are overwritten
+        self.loadSettings()
+        # Once settings are loaded update FileMenu with recentFiles
+        self.updateFileMenu()
         self.pluginForm = PluginForm(self)
         # Set up signals and slots
         QtCore.QObject.connect(self.ImportThemeItem,
@@ -541,8 +526,8 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         #warning cyclic dependency
         #RenderManager needs to call ThemeManager and
         #ThemeManager needs to call RenderManager
-        self.RenderManager = RenderManager(self.ThemeManagerContents,
+        self.RenderManager = RenderManager(
-                                            self.screens)
+            self.ThemeManagerContents, self.screens)
         #Define the media Dock Manager
         self.mediaDockManager = MediaDockManager(self.MediaToolBox)
         log.info(u'Load Plugins')
@@ -551,7 +536,7 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         self.plugin_helpers[u'live'] = self.LiveController
         self.plugin_helpers[u'render'] = self.RenderManager
         self.plugin_helpers[u'service'] = self.ServiceManagerContents
-        self.plugin_helpers[u'settings'] = self.settingsForm
+        self.plugin_helpers[u'settings form'] = self.settingsForm
         self.plugin_helpers[u'toolbox'] = self.mediaDockManager
         self.plugin_helpers[u'maindisplay'] = self.displayManager.mainDisplay
         self.plugin_manager.find_plugins(pluginpath, self.plugin_helpers)
@@ -581,7 +566,8 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
 
     #i18n
     def setAutoLanguage(self, value):
-        self.LanguageGroup.setDisabled(value)
+        for action in self.LanguageGroup.actions():
+            action.setDisabled(value)
         LanguageManager.AutoLanguage = value
         LanguageManager.set_language(self.LanguageGroup.checkedAction())
 
@@ -604,13 +590,14 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         """
         Show the main form, as well as the display form
         """
-        self.showMaximized()
+        QtGui.QWidget.show(self)
         #screen_number = self.getMonitorNumber()
         self.displayManager.setup()
         if self.displayManager.mainDisplay.isVisible():
             self.displayManager.mainDisplay.setFocus()
         self.activateWindow()
-        if str_to_bool(self.generalConfig.get_config(u'auto open', False)):
+        if QtCore.QSettings().value(self.generalSettingsSection + u'/auto open',
+            QtCore.QVariant(False)).toBool():
             self.ServiceManagerContents.onLoadService(True)
 
     def blankCheck(self):
@@ -618,20 +605,23 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         Check and display message if screen blank on setup.
         Triggered by delay thread.
         """
-        if str_to_bool(self.generalConfig.get_config(u'screen blank', False)) \
+        settings = QtCore.QSettings()
-        and str_to_bool(self.generalConfig.get_config(u'blank warning', False)):
+        settings.beginGroup(self.generalSettingsSection)
+        if settings.value(u'screen blank', QtCore.QVariant(False)).toBool() \
+        and settings.value(u'blank warning', QtCore.QVariant(False)).toBool():
             self.LiveController.onBlankDisplay(True)
             QtGui.QMessageBox.question(self,
                 self.trUtf8('OpenLP Main Display Blanked'),
                 self.trUtf8('The Main Display has been blanked out'),
                 QtGui.QMessageBox.StandardButtons(QtGui.QMessageBox.Ok),
                 QtGui.QMessageBox.Ok)
+        settings.endGroup()
 
     def versionThread(self):
         """
         Start an initial setup thread to delay notifications
         """
-        vT = VersionThread(self, self.applicationVersion, self.generalConfig)
+        vT = VersionThread(self, self.applicationVersion)
         vT.start()
 
     def onHelpAboutItemClicked(self):
@@ -671,7 +661,8 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         if self.serviceNotSaved:
             ret = QtGui.QMessageBox.question(self,
                 self.trUtf8('Save Changes to Service?'),
-                self.trUtf8('Your service has changed, do you want to save those changes?'),
+                self.trUtf8('Your service has changed.  '
+                    'Do you want to save those changes?'),
                 QtGui.QMessageBox.StandardButtons(
                     QtGui.QMessageBox.Cancel |
                     QtGui.QMessageBox.Discard |
@@ -699,6 +690,8 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
         # Call the cleanup method to shutdown plugins.
         log.info(u'cleanup plugins')
         self.plugin_manager.finalise_plugins()
+        # Save settings
+        self.saveSettings()
         #Close down the displays
         self.displayManager.close()
 
@@ -734,22 +727,73 @@ class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
     def toggleMediaManager(self, visible):
         if self.MediaManagerDock.isVisible() != visible:
             self.MediaManagerDock.setVisible(visible)
-            self.settingsmanager.setUIItemVisibility(
-                self.MediaManagerDock.objectName(), visible)
 
     def toggleServiceManager(self, visible):
         if self.ServiceManagerDock.isVisible() != visible:
             self.ServiceManagerDock.setVisible(visible)
-            self.settingsmanager.setUIItemVisibility(
-                self.ServiceManagerDock.objectName(), visible)
 
     def toggleThemeManager(self, visible):
         if self.ThemeManagerDock.isVisible() != visible:
             self.ThemeManagerDock.setVisible(visible)
-            self.settingsmanager.setUIItemVisibility(
-                self.ThemeManagerDock.objectName(), visible)
 
     def togglePreviewPanel(self):
         previewBool = self.PreviewController.Panel.isVisible()
         self.PreviewController.Panel.setVisible(not previewBool)
         self.settingsmanager.togglePreviewPanel(not previewBool)
+
+    def loadSettings(self):
+        log.debug(u'Loading QSettings')
+        settings = QtCore.QSettings()
+        self.recentFiles = settings.value(
+            self.generalSettingsSection + u'/recent files').toStringList()
+        settings.beginGroup(self.uiSettingsSection)
+        self.move(settings.value(u'main window position',
+            QtCore.QVariant(QtCore.QPoint(0, 0))).toPoint())
+        self.restoreGeometry(
+            settings.value(u'main window geometry').toByteArray())
+        self.restoreState(settings.value(u'main window state').toByteArray())
+        settings.endGroup()
+
+    def saveSettings(self):
+        log.debug(u'Saving QSettings')
+        settings = QtCore.QSettings()
+        recentFiles = QtCore.QVariant(self.recentFiles) \
+            if self.recentFiles else QtCore.QVariant()
+        settings.setValue(
+            self.generalSettingsSection + u'/recent files', recentFiles)
+        settings.beginGroup(self.uiSettingsSection)
+        settings.setValue(u'main window position',
+            QtCore.QVariant(self.pos()))
+        settings.setValue(u'main window state',
+            QtCore.QVariant(self.saveState()))
+        settings.setValue(u'main window geometry',
+            QtCore.QVariant(self.saveGeometry()))
+        settings.endGroup()
+
+    def updateFileMenu(self):
+        self.FileMenu.clear()
+        add_actions(self.FileMenu, self.FileMenuActions[:-1])
+        existingRecentFiles = []
+        for file in self.recentFiles:
+            if QtCore.QFile.exists(file):
+                existingRecentFiles.append(file)
+        if existingRecentFiles:
+            self.FileMenu.addSeparator()
+            for fileId, filename in enumerate(existingRecentFiles):
+                action = QtGui.QAction(u'&%d %s' % (fileId +1,
+                    QtCore.QFileInfo(filename).fileName()), self)
+                action.setData(QtCore.QVariant(filename))
+                self.connect(action, QtCore.SIGNAL(u'triggered()'),
+                    self.ServiceManagerContents.loadService)
+                self.FileMenu.addAction(action)
+        self.FileMenu.addSeparator()
+        self.FileMenu.addAction(self.FileMenuActions[-1])
+
+    def addRecentFile(self, filename):
+        recentFileCount = QtCore.QSettings().value(
+            self.generalSettingsSection + u'/max recent files',
+            QtCore.QVariant(4)).toInt()[0]
+        if filename and not self.recentFiles.contains(filename):
+            self.recentFiles.prepend(QtCore.QString(filename))
+            while self.recentFiles.count() > recentFileCount:
+                self.recentFiles.takeLast()

openlp/core/ui/mediadockmanager.py

@@ -45,7 +45,8 @@ class MediaDockManager(object):
         log.debug(u'Inserting %s dock' % media_item.title)
         match = False
         for dock_index in range(0, self.media_dock.count()):
-            if self.media_dock.widget(dock_index).ConfigSection == media_item.title.lower():
+            if self.media_dock.widget(dock_index).SettingsSection == \
+                media_item.title.lower():
                 match = True
                 break
         if not match:
@@ -56,6 +57,6 @@ class MediaDockManager(object):
         log.debug(u'remove %s dock' % name)
         for dock_index in range(0, self.media_dock.count()):
             if self.media_dock.widget(dock_index):
-                if self.media_dock.widget(dock_index).ConfigSection == name:
+                if self.media_dock.widget(dock_index).SettingsSection == name:
                     self.media_dock.widget(dock_index).hide()
                     self.media_dock.removeItem(dock_index)

openlp/core/ui/servicemanager.py

@@ -32,14 +32,15 @@ log = logging.getLogger(__name__)
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import PluginConfig, OpenLPToolbar, ServiceItem, \
+from openlp.core.lib import OpenLPToolbar, ServiceItem, contextMenuAction, \
-    contextMenuAction, Receiver, str_to_bool, build_icon, ItemCapabilities
+    Receiver, build_icon, ItemCapabilities, SettingsManager
 from openlp.core.ui import ServiceNoteForm, ServiceItemEditForm
+from openlp.core.utils import AppLocation
 
 class ServiceManagerList(QtGui.QTreeWidget):
 
     def __init__(self, parent=None, name=None):
-        QtGui.QTreeWidget.__init__(self,parent)
+        QtGui.QTreeWidget.__init__(self, parent)
         self.parent = parent
 
     def keyPressEvent(self, event):
@@ -98,6 +99,8 @@ class ServiceManager(QtGui.QWidget):
         """
         QtGui.QWidget.__init__(self)
         self.parent = parent
+        self.settingsSection = u'servicemanager'
+        self.generalSettingsSection = self.parent.generalSettingsSection
         self.serviceItems = []
         self.serviceName = u''
         self.droppos = 0
@@ -189,10 +192,10 @@ class ServiceManager(QtGui.QWidget):
         QtCore.QObject.connect(Receiver.get_receiver(),
             QtCore.SIGNAL(u'config_updated'), self.regenerateServiceItems)
         # Last little bits of setting up
-        self.config = PluginConfig(u'ServiceManager')
+        self.service_theme = unicode(QtCore.QSettings().value(
-        self.servicePath = self.config.get_data_path()
+            self.settingsSection + u'/service theme',
-        self.service_theme = unicode(
+            QtCore.QVariant(u'')).toString())
-            self.config.get_config(u'service theme', u''))
+        self.servicePath = AppLocation.get_section_data_path(u'servicemanager')
         #build the context menu
         self.menu = QtGui.QMenu()
         self.editAction = self.menu.addAction(self.trUtf8('&Edit Item'))
@@ -201,7 +204,8 @@ class ServiceManager(QtGui.QWidget):
         self.editAction.setIcon(build_icon(u':/general/general_edit.png'))
         self.notesAction = self.menu.addAction(self.trUtf8('&Notes'))
         self.notesAction.setIcon(build_icon(u':/services/service_notes.png'))
-        self.deleteAction = self.menu.addAction(self.trUtf8('&Delete From Service'))
+        self.deleteAction = self.menu.addAction(
+            self.trUtf8('&Delete From Service'))
         self.deleteAction.setIcon(build_icon(u':/general/general_delete.png'))
         self.sep1 = self.menu.addAction(u'')
         self.sep1.setSeparator(True)
@@ -401,13 +405,13 @@ class ServiceManager(QtGui.QWidget):
         """
         Clear the list to create a new service
         """
-        if self.parent.serviceNotSaved and \
+        if self.parent.serviceNotSaved and QtCore.QSettings().value(
-            str_to_bool(PluginConfig(u'General').
+            self.generalSettingsSection + u'/save prompt',
-                        get_config(u'save prompt', u'False')):
+            QtCore.QVariant(False)).toBool():
             ret = QtGui.QMessageBox.question(self,
                 self.trUtf8('Save Changes to Service?'),
-                self.trUtf8('Your service is unsaved, do you want to save those '
+                self.trUtf8('Your service is unsaved, do you want to save '
-                            'changes before creating a new one ?'),
+                            'those changes before creating a new one?'),
                 QtGui.QMessageBox.StandardButtons(
                     QtGui.QMessageBox.Cancel |
                     QtGui.QMessageBox.Save),
@@ -486,17 +490,18 @@ class ServiceManager(QtGui.QWidget):
         log.debug(u'onSaveService')
         if not quick or self.isNew:
             filename = QtGui.QFileDialog.getSaveFileName(self,
-            self.trUtf8(u'Save Service'), self.config.get_last_dir(),
+            self.trUtf8(u'Save Service'),
+            SettingsManager.get_last_dir(self.settingsSection),
             self.trUtf8(u'OpenLP Service Files (*.osz)'))
         else:
-            filename = self.config.get_last_dir()
+            filename = SettingsManager.get_last_dir(self.settingsSection)
         if filename:
             splittedFile = filename.split(u'.')
             if splittedFile[-1] != u'osz':
                 filename = filename + u'.osz'
             filename = unicode(filename)
             self.isNew = False
-            self.config.set_last_dir(filename)
+            SettingsManager.set_last_dir(self.settingsSection, filename)
             service = []
             servicefile = filename + u'.osd'
             zip = None
@@ -504,7 +509,8 @@ class ServiceManager(QtGui.QWidget):
             try:
                 zip = zipfile.ZipFile(unicode(filename), 'w')
                 for item in self.serviceItems:
-                    service.append({u'serviceitem':item[u'service_item'].get_service_repr()})
+                    service.append({u'serviceitem':item[u'service_item']
+                        .get_service_repr()})
                     if item[u'service_item'].uses_file():
                         for frame in item[u'service_item'].get_frames():
                             path_from = unicode(os.path.join(
@@ -528,27 +534,49 @@ class ServiceManager(QtGui.QWidget):
                 pass #if not present do not worry
             name = filename.split(os.path.sep)
             self.serviceName = name[-1]
+            self.parent.addRecentFile(filename)
             self.parent.serviceChanged(True, self.serviceName)
 
     def onQuickSaveService(self):
         self.onSaveService(True)
 
     def onLoadService(self, lastService=False):
+        if lastService:
+            filename = SettingsManager.get_last_dir(self.settingsSection)
+        else:
+            filename = QtGui.QFileDialog.getOpenFileName(
+                self, self.trUtf8('Open Service'),
+                SettingsManager.get_last_dir(self.settingsSection),
+                u'Services (*.osz)')
+        self.loadService(filename)
+
+    def loadService(self, filename=None):
         """
         Load an existing service from disk and rebuild the serviceitems.  All
         files retrieved from the zip file are placed in a temporary directory
         and will only be used for this service.
         """
-        if lastService:
+        if self.parent.serviceNotSaved:
-            filename = self.config.get_last_dir()
+            ret = QtGui.QMessageBox.question(self,
-        else:
+                self.trUtf8('Save Changes to Service?'),
-            filename = QtGui.QFileDialog.getOpenFileName(
+                self.trUtf8('Your current service is unsaved, do you want to '
-                self, self.trUtf8('Open Service'),
+                            'save the changes before opening a new one?'),
-                self.config.get_last_dir(), u'Services (*.osz)')
+                QtGui.QMessageBox.StandardButtons(
+                    QtGui.QMessageBox.Discard |
+                    QtGui.QMessageBox.Save),
+                QtGui.QMessageBox.Save)
+            if ret == QtGui.QMessageBox.Save:
+                self.onSaveService()
+        if filename is None:
+            action = self.sender()
+            if isinstance(action, QtGui.QAction):
+                filename = action.data().toString()
+            else:
+                return
         filename = unicode(filename)
         name = filename.split(os.path.sep)
         if filename:
-            self.config.set_last_dir(filename)
+            SettingsManager.set_last_dir(self.settingsSection, filename)
             zip = None
             f = None
             try:
@@ -588,6 +616,7 @@ class ServiceManager(QtGui.QWidget):
                     zip.close()
         self.isNew = False
         self.serviceName = name[len(name) - 1]
+        self.parent.addRecentFile(filename)
         self.parent.serviceChanged(True, self.serviceName)
 
     def validateItem(self, serviceItem):
@@ -616,7 +645,8 @@ class ServiceManager(QtGui.QWidget):
         """
         self.service_theme = unicode(self.ThemeComboBox.currentText())
         self.parent.RenderManager.set_service_theme(self.service_theme)
-        self.config.set_config(u'service theme', self.service_theme)
+        QtCore.QSettings().setValue(self.settingsSection + u'/service theme',
+            QtCore.QVariant(self.service_theme))
         self.regenerateServiceItems()
 
     def regenerateServiceItems(self):
@@ -628,7 +658,8 @@ class ServiceManager(QtGui.QWidget):
             self.serviceItems = []
             self.isNew = True
             for item in tempServiceItems:
-                self.addServiceItem(item[u'service_item'], False, item[u'expanded'])
+                self.addServiceItem(
+                    item[u'service_item'], False, 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.parent.serviceChanged(False, self.serviceName)
@@ -697,11 +728,13 @@ class ServiceManager(QtGui.QWidget):
         item, count = self.findServiceItem()
         self.parent.LiveController.addServiceManagerItem(
             self.serviceItems[item][u'service_item'], count)
-        if str_to_bool(PluginConfig(u'General').
+        if QtCore.QSettings().value(
-                        get_config(u'auto preview', u'False')):
+            self.generalSettingsSection + u'/auto preview',
+            QtCore.QVariant(False)).toBool():
             item += 1
             if self.serviceItems and item < len(self.serviceItems) and \
-                self.serviceItems[item][u'service_item'].is_capable(ItemCapabilities.AllowsPreview):
+                self.serviceItems[item][u'service_item'].is_capable(
+                ItemCapabilities.AllowsPreview):
                     self.parent.PreviewController.addServiceManagerItem(
                         self.serviceItems[item][u'service_item'], 0)
 

openlp/core/ui/slidecontroller.py

@@ -41,8 +41,7 @@ class HideMode(object):
     Blank = 1
     Theme = 2
 
-from openlp.core.lib import OpenLPToolbar, Receiver, str_to_bool, \
+from openlp.core.lib import OpenLPToolbar, Receiver, resize_image
-    PluginConfig, resize_image
 
 log = logging.getLogger(__name__)
 
@@ -94,9 +93,11 @@ class SlideController(QtGui.QWidget):
         """
         QtGui.QWidget.__init__(self, parent)
         self.settingsmanager = settingsmanager
+        self.generalSettingsSection = u'general'
+        self.songsSettingsSection = u'songs'
         self.isLive = isLive
         self.parent = parent
-        self.songsconfig = PluginConfig(u'Songs')
+        self.mainDisplay = self.parent.displayManager.mainDisplay
         self.loop_list = [
             u'Start Loop',
             u'Stop Loop',
@@ -153,13 +154,15 @@ class SlideController(QtGui.QWidget):
         self.PreviewListWidget.horizontalHeader().setVisible(False)
         self.PreviewListWidget.verticalHeader().setVisible(False)
         self.PreviewListWidget.setColumnWidth(1, self.labelWidth)
-        self.PreviewListWidget.setColumnWidth(1, self.Controller.width() - self.labelWidth)
+        self.PreviewListWidget.setColumnWidth(
+            1, self.Controller.width() - self.labelWidth)
         self.PreviewListWidget.isLive = self.isLive
         self.PreviewListWidget.setObjectName(u'PreviewListWidget')
         self.PreviewListWidget.setSelectionBehavior(1)
         self.PreviewListWidget.setEditTriggers(
             QtGui.QAbstractItemView.NoEditTriggers)
-        self.PreviewListWidget.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.PreviewListWidget.setHorizontalScrollBarPolicy(
+            QtCore.Qt.ScrollBarAlwaysOff)
         self.PreviewListWidget.setAlternatingRowColors(True)
         self.ControllerLayout.addWidget(self.PreviewListWidget)
         # Build the full toolbar
@@ -221,7 +224,8 @@ class SlideController(QtGui.QWidget):
             self.Toolbar.addToolbarWidget(
                 u'Image SpinBox', self.DelaySpinBox)
             self.DelaySpinBox.setSuffix(self.trUtf8('s'))
-            self.DelaySpinBox.setToolTip(self.trUtf8('Delay between slides in seconds'))
+            self.DelaySpinBox.setToolTip(
+                self.trUtf8('Delay between slides in seconds'))
         self.ControllerLayout.addWidget(self.Toolbar)
         #Build a Media ToolBar
         self.Mediabar = OpenLPToolbar(self)
@@ -394,8 +398,9 @@ class SlideController(QtGui.QWidget):
         self.Toolbar.makeWidgetsInvisible(self.loop_list)
         if item.is_text():
             self.Toolbar.makeWidgetsInvisible(self.loop_list)
-            if str_to_bool(self.songsconfig.get_config(u'show songbar', True)) \
+            if QtCore.QSettings().value(
-                and len(self.slideList) > 0:
+                self.songsSettingsSection + u'/show songbar',
+                QtCore.QVariant(True)).toBool() and len(self.slideList) > 0:
                 self.Toolbar.makeWidgetsVisible([u'Song Menu'])
         if item.is_capable(ItemCapabilities.AllowsLoop) and \
             len(item.get_frames()) > 1:
@@ -403,7 +408,7 @@ class SlideController(QtGui.QWidget):
         if item.is_media():
             self.Toolbar.setVisible(False)
             self.Mediabar.setVisible(True)
-            #self.volumeSlider.setAudioOutput(self.parent.mainDisplay.videoDisplay.audio)
+            #self.volumeSlider.setAudioOutput(self.mainDisplay.videoDisplay.audio)
 
     def enablePreviewToolBar(self, item):
         """
@@ -583,8 +588,9 @@ class SlideController(QtGui.QWidget):
         if force:
             self.blankButton.setChecked(True)
         self.blankScreen(HideMode.Blank, self.blankButton.isChecked())
-        self.parent.generalConfig.set_config(u'screen blank',
+        QtCore.QSettings().setValue(
-            self.blankButton.isChecked())
+            self.generalSettingsSection + u'/screen blank',
+            QtCore.QVariant(self.blankButton.isChecked()))
 
     def onThemeDisplay(self, force=False):
         """
@@ -603,9 +609,9 @@ class SlideController(QtGui.QWidget):
         if force:
             self.hideButton.setChecked(True)
         if self.hideButton.isChecked():
-            self.parent.mainDisplay.hideDisplay()
+            self.mainDisplay.hideDisplay()
         else:
-            self.parent.mainDisplay.showDisplay()
+            self.mainDisplay.showDisplay()
 
     def blankScreen(self, blankType, blanked=False):
         """
@@ -613,15 +619,16 @@ class SlideController(QtGui.QWidget):
         """
         if self.serviceItem is not None:
             if blanked:
-                Receiver.send_message(u'%s_blank' % self.serviceItem.name.lower(), 
+                Receiver.send_message(
+                    u'%s_blank' % self.serviceItem.name.lower(),
                     [self.serviceItem, self.isLive])
             else:
                 Receiver.send_message(u'%s_unblank' 
                     % self.serviceItem.name.lower(), 
                     [self.serviceItem, self.isLive])
-            self.parent.mainDisplay.blankDisplay(blankType, blanked)
+            self.mainDisplay.blankDisplay(blankType, blanked)
         else:
-            self.parent.mainDisplay.blankDisplay(blankType, blanked)
+            self.mainDisplay.blankDisplay(blankType, blanked)
 
     def onSlideSelected(self):
         """
@@ -642,12 +649,15 @@ class SlideController(QtGui.QWidget):
                     self.SlidePreview.setPixmap(QtGui.QPixmap.fromImage(frame))
                 else:
                     if isinstance(frame[u'main'], basestring):
-                        self.SlidePreview.setPixmap(QtGui.QPixmap(frame[u'main']))
+                        self.SlidePreview.setPixmap(
+                            QtGui.QPixmap(frame[u'main']))
                     else:
-                        self.SlidePreview.setPixmap(QtGui.QPixmap.fromImage(frame[u'main']))
+                        self.SlidePreview.setPixmap(
-                log.log(15, u'Slide Rendering took %4s' % (time.time() - before))
+                            QtGui.QPixmap.fromImage(frame[u'main']))
+                log.log(
+                    15, u'Slide Rendering took %4s' % (time.time() - before))
                 if self.isLive:
-                    self.parent.displayManager.mainDisplay.frameView(frame, True)
+                    self.mainDisplay.frameView(frame, True)
             self.selectedRow = row
 
     def onSlideChange(self, row):

openlp/core/ui/thememanager.py

@@ -33,10 +33,10 @@ from PyQt4 import QtCore, QtGui
 
 from openlp.core.ui import AmendThemeForm
 from openlp.core.theme import Theme
-from openlp.core.lib import PluginConfig, OpenLPToolbar, contextMenuAction, \
+from openlp.core.lib import OpenLPToolbar, contextMenuAction, \
     ThemeXML, str_to_bool, get_text_file_string, build_icon, Receiver, \
-    contextMenuSeparator
+    contextMenuSeparator, SettingsManager
-from openlp.core.utils import ConfigHelper
+from openlp.core.utils import AppLocation
 
 log = logging.getLogger(__name__)
 
@@ -47,6 +47,7 @@ class ThemeManager(QtGui.QWidget):
     def __init__(self, parent):
         QtGui.QWidget.__init__(self, parent)
         self.parent = parent
+        self.settingsSection = u'themes'
         self.Layout = QtGui.QVBoxLayout(self)
         self.Layout.setSpacing(0)
         self.Layout.setMargin(0)
@@ -105,16 +106,15 @@ class ThemeManager(QtGui.QWidget):
             QtCore.SIGNAL(u'theme_update_global'), self.changeGlobalFromTab)
         #Variables
         self.themelist = []
-        self.path = os.path.join(ConfigHelper.get_data_path(), u'themes')
+        self.path = AppLocation.get_section_data_path(self.settingsSection)
         self.checkThemesExists(self.path)
         self.thumbPath = os.path.join(self.path, u'.thumbnails')
         self.checkThemesExists(self.thumbPath)
         self.amendThemeForm.path = self.path
         # Last little bits of setting up
-        self.config = PluginConfig(u'themes')
+        self.global_theme = unicode(QtCore.QSettings().value(
-        self.servicePath = self.config.get_data_path()
+            self.settingsSection + u'/global theme',
-        self.global_theme = unicode(
+            QtCore.QVariant(u'')).toString())
-            self.config.get_config(u'global theme', u''))
 
     def changeGlobalFromTab(self, themeName):
         log.debug(u'changeGlobalFromTab %s', themeName)
@@ -146,7 +146,9 @@ class ThemeManager(QtGui.QWidget):
                     self.ThemeListWidget.item(count).text())
                 name = u'%s (%s)' % (self.global_theme, self.trUtf8('default'))
                 self.ThemeListWidget.item(count).setText(name)
-                self.config.set_config(u'global theme', self.global_theme)
+                QtCore.QSettings().setValue(
+                    self.settingsSection + u'/global theme',
+                    QtCore.QVariant(self.global_theme))
                 Receiver.send_message(u'theme_update_global', self.global_theme)
                 self.pushThemes()
 
@@ -167,8 +169,9 @@ class ThemeManager(QtGui.QWidget):
             self.amendThemeForm.exec_()
 
     def onDeleteTheme(self):
-        self.global_theme = unicode(
+        self.global_theme = unicode(QtCore.QSettings().value(
-            self.config.get_config(u'global theme', u''))
+            self.settingsSection + u'/global theme',
+            QtCore.QVariant(u'')).toString())
         item = self.ThemeListWidget.currentItem()
         if item:
             theme = unicode(item.text())
@@ -221,10 +224,10 @@ class ThemeManager(QtGui.QWidget):
         theme = unicode(item.data(QtCore.Qt.UserRole).toString())
         path = QtGui.QFileDialog.getExistingDirectory(self,
             unicode(self.trUtf8('Save Theme - (%s)')) %  theme,
-            self.config.get_last_dir(1) )
+            SettingsManager.get_last_dir(self.settingsSection, 1))
         path = unicode(path)
         if path:
-            self.config.set_last_dir(path, 1)
+            SettingsManager.set_last_dir(self.settingsSection, path, 1)
             themePath = os.path.join(path, theme + u'.theme')
             zip = None
             try:
@@ -233,7 +236,8 @@ class ThemeManager(QtGui.QWidget):
                 for root, dirs, files in os.walk(source):
                     for name in files:
                         zip.write(
-                            os.path.join(source, name), os.path.join(theme, name))
+                            os.path.join(source, name),
+                            os.path.join(theme, name))
             except:
                 log.exception(u'Export Theme Failed')
             finally:
@@ -243,11 +247,12 @@ class ThemeManager(QtGui.QWidget):
     def onImportTheme(self):
         files = QtGui.QFileDialog.getOpenFileNames(
             self, self.trUtf8('Select Theme Import File'),
-            self.config.get_last_dir(), u'Theme (*.*)')
+            SettingsManager.get_last_dir(self.settingsSection), u'Theme (*.*)')
         log.info(u'New Themes %s', unicode(files))
         if files:
             for file in files:
-                self.config.set_last_dir(unicode(file))
+                SettingsManager.set_last_dir(
+                    self.settingsSection, unicode(file))
                 self.unzipTheme(file, self.path)
         self.loadThemes()
 

openlp/core/ui/themestab.py

@@ -123,9 +123,13 @@ class ThemesTab(SettingsTab):
             'songs.'))
 
     def load(self):
-        self.theme_level = int(self.config.get_config(u'theme level',
+        settings = QtCore.QSettings()
-            ThemeLevel.Global))
+        settings.beginGroup(self.settingsSection)
-        self.global_theme = self.config.get_config(u'global theme', u'')
+        self.theme_level = settings.value(
+            u'theme level', QtCore.QVariant(ThemeLevel.Global)).toInt()[0]
+        self.global_theme = unicode(settings.value(
+            u'global theme', QtCore.QVariant(u'')).toString())
+        settings.endGroup()
         if self.theme_level == ThemeLevel.Global:
             self.GlobalLevelRadioButton.setChecked(True)
         elif self.theme_level == ThemeLevel.Service:
@@ -134,8 +138,13 @@ class ThemesTab(SettingsTab):
             self.SongLevelRadioButton.setChecked(True)
 
     def save(self):
-        self.config.set_config(u'theme level', self.theme_level)
+        settings = QtCore.QSettings()
-        self.config.set_config(u'global theme',self.global_theme)
+        settings.beginGroup(self.settingsSection)
+        settings.setValue(u'theme level',
+            QtCore.QVariant(self.theme_level))
+        settings.setValue(u'global theme',
+            QtCore.QVariant(self.global_theme))
+        settings.endGroup()
         Receiver.send_message(u'theme_update_global', self.global_theme)
         self.parent.RenderManager.set_global_theme(
             self.global_theme, self.theme_level)
@@ -169,7 +178,9 @@ class ThemesTab(SettingsTab):
         Called from ThemeManager when the Themes have changed
         """
         #reload as may have been triggered by the ThemeManager
-        self.global_theme = self.config.get_config(u'global theme', u'')
+        self.global_theme = unicode(QtCore.QSettings().value(
+            self.settingsSection + u'/global theme',
+            QtCore.QVariant(u'')).toString())
         self.DefaultComboBox.clear()
         for theme in theme_list:
             self.DefaultComboBox.addItem(theme)
@@ -188,4 +199,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

@@ -64,7 +64,8 @@ class AppLocation(object):
             else:
                 try:
                     from xdg import BaseDirectory
-                    path = os.path.join(BaseDirectory.xdg_config_home, u'openlp')
+                    path = os.path.join(
+                        BaseDirectory.xdg_config_home, u'openlp')
                 except ImportError:
                     path = os.path.join(os.getenv(u'HOME'), u'.openlp')
             return path
@@ -97,27 +98,44 @@ class AppLocation(object):
                 plugin_path = os.path.split(openlp.__file__)[0]
             return plugin_path
 
+    @staticmethod
+    def get_data_path():
+        path = AppLocation.get_directory(AppLocation.DataDir)
+        if not os.path.exists(path):
+            os.makedirs(path)
+        return path
 
-def check_latest_version(config, current_version):
+    @staticmethod
+    def get_section_data_path(section):
+        data_path = AppLocation.get_data_path()
+        path = os.path.join(data_path, section)
+        if not os.path.exists(path):
+            os.makedirs(path)
+        return path
+
+
+def check_latest_version(current_version):
     """
     Check the latest version of OpenLP against the version file on the OpenLP
     site.
 
-    ``config``
-        The OpenLP config object.
-
     ``current_version``
         The current version of OpenLP.
     """
     version_string = current_version[u'full']
-    #set to prod in the distribution confif file.
+    #set to prod in the distribution config file.
-    last_test = config.get_config(u'last version test', datetime.now().date())
+    settings = QtCore.QSettings()
+    settings.beginGroup(u'general')
+    last_test = unicode(settings.value(u'last version test',
+        QtCore.QVariant(datetime.now().date())).toString())
     this_test = unicode(datetime.now().date())
-    config.set_config(u'last version test', this_test)
+    settings.setValue(u'last version test', QtCore.QVariant(this_test))
+    settings.endGroup()
     if last_test != this_test:
         version_string = u''
         if current_version[u'build']:
-            req = urllib2.Request(u'http://www.openlp.org/files/dev_version.txt')
+            req = urllib2.Request(
+                u'http://www.openlp.org/files/dev_version.txt')
         else:
             req = urllib2.Request(u'http://www.openlp.org/files/version.txt')
         req.add_header(u'User-Agent', u'OpenLP/%s' % current_version[u'full'])
@@ -149,8 +167,23 @@ def variant_to_unicode(variant):
         string = string_to_unicode(string)
     return string
 
-from registry import Registry
+def add_actions(target, actions):
-from confighelper import ConfigHelper
+    """
+    Adds multiple actions to a menu or toolbar in one command.
+
+    ``target``
+        The menu or toolbar to add actions to.
+
+    ``actions``
+        The actions to be added.  An action consisting of the keyword 'None'
+        will result in a separator being inserted into the target.
+    """
+    for action in actions:
+        if action is None:
+            target.addSeparator()
+        else:
+            target.addAction(action)
+
 from languagemanager import LanguageManager
 
-__all__ = [u'Registry', u'ConfigHelper', u'AppLocation', u'LanguageManager',  u'check_latest_version']
+__all__ = [u'AppLocation', u'check_latest_version', u'add_actions',  u'LanguageManager']

openlp/core/utils/confighelper.py

@@ -1,76 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4
-
-###############################################################################
-# OpenLP - Open Source Lyrics Projection                                      #
-# --------------------------------------------------------------------------- #
-# Copyright (c) 2008-2010 Raoul Snyman                                        #
-# Portions copyright (c) 2008-2010 Tim Bentley, Jonathan Corwin, Michael      #
-# Gorven, Scott Guerrieri, Christian Richter, Maikel Stuivenberg, Martin      #
-# Thompson, Jon Tibble, Carsten Tinggaard                                     #
-# --------------------------------------------------------------------------- #
-# 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 os
-
-from openlp.core.utils import AppLocation
-from openlp.core.utils.registry import Registry
-
-class ConfigHelper(object):
-    """
-    Utility Helper to allow classes to find directories in a standard manner.
-    """
-    __registry__ = None
-
-    @staticmethod
-    def get_data_path():
-        path = AppLocation.get_directory(AppLocation.DataDir)
-        if not os.path.exists(path):
-            os.makedirs(path)
-        return path
-
-    @staticmethod
-    def get_config(section, key, default=None):
-        reg = ConfigHelper.get_registry()
-        if reg.has_value(section, key):
-            return reg.get_value(section, key, default)
-        else:
-            if default:
-                ConfigHelper.set_config(section, key, default)
-            return default
-
-    @staticmethod
-    def set_config(section, key, value):
-        reg = ConfigHelper.get_registry()
-        if not reg.has_section(section):
-            reg.create_section(section)
-        return reg.set_value(section, key, value)
-
-    @staticmethod
-    def delete_config(section, key):
-        reg = ConfigHelper.get_registry()
-        reg.delete_value(section, key)
-
-    @staticmethod
-    def get_registry():
-        """
-        This static method loads the appropriate registry class based on the
-        current operating system, and returns an instantiation of that class.
-        """
-        if ConfigHelper.__registry__ is None:
-            config_path = AppLocation.get_directory(AppLocation.ConfigDir)
-            ConfigHelper.__registry__ = Registry(config_path)
-        return ConfigHelper.__registry__
-

openlp/core/utils/languagemanager.py

@@ -28,7 +28,7 @@ import logging
 from logging import FileHandler
 from PyQt4 import QtCore, QtGui
 import os
-from openlp.core.utils import AppLocation, ConfigHelper
+from openlp.core.utils import AppLocation
 from openlp.core.lib import translate
 
 log = logging.getLogger()
@@ -68,8 +68,8 @@ class LanguageManager(object):
 
     @staticmethod
     def get_language():
-        language = ConfigHelper.get_registry().get_value(u'general', 
+        language = unicode(QtCore.QSettings().value(
-                                u'language', u'[en]')
+            u'general/language', QtCore.QVariant(u'[en]')).toString())
         log.info(u'Language file: \'%s\' Loaded from conf file' % language)
         regEx = QtCore.QRegExp("^\[(.*)\]")
         if regEx.exactMatch(language):
@@ -85,8 +85,9 @@ class LanguageManager(object):
             language = u'[%s]' % qmList[actionName]
         else:
             language = u'%s' % qmList[actionName]
+        QtCore.QSettings().setValue(
+            u'general/language', QtCore.QVariant(language))
         log.info(u'Language file: \'%s\' written to conf file' % language)
-        ConfigHelper.set_config(u'general', u'language', language)
         QtGui.QMessageBox.information(None,  
                     translate('LanguageManager', 'Language'), 
                     translate('LanguageManager', 
@@ -100,7 +101,7 @@ class LanguageManager(object):
             regEx = QtCore.QRegExp("^.*openlp_(.*).qm")
             if regEx.exactMatch(qmf):
                 langName = regEx.cap(1)
-                LanguageManager.__qmList__[u'%i %s' % (i, 
+                LanguageManager.__qmList__[u'%#2i %s' % (i+1, 
                             LanguageManager.language_name(qmf))] = langName 
 
     @staticmethod

openlp/core/utils/registry.py

@@ -1,134 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4
-
-###############################################################################
-# OpenLP - Open Source Lyrics Projection                                      #
-# --------------------------------------------------------------------------- #
-# Copyright (c) 2008-2010 Raoul Snyman                                        #
-# Portions copyright (c) 2008-2010 Tim Bentley, Jonathan Corwin, Michael      #
-# Gorven, Scott Guerrieri, Christian Richter, Maikel Stuivenberg, Martin      #
-# Thompson, Jon Tibble, Carsten Tinggaard                                     #
-# --------------------------------------------------------------------------- #
-# 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 os
-
-from ConfigParser import SafeConfigParser
-
-class Registry(object):
-    """
-    The Registry class is a high-level class for working with a configuration
-    file.
-    """
-    def __init__(self, dir):
-        self.config = SafeConfigParser()
-        self.file_name = os.path.join(dir, u'openlp.conf')
-        self._load()
-
-    def has_value(self, section, key):
-        """
-        Check if a value exists.
-        """
-        return self.config.has_option(section.encode('utf-8'), 
-            key.encode('utf-8'))
-
-    def get_value(self, section, key, default=None):
-        """
-        Get a single value from the registry.
-        """
-        try:
-            if self.config.get(section.encode('utf-8'), key.encode('utf-8')):
-                return self.config.get(section.encode('utf-8'), 
-                    key.encode('utf-8')).decode('utf-8')
-            else:
-                return default
-        except:
-            return default
-
-    def set_value(self, section, key, value):
-        """
-        Set a single value in the registry.
-        """
-        try :
-            self.config.set(section.encode('utf-8'), key.encode('utf-8'), 
-                unicode(value).encode('utf-8'))
-            return self._save()
-        except:
-            return False
-
-    def delete_value(self, section, key):
-        """
-        Delete a single value from the registry.
-        """
-        try:
-            self.config.remove_option(section.encode('utf-8'), 
-                key.encode('utf-8'))
-            return self._save()
-        except:
-            return False
-
-    def has_section(self, section):
-        """
-        Check if a section exists.
-        """
-        return self.config.has_section(section.encode('utf-8'))
-
-    def create_section(self, section):
-        """
-        Create a new section in the registry.
-        """
-        try:
-            self.config.add_section(section.encode('utf-8'))
-            return self._save()
-        except:
-            return False
-
-    def delete_section(self, section):
-        """
-        Delete a section (including all values).
-        """
-        try:
-            self.config.remove_section(section.encode('utf-8'))
-            return self._save()
-        except:
-            return False
-
-    def _load(self):
-        if not os.path.isfile(self.file_name):
-            return False
-        file_handle = None
-        try:
-            file_handle = open(self.file_name, u'r')
-            self.config.readfp(file_handle)
-            return True
-        except:
-            return False
-        finally:
-            if file_handle:
-                file_handle.close()
-
-    def _save(self):
-        file_handle = None
-        try:
-            if not os.path.exists(os.path.dirname(self.file_name)):
-                os.makedirs(os.path.dirname(self.file_name))
-            file_handle = open(self.file_name, u'w')
-            self.config.write(file_handle)
-            return self._load()
-        except:
-            return False
-        finally:
-            if file_handle:
-                file_handle.close()

openlp/migration/migratebibles.py

@@ -31,7 +31,8 @@ from sqlalchemy import *
 from sqlalchemy import create_engine
 from sqlalchemy.orm import scoped_session, sessionmaker, mapper
 
-from openlp.core.lib import PluginConfig
+from openlp.core.lib import SettingsManager
+from openlp.core.utils import AppLocation
 from openlp.plugins.bibles.lib.models import *
     
 class BaseModel(object):
@@ -111,9 +112,8 @@ def init_models(url):
 class MigrateBibles():
     def __init__(self, display):
         self.display = display
-        self.config = PluginConfig(u'Bibles')
+        self.data_path = AppLocation.get_section_data_path(u'bibles')
-        self.data_path = self.config.get_data_path()
+        self.database_files = SettingsManager.get_files(u'bibles', u'.sqlite')
-        self.database_files = self.config.get_files(u'sqlite')
         print self.database_files
 
     def progress(self, text):

openlp/migration/migratefiles.py

@@ -23,7 +23,7 @@
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
 
-from openlp.core.utils import ConfigHelper
+from openlp.core.utils import AppLocation
 
 class MigrateFiles():
     def __init__(self, display):
@@ -36,14 +36,19 @@ class MigrateFiles():
 
     def _initial_setup(self):
         self.display.output(u'Initial Setup started')
-        ConfigHelper.get_data_path()
+        data_path = AppLocation.get_data_path()
+        print data_path
         self.display.sub_output(u'Config created')
-        ConfigHelper.get_config(u'bible', u'data path')
+        bibles_path = AppLocation.get_section_data_path(u'bibles')
+        print bibles_path
         self.display.sub_output(u'Config created')
-        ConfigHelper.get_config(u'videos', u'data path')
+        # Media doesn't use a directory like the other plugins.
-        self.display.sub_output(u'videos created')
+        #media_path = AppLocation.get_section_data_path(u'media')
-        ConfigHelper.get_config(u'images', u'data path')
+        #self.display.sub_output(u'videos created')
+        images_path = AppLocation.get_section_data_path(u'images')
+        print images_path
         self.display.sub_output(u'images created')
-        ConfigHelper.get_config(u'presentations', u'data path')
+        presentations_path = AppLocation.get_section_data_path(u'presentations')
+        print presentations_path
         self.display.sub_output(u'presentations created')
         self.display.output(u'Initial Setup finished')

openlp/migration/migratesongs.py

@@ -31,7 +31,8 @@ from sqlalchemy import  *
 from sqlalchemy import create_engine
 from sqlalchemy.orm import scoped_session, sessionmaker, mapper, relation
 
-from openlp.core.lib import PluginConfig
+from openlp.core.lib import SettingsManager
+from openlp.core.utils import AppLocation
 from openlp.plugins.songs.lib.models import metadata, songs_table, Song, \
     Author, Topic, Book
 from openlp.plugins.songs.lib.tables import *
@@ -111,9 +112,8 @@ class TSongAuthor(BaseModel):
 class MigrateSongs():
     def __init__(self, display):
         self.display = display
-        self.config = PluginConfig(u'Songs')
+        self.data_path = AppLocation.get_section_data_path(u'songs')
-        self.data_path = self.config.get_data_path()
+        self.database_files = SettingsManager.get_files(u'songs', u'.sqlite')
-        self.database_files = self.config.get_files(u'sqlite')
         print self.database_files
 
     def process(self):

openlp/plugins/alerts/alertsplugin.py

@@ -27,7 +27,7 @@ import logging
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import Plugin, build_icon, PluginStatus, Receiver
+from openlp.core.lib import Plugin, build_icon, PluginStatus
 from openlp.plugins.alerts.lib import AlertsManager, DBManager
 from openlp.plugins.alerts.forms import AlertsTab, AlertForm
 
@@ -41,7 +41,7 @@ class alertsPlugin(Plugin):
         self.weight = -3
         self.icon = build_icon(u':/media/media_image.png')
         self.alertsmanager = AlertsManager(self)
-        self.manager = DBManager(self.config)
+        self.manager = DBManager()
         self.alertForm = AlertForm(self.manager, self)
         self.status = PluginStatus.Active
 
@@ -83,7 +83,9 @@ class alertsPlugin(Plugin):
 
     def togglealertsState(self):
         self.alertsActive = not self.alertsActive
-        self.config.set_config(u'active', self.alertsActive)
+        QtCore.QSettings().setValue(
+            self.settings_section + u'/active',
+            QtCore.QVariant(self.alertsActive))
 
     def onAlertsTrigger(self):
         self.alertForm.loadList()

openlp/plugins/alerts/forms/alertstab.py

@@ -25,16 +25,16 @@
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import SettingsTab, str_to_bool
+from openlp.core.lib import SettingsTab
 
 class AlertsTab(SettingsTab):
     """
     AlertsTab is the alerts settings tab in the settings dialog.
     """
-    def __init__(self, parent, section=None):
+    def __init__(self, parent):
         self.parent = parent
         self.manager = parent.manager
-        SettingsTab.__init__(self, parent.name, section)
+        SettingsTab.__init__(self, parent.name)
 
     def setupUi(self):
         self.setObjectName(u'AlertsTab')
@@ -228,15 +228,20 @@ class AlertsTab(SettingsTab):
         self.updateDisplay()
 
     def load(self):
-        self.timeout = int(self.config.get_config(u'timeout', 5))
+        settings = QtCore.QSettings()
-        self.font_color = unicode(
+        settings.beginGroup(self.settingsSection)
-            self.config.get_config(u'font color', u'#ffffff'))
+        self.timeout = settings.value(u'timeout', QtCore.QVariant(5)).toInt()[0]
-        self.font_size = int(self.config.get_config(u'font size', 40))
+        self.font_color = unicode(settings.value(
-        self.bg_color = unicode(
+            u'font color', QtCore.QVariant(u'#ffffff')).toString())
-            self.config.get_config(u'background color', u'#660000'))
+        self.font_size = settings.value(
-        self.font_face = unicode(
+            u'font size', QtCore.QVariant(40)).toInt()[0]
-            self.config.get_config(u'font face', QtGui.QFont().family()))
+        self.bg_color = unicode(settings.value(
-        self.location = int(self.config.get_config(u'location', 0))
+            u'background color', QtCore.QVariant(u'#660000')).toString())
+        self.font_face = unicode(settings.value(
+            u'font face', QtCore.QVariant(QtGui.QFont().family())).toString())
+        self.location = settings.value(
+            u'location', QtCore.QVariant(0)).toInt()[0]
+        settings.endGroup()
         self.FontSizeSpinBox.setValue(self.font_size)
         self.TimeoutSpinBox.setValue(self.timeout)
         self.FontColorButton.setStyleSheet(
@@ -254,14 +259,17 @@ class AlertsTab(SettingsTab):
         self.DeleteButton.setEnabled(True)
 
     def save(self):
+        settings = QtCore.QSettings()
+        settings.beginGroup(self.settingsSection)
         self.font_face = self.FontComboBox.currentFont().family()
-        self.config.set_config(u'background color', unicode(self.bg_color))
+        settings.setValue(u'background color', QtCore.QVariant(self.bg_color))
-        self.config.set_config(u'font color', unicode(self.font_color))
+        settings.setValue(u'font color', QtCore.QVariant(self.font_color))
-        self.config.set_config(u'font size', unicode(self.font_size))
+        settings.setValue(u'font size', QtCore.QVariant(self.font_size))
-        self.config.set_config(u'font face', unicode(self.font_face))
+        settings.setValue(u'font face', QtCore.QVariant(self.font_face))
-        self.config.set_config(u'timeout', unicode(self.timeout))
+        settings.setValue(u'timeout', QtCore.QVariant(self.timeout))
-        self.config.set_config(u'location',
+        settings.setValue(u'location',
-                        unicode(self.LocationComboBox.currentIndex()))
+            QtCore.QVariant(self.LocationComboBox.currentIndex()))
+        settings.endGroup()
 
     def updateDisplay(self):
         font = QtGui.QFont()

openlp/plugins/alerts/lib/manager.py

@@ -25,6 +25,9 @@
 
 import logging
 
+from PyQt4 import QtCore
+
+from openlp.core.utils import AppLocation
 from openlp.plugins.alerts.lib.models import init_models, metadata, AlertItem
 
 log = logging.getLogger(__name__)
@@ -36,27 +39,29 @@ class DBManager():
     """
     log.info(u'Alerts DB loaded')
 
-    def __init__(self, config):
+    def __init__(self):
         """
         Creates the connection to the database, and creates the tables if they
         don't exist.
         """
-        self.config = config
         log.debug(u'Alerts Initialising')
+        settings = QtCore.QSettings()
+        settings.beginGroup(u'alerts')
         self.db_url = u''
-        db_type = self.config.get_config(u'db type', u'sqlite')
+        db_type = unicode(
+            settings.value(u'db type', QtCore.QVariant(u'sqlite')).toString())
         if db_type == u'sqlite':
             self.db_url = u'sqlite:///%s/alerts.sqlite' % \
-                self.config.get_data_path()
+                AppLocation.get_section_data_path(u'alerts')
         else:
-            self.db_url = u'%s://%s:%s@%s/%s' % \
+            self.db_url = u'%s://%s:%s@%s/%s' % (db_type,
-                (db_type, self.config.get_config(u'db username'),
+                unicode(settings.value(u'db username').toString()),
-                    self.config.get_config(u'db password'),
+                unicode(settings.value(u'db password').toString()),
-                    self.config.get_config(u'db hostname'),
+                unicode(settings.value(u'db hostname').toString()),
-                    self.config.get_config(u'db database'))
+                unicode(settings.value(u'db database').toString()))
+        settings.endGroup()
         self.session = init_models(self.db_url)
         metadata.create_all(checkfirst=True)
-
         log.debug(u'Alerts Initialised')
 
     def get_all_alerts(self):

openlp/plugins/bibles/bibleplugin.py

@@ -46,7 +46,7 @@ class BiblePlugin(Plugin):
     def initialise(self):
         log.info(u'bibles Initialising')
         if self.manager is None:
-            self.manager = BibleManager(self, self.config)
+            self.manager = BibleManager(self)
         Plugin.initialise(self)
         self.insert_toolbox_item()
         self.ImportBibleItem.setVisible(True)

openlp/plugins/bibles/forms/importwizardform.py

@@ -31,7 +31,7 @@ import os.path
 from PyQt4 import QtCore, QtGui
 
 from bibleimportwizard import Ui_BibleImportWizard
-from openlp.core.lib import Receiver
+from openlp.core.lib import Receiver, SettingsManager
 from openlp.core.utils import AppLocation, variant_to_unicode
 from openlp.plugins.bibles.lib.manager import BibleFormat
 
@@ -59,16 +59,13 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
     """
     log.info(u'BibleImportForm loaded')
 
-    def __init__(self, parent, config, manager, bibleplugin):
+    def __init__(self, parent, manager, bibleplugin):
         """
         Instantiate the wizard, and run any extra setup we need to.
 
         ``parent``
             The QWidget-derived parent of the wizard.
 
-        ``config``
-            The configuration object for storing and retrieving settings.
-
         ``manager``
             The Bible manager.
 
@@ -81,7 +78,6 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
         self.finishButton = self.button(QtGui.QWizard.FinishButton)
         self.cancelButton = self.button(QtGui.QWizard.CancelButton)
         self.manager = manager
-        self.config = config
         self.bibleplugin = bibleplugin
         self.manager.set_process_dialog(self)
         self.web_bible_list = {}
@@ -277,6 +273,8 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
             u'license_permission', self.PermissionEdit)
 
     def setDefaults(self):
+        settings = QtCore.QSettings()
+        settings.beginGroup(self.bibleplugin.settings_section)
         self.setField(u'source_format', QtCore.QVariant(0))
         self.setField(u'osis_location', QtCore.QVariant(''))
         self.setField(u'csv_booksfile', QtCore.QVariant(''))
@@ -285,15 +283,17 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
         self.setField(u'web_location', QtCore.QVariant(WebDownload.Crosswalk))
         self.setField(u'web_biblename', QtCore.QVariant(self.BibleComboBox))
         self.setField(u'proxy_server',
-            QtCore.QVariant(self.config.get_config(u'proxy address', '')))
+            settings.value(u'proxy address', QtCore.QVariant(u'')))
         self.setField(u'proxy_username',
-            QtCore.QVariant(self.config.get_config(u'proxy username','')))
+            settings.value(u'proxy username', QtCore.QVariant(u'')))
         self.setField(u'proxy_password',
-            QtCore.QVariant(self.config.get_config(u'proxy password','')))
+            settings.value(u'proxy password', QtCore.QVariant(u'')))
         self.setField(u'license_version', QtCore.QVariant(self.VersionNameEdit))
         self.setField(u'license_copyright', QtCore.QVariant(self.CopyrightEdit))
-        self.setField(u'license_permission', QtCore.QVariant(self.PermissionEdit))
+        self.setField(u'license_permission',
+            QtCore.QVariant(self.PermissionEdit))
         self.onLocationComboBoxChanged(WebDownload.Crosswalk)
+        settings.endGroup()
 
     def loadWebBibles(self):
         """
@@ -302,10 +302,10 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
         #Load and store Crosswalk Bibles
         filepath = AppLocation.get_directory(AppLocation.PluginsDir)
         filepath = os.path.join(filepath, u'bibles', u'resources')
-        fbibles = None
         try:
             self.web_bible_list[WebDownload.Crosswalk] = {}
-            books_file = open(os.path.join(filepath, u'crosswalkbooks.csv'), 'r')
+            books_file = open(
+                os.path.join(filepath, u'crosswalkbooks.csv'), 'r')
             dialect = csv.Sniffer().sniff(books_file.read(1024))
             books_file.seek(0)
             books_reader = csv.reader(books_file, dialect)
@@ -345,10 +345,11 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
 
     def getFileName(self, title, editbox):
         filename = QtGui.QFileDialog.getOpenFileName(self, title,
-            self.config.get_last_dir(1))
+            SettingsManager.get_last_dir(self.bibleplugin.settings_section, 1))
         if filename:
             editbox.setText(filename)
-            self.config.set_last_dir(filename, 1)
+            SettingsManager.set_last_dir(
+                self.bibleplugin.settings_section, filename, 1)
 
     def incrementProgressBar(self, status_text):
         log.debug(u'IncrementBar %s', status_text)
@@ -368,7 +369,8 @@ class ImportWizardForm(QtGui.QWizard, Ui_BibleImportWizard):
         bible_type = self.field(u'source_format').toInt()[0]
         license_version = variant_to_unicode(self.field(u'license_version'))
         license_copyright = variant_to_unicode(self.field(u'license_copyright'))
-        license_permission = variant_to_unicode(self.field(u'license_permission'))
+        license_permission = variant_to_unicode(
+            self.field(u'license_permission'))
         importer = None
         if bible_type == BibleFormat.OSIS:
             # Import an OSIS bible

openlp/plugins/bibles/lib/biblestab.py

@@ -27,7 +27,7 @@ import logging
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import str_to_bool, Receiver, SettingsTab
+from openlp.core.lib import Receiver, SettingsTab
 
 log = logging.getLogger(__name__)
 
@@ -37,11 +37,11 @@ class BiblesTab(SettingsTab):
     """
     log.info(u'Bible Tab loaded')
 
-    def __init__(self, title, section=None):
+    def __init__(self, title):
         self.paragraph_style = True
         self.show_new_chapters = False
         self.display_style = 0
-        SettingsTab.__init__(self, title, section)
+        SettingsTab.__init__(self, title)
 
     def setupUi(self):
         self.setObjectName(u'BiblesTab')
@@ -150,7 +150,8 @@ class BiblesTab(SettingsTab):
 
     def retranslateUi(self):
         self.VerseDisplayGroupBox.setTitle(self.trUtf8('Verse Display'))
-        self.NewChaptersCheckBox.setText(self.trUtf8('Only show new chapter numbers'))
+        self.NewChaptersCheckBox.setText(
+            self.trUtf8('Only show new chapter numbers'))
         self.LayoutStyleLabel.setText(self.trUtf8('Layout Style:'))
         self.DisplayStyleLabel.setText(self.trUtf8('Display Style:'))
         self.BibleThemeLabel.setText(self.trUtf8('Bible Theme:'))
@@ -161,8 +162,8 @@ class BiblesTab(SettingsTab):
         self.DisplayStyleComboBox.setItemText(1, self.trUtf8('( and )'))
         self.DisplayStyleComboBox.setItemText(2, self.trUtf8('{ and }'))
         self.DisplayStyleComboBox.setItemText(3, self.trUtf8('[ and ]'))
-        self.ChangeNoteLabel.setText(
+        self.ChangeNoteLabel.setText(self.trUtf8(
-            self.trUtf8('Note:\nChanges don\'t affect verses already in the service'))
+            'Note:\nChanges don\'t affect verses already in the service'))
         self.BibleDualCheckBox.setText(self.trUtf8('Display Dual Bible Verses'))
 
     def onBibleThemeComboBoxChanged(self):
@@ -187,29 +188,36 @@ class BiblesTab(SettingsTab):
             self.duel_bibles = True
 
     def load(self):
-        self.show_new_chapters = str_to_bool(
+        settings = QtCore.QSettings()
-            self.config.get_config(u'display new chapter', u'False'))
+        settings.beginGroup(self.settingsSection)
-        self.display_style = int(
+        self.show_new_chapters = settings.value(
-            self.config.get_config(u'display brackets', u'0'))
+            u'display new chapter', QtCore.QVariant(False)).toBool()
-        self.layout_style = int(
+        self.display_style = settings.value(
-            self.config.get_config(u'verse layout style', u'0'))
+            u'display brackets', QtCore.QVariant(0)).toInt()[0]
-        self.bible_theme = self.config.get_config(u'bible theme', u'0')
+        self.layout_style = settings.value(
-        self.duel_bibles = str_to_bool(
+            u'verse layout style', QtCore.QVariant(0)).toInt()[0]
-            self.config.get_config(u'dual bibles', u'True'))
+        self.bible_theme = unicode(
+            settings.value(u'bible theme', QtCore.QVariant(u'')).toString())
+        self.duel_bibles = settings.value(
+            u'dual bibles', QtCore.QVariant(True)).toBool()
         self.NewChaptersCheckBox.setChecked(self.show_new_chapters)
         self.DisplayStyleComboBox.setCurrentIndex(self.display_style)
         self.LayoutStyleComboBox.setCurrentIndex(self.layout_style)
         self.BibleDualCheckBox.setChecked(self.duel_bibles)
+        settings.endGroup()
 
     def save(self):
-        self.config.set_config(
+        settings = QtCore.QSettings()
-            u'display new chapter', unicode(self.show_new_chapters))
+        settings.beginGroup(self.settingsSection)
-        self.config.set_config(
+        settings.setValue(u'display new chapter',
-            u'display brackets', unicode(self.display_style))
+            QtCore.QVariant(self.show_new_chapters))
-        self.config.set_config(
+        settings.setValue(u'display brackets',
-            u'verse layout style', unicode(self.layout_style))
+            QtCore.QVariant(self.display_style))
-        self.config.set_config(u'dual bibles', unicode(self.duel_bibles))
+        settings.setValue(u'verse layout style',
-        self.config.set_config(u'bible theme', unicode(self.bible_theme))
+            QtCore.QVariant(self.layout_style))
+        settings.setValue(u'dual bibles', QtCore.QVariant(self.duel_bibles))
+        settings.setValue(u'bible theme', QtCore.QVariant(self.bible_theme))
+        settings.endGroup()
 
     def updateThemeList(self, theme_list):
         """
@@ -225,4 +233,4 @@ class BiblesTab(SettingsTab):
             # Not Found
             id = 0
             self.bible_theme = u''
-        self.BibleThemeComboBox.setCurrentIndex(id)
+        self.BibleThemeComboBox.setCurrentIndex(id)

openlp/plugins/bibles/lib/db.py

@@ -56,20 +56,14 @@ class BibleDB(QtCore.QObject):
         ``name``
             The name of the database. This is also used as the file name for
             SQLite databases.
-
-        ``config``
-            The configuration object, passed in from the plugin.
         """
         log.info(u'BibleDB loaded')
         QtCore.QObject.__init__(self)
         if u'path' not in kwargs:
             raise KeyError(u'Missing keyword argument "path".')
-        if u'config' not in kwargs:
-            raise KeyError(u'Missing keyword argument "config".')
         if u'name' not in kwargs and u'file' not in kwargs:
             raise KeyError(u'Missing keyword argument "name" or "file".')
         self.stop_import_flag = False
-        self.config = kwargs[u'config']
         if u'name' in kwargs:
             self.name = kwargs[u'name']
             if not isinstance(self.name, unicode):
@@ -79,16 +73,20 @@ class BibleDB(QtCore.QObject):
             self.file = kwargs[u'file']
         self.db_file = os.path.join(kwargs[u'path'], self.file)
         log.debug(u'Load bible %s on path %s', self.file, self.db_file)
-        db_type = self.config.get_config(u'db type', u'sqlite')
+        settings = QtCore.QSettings()
+        settings.beginGroup(u'bibles')
+        db_type = unicode(
+            settings.value(u'db type', QtCore.QVariant(u'sqlite')).toString())
         db_url = u''
         if db_type == u'sqlite':
             db_url = u'sqlite:///' + self.db_file
         else:
-            db_url = u'%s://%s:%s@%s/%s' % \
+            db_url = u'%s://%s:%s@%s/%s' % (db_type,
-                (db_type, self.config.get_config(u'db username'),
+                unicode(settings.value(u'db username').toString()),
-                    self.config.get_config(u'db password'),
+                unicode(settings.value(u'db password').toString()),
-                    self.config.get_config(u'db hostname'),
+                unicode(settings.value(u'db hostname').toString()),
-                    self.config.get_config(u'db database'))
+                unicode(settings.value(u'db database').toString()))
+        settings.endGroup()
         self.metadata, self.session = init_models(db_url)
         self.metadata.create_all(checkfirst=True)
         if u'file' in kwargs:

openlp/plugins/bibles/lib/manager.py

@@ -25,6 +25,11 @@
 
 import logging
 
+from PyQt4 import QtCore
+
+from openlp.core.lib import SettingsManager
+from openlp.core.utils import AppLocation
+
 from common import parse_reference
 from opensong import OpenSongBible
 from osis import OSISBible
@@ -94,25 +99,24 @@ class BibleManager(object):
     """
     log.info(u'Bible manager loaded')
 
-    def __init__(self, parent, config):
+    def __init__(self, parent):
         """
         Finds all the bibles defined for the system and creates an interface
         object for each bible containing connection information. Throws
         Exception if no Bibles are found.
 
         Init confirms the bible exists and stores the database path.
-
-        ``config``
-            The plugin's configuration object.
         """
         log.debug(u'Bible Initialising')
-        self.config = config
         self.parent = parent
+        self.settings_section = u'bibles'
         self.web = u'Web'
         self.db_cache = None
-        self.path = self.config.get_data_path()
+        self.path = AppLocation.get_section_data_path(self.settings_section)
-        self.proxy_name = self.config.get_config(u'proxy name')
+        self.proxy_name = unicode(
-        self.suffix = u'sqlite'
+            QtCore.QSettings().value(self.settings_section + u'/proxy name',
+            QtCore.QVariant(u'')).toString())
+        self.suffix = u'.sqlite'
         self.import_wizard = None
         self.reload_bibles()
         self.media = None
@@ -124,23 +128,23 @@ class BibleManager(object):
         BibleDB class.
         """
         log.debug(u'Reload bibles')
-        files = self.config.get_files(self.suffix)
+        files = SettingsManager.get_files(self.settings_section, self.suffix)
         log.debug(u'Bible Files %s', files)
         self.db_cache = {}
         for filename in files:
-            bible = BibleDB(self.parent, path=self.path, file=filename,
+            bible = BibleDB(self.parent, path=self.path, file=filename)
-                            config=self.config)
             name = bible.get_name()
             log.debug(u'Bible Name: "%s"', name)
             self.db_cache[name] = bible
             # look to see if lazy load bible exists and get create getter.
             source = self.db_cache[name].get_meta(u'download source')
             if source:
-                download_name = self.db_cache[name].get_meta(u'download name').value
+                download_name = \
+                    self.db_cache[name].get_meta(u'download name').value
                 meta_proxy = self.db_cache[name].get_meta(u'proxy url')
                 web_bible = HTTPBible(self.parent, path=self.path,
-                    file=filename, config=self.config,
+                    file=filename, download_source=source.value,
-                    download_source=source.value, download_name=download_name)
+                    download_name=download_name)
                 if meta_proxy:
                     web_bible.set_proxy_server(meta_proxy.value)
                 self.db_cache[name] = web_bible
@@ -167,7 +171,6 @@ class BibleManager(object):
         """
         class_ = BibleFormat.get_class(type)
         kwargs['path'] = self.path
-        kwargs['config'] = self.config
         importer = class_(self.parent, **kwargs)
         name = importer.register(self.import_wizard)
         self.db_cache[name] = importer
@@ -208,7 +211,8 @@ class BibleManager(object):
         Returns all the number of verses for a given
         book and chapterMaxBibleBookVerses
         """
-        log.debug(u'BibleManager.get_verse_count("%s", "%s", %s)', bible, book, chapter)
+        log.debug(u'BibleManager.get_verse_count("%s", "%s", %s)',
+            bible, book, chapter)
         return self.db_cache[bible].get_verse_count(book, chapter)
 
     def get_verses(self, bible, versetext):
@@ -260,4 +264,3 @@ class BibleManager(object):
             if bible == name:
                 return True
         return False
-

openlp/plugins/bibles/lib/mediaitem.py

@@ -28,8 +28,8 @@ import time
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import MediaManagerItem, Receiver, str_to_bool, \
+from openlp.core.lib import MediaManagerItem, Receiver, BaseListWithDnD, \
-    BaseListWithDnD, ItemCapabilities
+    ItemCapabilities
 from openlp.plugins.bibles.forms import ImportWizardForm
 
 log = logging.getLogger(__name__)
@@ -54,7 +54,7 @@ class BibleMediaItem(MediaManagerItem):
 
     def __init__(self, parent, icon, title):
         self.PluginNameShort = u'Bible'
-        self.ConfigSection = title
+        self.SettingsSection = title.lower()
         self.IconPath = u'songs/song'
         self.ListViewWithDnD_class = BibleListView
         self.lastReference = []
@@ -276,8 +276,8 @@ class BibleMediaItem(MediaManagerItem):
         self.SearchProgress.setObjectName(u'SearchProgress')
 
     def configUpdated(self):
-        if str_to_bool(
+        if QtCore.QSettings().value(self.SettingsSection + u'/dual bibles',
-            self.parent.config.get_config(u'dual bibles', u'False')):
+            QtCore.QVariant(False)).toBool():
             self.AdvancedSecondBibleLabel.setVisible(True)
             self.AdvancedSecondBibleComboBox.setVisible(True)
             self.QuickSecondVersionLabel.setVisible(True)
@@ -381,7 +381,7 @@ class BibleMediaItem(MediaManagerItem):
             self.AdvancedBookComboBox.itemData(item).toInt()[0])
 
     def onImportClick(self):
-        self.bibleimportform = ImportWizardForm(self, self.parent.config,
+        self.bibleimportform = ImportWizardForm(self,
             self.parent.manager, self.parent)
         self.bibleimportform.exec_()
         self.reloadBibles()

openlp/plugins/bibles/lib/osis.py

@@ -98,7 +98,8 @@ class OSISBible(BibleDB):
         Loads a Bible from file.
         """
         log.debug(u'Starting OSIS import from "%s"' % self.filename)
-        self.wizard.incrementProgressBar(u'Detecting encoding (this may take a few minutes)...')
+        self.wizard.incrementProgressBar(
+            u'Detecting encoding (this may take a few minutes)...')
         detect_file = None
         try:
             detect_file = open(self.filename, u'r')

openlp/plugins/custom/customplugin.py

@@ -45,7 +45,7 @@ class CustomPlugin(Plugin):
     def __init__(self, plugin_helpers):
         Plugin.__init__(self, u'Custom', u'1.9.1', plugin_helpers)
         self.weight = -5
-        self.custommanager = CustomManager(self.config)
+        self.custommanager = CustomManager()
         self.edit_custom_form = EditCustomForm(self.custommanager)
         self.icon = build_icon(u':/media/media_custom.png')
         self.status = PluginStatus.Active

openlp/plugins/custom/lib/customtab.py

@@ -25,14 +25,14 @@
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import SettingsTab, str_to_bool
+from openlp.core.lib import SettingsTab
 
 class CustomTab(SettingsTab):
     """
     CustomTab is the Custom settings tab in the settings dialog.
     """
-    def __init__(self, title, section=None):
+    def __init__(self, title):
-        SettingsTab.__init__(self, title, section)
+        SettingsTab.__init__(self, title)
 
     def setupUi(self):
         self.setObjectName(u'CustomTab')
@@ -57,7 +57,7 @@ class CustomTab(SettingsTab):
     def retranslateUi(self):
         self.CustomModeGroupBox.setTitle(self.trUtf8('Custom Display'))
         self.DisplayFooterCheckBox.setText(
-            self.trUtf8('Display Footer:'))
+            self.trUtf8('Display Footer'))
 
     def onDisplayFooterCheckBoxChanged(self, check_state):
         self.displayFooter = False
@@ -66,9 +66,11 @@ class CustomTab(SettingsTab):
             self.displayFooter = True
 
     def load(self):
-        self.displayFooter = str_to_bool(
+        self.displayFooter = QtCore.QSettings().value(
-            self.config.get_config(u'display footer', True))
+            self.settingsSection + u'/display footer',
+            QtCore.QVariant(True)).toBool()
         self.DisplayFooterCheckBox.setChecked(self.displayFooter)
 
     def save(self):
-        self.config.set_config(u'display footer', unicode(self.displayFooter))
+        QtCore.QSettings().setValue(self.settingsSection + u'/display footer',
+            QtCore.QVariant(self.displayFooter))

openlp/plugins/custom/lib/manager.py

@@ -25,6 +25,9 @@
 
 import logging
 
+from PyQt4 import QtCore
+
+from openlp.core.utils import AppLocation
 from openlp.plugins.custom.lib.models import init_models, metadata, CustomSlide
 
 log = logging.getLogger(__name__)
@@ -36,27 +39,29 @@ class CustomManager():
     """
     log.info(u'Custom manager loaded')
 
-    def __init__(self, config):
+    def __init__(self):
         """
         Creates the connection to the database, and creates the tables if they
         don't exist.
         """
-        self.config = config
         log.debug(u'Custom Initialising')
+        settings = QtCore.QSettings()
+        settings.beginGroup(u'custom')
         self.db_url = u''
-        db_type = self.config.get_config(u'db type', u'sqlite')
+        db_type = unicode(
+            settings.value(u'db type', QtCore.QVariant(u'sqlite')).toString())
         if db_type == u'sqlite':
             self.db_url = u'sqlite:///%s/custom.sqlite' % \
-                self.config.get_data_path()
+                AppLocation.get_section_data_path(u'custom')
         else:
-            self.db_url = u'%s://%s:%s@%s/%s' % \
+            self.db_url = u'%s://%s:%s@%s/%s' % (db_type,
-                (db_type, self.config.get_config(u'db username'),
+                unicode(settings.value(u'db username').toString()),
-                    self.config.get_config(u'db password'),
+                unicode(settings.value(u'db password').toString()),
-                    self.config.get_config(u'db hostname'),
+                unicode(settings.value(u'db hostname').toString()),
-                    self.config.get_config(u'db database'))
+                unicode(settings.value(u'db database').toString()))
         self.session = init_models(self.db_url)
         metadata.create_all(checkfirst=True)
-
+        settings.endGroup()
         log.debug(u'Custom Initialised')
 
     def get_all_slides(self):
@@ -107,4 +112,5 @@ class CustomManager():
             return True
 
     def get_customs_for_theme(self, theme):
-        return self.session.query(CustomSlide).filter(CustomSlide.theme_name == theme).all()
+        return self.session.query(
+            CustomSlide).filter(CustomSlide.theme_name == theme).all()

openlp/plugins/custom/lib/mediaitem.py

@@ -27,8 +27,8 @@ import logging
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import MediaManagerItem, SongXMLParser, BaseListWithDnD,\
+from openlp.core.lib import MediaManagerItem, SongXMLParser, BaseListWithDnD, \
-Receiver, str_to_bool, ItemCapabilities
+    Receiver, ItemCapabilities
 
 log = logging.getLogger(__name__)
 
@@ -45,7 +45,7 @@ class CustomMediaItem(MediaManagerItem):
 
     def __init__(self, parent, icon, title):
         self.PluginNameShort = u'Custom'
-        self.ConfigSection = title
+        self.SettingsSection = title.lower()
         self.IconPath = u'custom/custom'
         # this next is a class, not an instance of a class - it will
         # be instanced by the base MediaManagerItem
@@ -133,7 +133,7 @@ class CustomMediaItem(MediaManagerItem):
             self.ListView.takeItem(row)
 
     def generateSlideData(self, service_item, item=None):
-        raw_slides =[]
+        raw_slides = []
         raw_footer = []
         slide = None
         theme = None
@@ -164,8 +164,8 @@ class CustomMediaItem(MediaManagerItem):
         service_item.title = title
         for slide in raw_slides:
             service_item.add_from_text(slide[:30], slide)
-        if str_to_bool(self.parent.config.get_config(u'display footer', True)) \
+        if QtCore.QSettings().value(self.SettingsSection + u'/display footer',
-            or credit:
+            QtCore.QVariant(True)).toBool() or credit:
             raw_footer.append(title + u' ' + credit)
         else:
             raw_footer.append(u'')

openlp/plugins/images/lib/imagetab.py

@@ -31,8 +31,8 @@ class ImageTab(SettingsTab):
     """
     ImageTab is the Image settings tab in the settings dialog.
     """
-    def __init__(self, title, section=None):
+    def __init__(self, title):
-        SettingsTab.__init__(self, title, section)
+        SettingsTab.__init__(self, title)
 
     def setupUi(self):
         self.setObjectName(u'ImageTab')
@@ -71,11 +71,14 @@ class ImageTab(SettingsTab):
         self.loop_delay = self.TimeoutSpinBox.value()
 
     def load(self):
-        self.loop_delay = int(self.config.get_config(u'loop delay', 5))
+        self.loop_delay = QtCore.QSettings().value(
+            self.settingsSection + u'/loop delay',
+            QtCore.QVariant(5)).toInt()[0]
         self.TimeoutSpinBox.setValue(self.loop_delay)
 
     def save(self):
-        self.config.set_config(u'loop delay', self.loop_delay)
+        QtCore.QSettings().setValue(self.settingsSection + u'/loop delay',
+            QtCore.QVariant(self.loop_delay))
         Receiver.send_message(u'slidecontroller_live_spin_delay', 
             self.loop_delay)
 

openlp/plugins/images/lib/mediaitem.py

@@ -27,8 +27,10 @@ import logging
 import os
 
 from PyQt4 import QtCore, QtGui
+
 from openlp.core.lib import MediaManagerItem, BaseListWithDnD, build_icon, \
-    contextMenuAction, ItemCapabilities
+    contextMenuAction, ItemCapabilities, SettingsManager
+from openlp.core.utils import AppLocation
 
 log = logging.getLogger(__name__)
 
@@ -47,7 +49,7 @@ class ImageMediaItem(MediaManagerItem):
 
     def __init__(self, parent, icon, title):
         self.PluginNameShort = u'Image'
-        self.ConfigSection = title
+        self.SettingsSection = title.lower()
         self.IconPath = u'images/image'
         # this next is a class, not an instance of a class - it will
         # be instanced by the base MediaManagerItem
@@ -59,8 +61,8 @@ class ImageMediaItem(MediaManagerItem):
 
     def retranslateUi(self):
         self.OnNewPrompt = self.trUtf8('Select Image(s)')
-        self.OnNewFileMasks = \
+        self.OnNewFileMasks = self.trUtf8(
-            self.trUtf8('Images (*.jpg *.jpeg *.gif *.png *.bmp);; All files (*)')
+            'Images (*.jpg *.jpeg *.gif *.png *.bmp);; All files (*)')
 
     def requiredIcons(self):
         MediaManagerItem.requiredIcons(self)
@@ -76,10 +78,12 @@ class ImageMediaItem(MediaManagerItem):
             QtGui.QAbstractItemView.ExtendedSelection)
         self.ListView.setIconSize(QtCore.QSize(88,50))
         self.servicePath = os.path.join(
-            self.parent.config.get_data_path(), u'.thumbnails')
+            AppLocation.get_section_data_path(self.SettingsSection),
+            u'.thumbnails')
         if not os.path.exists(self.servicePath):
             os.mkdir(self.servicePath)
-        self.loadList(self.parent.config.load_list(self.ConfigSection))
+        self.loadList(SettingsManager.load_list(
+            self.SettingsSection, self.SettingsSection))
 
     def addListViewToToolBar(self):
         MediaManagerItem.addListViewToToolBar(self)
@@ -112,12 +116,14 @@ class ImageMediaItem(MediaManagerItem):
             for item in items:
                 text = self.ListView.item(item.row())
                 try:
-                    os.remove(os.path.join(self.servicePath, unicode(text.text())))
+                    os.remove(
+                        os.path.join(self.servicePath, unicode(text.text())))
                 except:
                     #if not present do not worry
                     pass
                 self.ListView.takeItem(item.row())
-                self.parent.config.set_list(self.ConfigSection, self.getFileList())
+                SettingsManager.set_list(
+                    self.SettingsSection, self.getFileList())
 
     def loadList(self, list):
         for file in list:

openlp/plugins/media/lib/mediaitem.py

@@ -29,7 +29,7 @@ import os
 from PyQt4 import QtCore, QtGui
 
 from openlp.core.lib import MediaManagerItem, BaseListWithDnD, build_icon, \
-ItemCapabilities
+    ItemCapabilities, SettingsManager
 
 log = logging.getLogger(__name__)
 
@@ -47,12 +47,12 @@ class MediaMediaItem(MediaManagerItem):
     def __init__(self, parent, icon, title):
         self.PluginNameShort = u'Media'
         self.IconPath = u'images/image'
-        self.ConfigSection = u'media'
+        self.SettingsSection = title.lower()
-        self.ConfigSection = title
         # this next is a class, not an instance of a class - it will
         # be instanced by the base MediaManagerItem
         self.ListViewWithDnD_class = MediaListView
-        self.PreviewFunction = QtGui.QPixmap(u':/media/media_video.png').toImage()
+        self.PreviewFunction = QtGui.QPixmap(
+            u':/media/media_video.png').toImage()
         MediaManagerItem.__init__(self, parent, icon, title)
         self.singleServiceItem = False
         self.ServiceItemIconName = u':/media/media_video.png'
@@ -89,15 +89,15 @@ class MediaMediaItem(MediaManagerItem):
         self.ListView.setSelectionMode(
             QtGui.QAbstractItemView.ExtendedSelection)
         self.ListView.setIconSize(QtCore.QSize(88,50))
-        self.loadList(self.parent.config.load_list(self.ConfigSection))
+        self.loadList(SettingsManager.load_list(
+            self.SettingsSection, self.SettingsSection))
 
     def onDeleteClick(self):
         item = self.ListView.currentItem()
         if item:
             row = self.ListView.row(item)
             self.ListView.takeItem(row)
-            self.parent.config.set_list(
+            SettingsManager.set_list(self.SettingsSection, self.getFileList())
-                self.ConfigSection, self.getFileList())
 
     def loadList(self, list):
         for file in list:
@@ -106,4 +106,4 @@ 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)

openlp/plugins/presentations/lib/mediaitem.py

@@ -28,7 +28,9 @@ import os
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import MediaManagerItem, BaseListWithDnD, build_icon
+from openlp.core.lib import MediaManagerItem, BaseListWithDnD, build_icon, \
+    SettingsManager
+from openlp.core.utils import AppLocation
 from openlp.plugins.presentations.lib import MessageListener
 
 log = logging.getLogger(__name__)
@@ -50,7 +52,7 @@ class PresentationMediaItem(MediaManagerItem):
     def __init__(self, parent, icon, title, controllers):
         self.controllers = controllers
         self.PluginNameShort = u'Presentation'
-        self.ConfigSection = title
+        self.SettingsSection = title.lower()
         self.IconPath = u'presentations/presentation'
         self.Automatic = u''
         # this next is a class, not an instance of a class - it will
@@ -68,7 +70,8 @@ class PresentationMediaItem(MediaManagerItem):
         fileType = u''
         for controller in self.controllers:
             if self.controllers[controller].enabled:
-                types = self.controllers[controller].supports + self.controllers[controller].alsosupports
+                types = self.controllers[controller].supports + \
+                    self.controllers[controller].alsosupports
                 for type in types:
                     if fileType.find(type) == -1:
                         fileType += u'*%s ' % type
@@ -104,10 +107,11 @@ class PresentationMediaItem(MediaManagerItem):
 
     def initialise(self):
         self.servicePath = os.path.join(
-            self.parent.config.get_data_path(), u'thumbnails')
+            AppLocation.get_section_data_path(self.SettingsSection),
+            u'thumbnails')
         if not os.path.exists(self.servicePath):
             os.mkdir(self.servicePath)
-        list = self.parent.config.load_list(u'presentations')
+        list = SettingsManager.load_list(self.SettingsSection, u'presentations')
         self.loadList(list)
         for item in self.controllers:
             #load the drop down selection
@@ -134,17 +138,20 @@ class PresentationMediaItem(MediaManagerItem):
             else:
                 icon = None
                 for controller in self.controllers:
-                    thumbPath = os.path.join(self.parent.config.get_data_path(), \
+                    thumbPath = os.path.join(
+                        AppLocation.get_section_data_path(self.SettingsSection),
                         u'thumbnails', controller, filename)
                     thumb = os.path.join(thumbPath, u'slide1.png')
-                    preview = os.path.join(self.parent.config.get_data_path(), \
+                    preview = os.path.join(
+                        AppLocation.get_section_data_path(self.SettingsSection),
                         controller, u'thumbnails', filename, u'slide1.png')
                     if os.path.exists(preview):
                         if os.path.exists(thumb):
                             if self.validate(preview, thumb):
                                 icon = build_icon(thumb)
                             else:
-                                icon = build_icon(u':/general/general_delete.png')
+                                icon = build_icon(
+                                    u':/general/general_delete.png')
                         else:
                             os.makedirs(thumbPath)
                             icon = self.IconFromFile(preview, thumb)
@@ -160,8 +167,7 @@ class PresentationMediaItem(MediaManagerItem):
         if item:
             row = self.ListView.row(item)
             self.ListView.takeItem(row)
-            self.parent.config.set_list(
+            SettingsManager.set_list(self.SettingsSection, self.getFileList())
-                self.ConfigSection, self.getFileList())
             filepath = unicode((item.data(QtCore.Qt.UserRole)).toString())
             #not sure of this has errors
             #John please can you look at .

openlp/plugins/presentations/lib/messagelistener.py

@@ -165,7 +165,8 @@ class Controller(object):
         if not self.isLive:
             return
         self.activate()
-        if self.doc.slidenumber and self.doc.slidenumber != self.doc.get_slide_number():
+        if self.doc.slidenumber and \
+            self.doc.slidenumber != self.doc.get_slide_number():
             self.doc.goto_slide(self.doc.slidenumber)
         self.doc.unblank_screen()
 
@@ -186,26 +187,27 @@ class MessageListener(object):
         self.liveHandler = Controller(True)
         # messages are sent from core.ui.slidecontroller
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_start'), self.startup)
+            QtCore.SIGNAL(u'presentations_start'), self.startup)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_stop'), self.shutdown)
+            QtCore.SIGNAL(u'presentations_stop'), self.shutdown)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_first'), self.first)
+            QtCore.SIGNAL(u'presentations_first'), self.first)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_previous'), self.previous)
+            QtCore.SIGNAL(u'presentations_previous'), self.previous)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_next'), self.next)
+            QtCore.SIGNAL(u'presentations_next'), self.next)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_last'), self.last)
+            QtCore.SIGNAL(u'presentations_last'), self.last)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_slide'), self.slide)
+            QtCore.SIGNAL(u'presentations_slide'), self.slide)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_blank'), self.blank)
+            QtCore.SIGNAL(u'presentations_blank'), self.blank)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'presentation_unblank'), self.unblank)
+            QtCore.SIGNAL(u'presentations_unblank'), self.unblank)
         self.timer = QtCore.QTimer()
         self.timer.setInterval(500)
-        QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.timeout)
+        QtCore.QObject.connect(
+            self.timer, QtCore.SIGNAL("timeout()"), self.timeout)
 
     def startup(self, message):
         """
@@ -279,11 +281,10 @@ class MessageListener(object):
         if isLive:
             self.liveHandler.blank()
 
-    def unblank(self,  message):
+    def unblank(self, message):
         isLive, item = self.decode_message(message)
         if isLive:
             self.liveHandler.unblank()
         
     def timeout(self):
         self.liveHandler.poll()
-        

openlp/plugins/presentations/lib/presentationcontroller.py

@@ -30,6 +30,7 @@ import shutil
 from PyQt4 import QtCore
 
 from openlp.core.lib import Receiver
+from openlp.core.utils import AppLocation
 
 log = logging.getLogger(__name__)
 
@@ -68,7 +69,8 @@ class PresentationController(object):
         Called at system exit to clean up any running presentations
 
     ``check_available()``
-        Returns True if presentation application is installed/can run on this machine
+        Returns True if presentation application is installed/can run on this
+        machine
 
     ``presentation_deleted()``
         Deletes presentation specific files, e.g. thumbnails
@@ -78,13 +80,14 @@ class PresentationController(object):
 
     def __init__(self, plugin=None, name=u'PresentationController'):
         """
-        This is the constructor for the presentationcontroller object.
+        This is the constructor for the presentationcontroller object.  This
-        This provides an easy way for descendent plugins to populate common data.
+        provides an easy way for descendent plugins to populate common data.
         This method *must* be overridden, like so::
 
             class MyPresentationController(PresentationController):
                 def __init__(self, plugin):
-                    PresentationController.__init(self, plugin, u'My Presenter App')
+                    PresentationController.__init(
+                        self, plugin, u'My Presenter App')
 
         ``plugin``
             Defaults to *None*. The presentationplugin object
@@ -97,13 +100,16 @@ class PresentationController(object):
         self.docs = []
         self.plugin = plugin
         self.name = name
+        self.settings_section = self.plugin.settings_section
         self.available = self.check_available()
         if self.available:
-            self.enabled = int(plugin.config.get_config(
+            self.enabled = QtCore.QSettings().value(
-                name, QtCore.Qt.Unchecked)) == QtCore.Qt.Checked
+                self.settings_section + u'/' + name,
+                QtCore.Qt.Unchecked).toInt()[0] == QtCore.Qt.Checked
         else:
             self.enabled = False
-        self.thumbnailroot = os.path.join(plugin.config.get_data_path(),
+        self.thumbnailroot = os.path.join(
+            AppLocation.get_section_data_path(self.settings_section),
             name, u'thumbnails')
         self.thumbnailprefix = u'slide'
         if not os.path.isdir(self.thumbnailroot):
@@ -241,7 +247,8 @@ class PresentationDocument(object):
         return os.path.split(presentation)[1]
 
     def get_thumbnail_path(self,  presentation):
-        return os.path.join(self.controller.thumbnailroot, self.get_file_name(presentation))
+        return os.path.join(
+            self.controller.thumbnailroot, self.get_file_name(presentation))
 
     def check_thumbnails(self):
         """
@@ -326,11 +333,11 @@ class PresentationDocument(object):
         pass
 
     def next_step(self):
-       """
+        """
-       Triggers the next effect of slide on the running presentation
+        Triggers the next effect of slide on the running presentation
-       This might be the next animation on the current slide, or the next slide
+        This might be the next animation on the current slide, or the next slide
-       """
+        """
-       pass
+        pass
 
     def previous_step(self):
         """

openlp/plugins/presentations/lib/presentationtab.py

@@ -23,7 +23,7 @@
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
 
-from PyQt4 import QtGui
+from PyQt4 import QtCore, QtGui
 
 from openlp.core.lib import SettingsTab
 
@@ -31,9 +31,9 @@ class PresentationTab(SettingsTab):
     """
     PresentationsTab is the Presentations settings tab in the settings dialog.
     """
-    def __init__(self, title, controllers, section=None):
+    def __init__(self, title, controllers):
         self.controllers = controllers
-        SettingsTab.__init__(self, title, section)
+        SettingsTab.__init__(self, title)
 
     def setupUi(self):
         self.setObjectName(u'PresentationTab')
@@ -93,19 +93,21 @@ class PresentationTab(SettingsTab):
             controller = self.controllers[key]
             checkbox = self.PresenterCheckboxes[controller.name]
             checkbox.setText(
-                u'%s %s:' % (controller.name, self.trUtf8('available')))
+                u'%s %s' % (controller.name, self.trUtf8('available')))
 
     def load(self):
         for key in self.controllers:
             controller = self.controllers[key]
             if controller.available:
                 checkbox = self.PresenterCheckboxes[controller.name]
-                checkbox.setChecked(
+                checkbox.setChecked(QtCore.QSettings().value(
-                    int(self.config.get_config(controller.name, 0)))
+                    self.settingsSection + u'/' + controller.name,
+                    QtCore.QVariant(0)).toInt()[0])
 
     def save(self):
         for key in self.controllers:
             controller = self.controllers[key]
             checkbox = self.PresenterCheckboxes[controller.name]
-            self.config.set_config(
+            QtCore.QSettings().setValue(
-                controller.name, unicode(checkbox.checkState()))
+                self.settingsSection + u'/' + controller.name,
+                QtCore.QVariant(checkbox.checkState()))

openlp/plugins/presentations/presentationplugin.py

@@ -26,7 +26,7 @@
 import os
 import logging
 
-from openlp.core.lib import Plugin, build_icon, Receiver, PluginStatus
+from openlp.core.lib import Plugin, build_icon, PluginStatus
 from openlp.core.utils import AppLocation
 from openlp.plugins.presentations.lib import *
 
@@ -96,7 +96,9 @@ class PresentationPlugin(Plugin):
                     try:
                         __import__(modulename, globals(), locals(), [])
                     except ImportError, e:
-                        log.error(u'Failed to import %s on path %s for reason %s', modulename, path, e.args[0])
+                        log.error(
+                            u'Failed to import %s on path %s for reason %s',
+                            modulename, path, e.args[0])
         controller_classes = PresentationController.__subclasses__()
         for controller_class in controller_classes:
             controller = controller_class(self)

openlp/plugins/remotes/lib/remotetab.py

@@ -23,7 +23,7 @@
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
 
-from PyQt4 import QtGui
+from PyQt4 import QtCore, QtGui
 
 from openlp.core.lib import SettingsTab
 
@@ -31,8 +31,8 @@ class RemoteTab(SettingsTab):
     """
     RemoteTab is the Remotes settings tab in the settings dialog.
     """
-    def __init__(self, title, section=None):
+    def __init__(self, title):
-        SettingsTab.__init__(self, title, section)
+        SettingsTab.__init__(self, title)
 
     def setupUi(self):
         self.setObjectName(u'RemoteTab')
@@ -57,8 +57,9 @@ class RemoteTab(SettingsTab):
 
     def load(self):
         self.RemotePortSpinBox.setValue(
-            int(self.config.get_config(u'remote port', 4316)))
+            QtCore.QSettings().value(self.settingsSection + u'/remote port',
+                QtCore.QVariant(4316)).toInt()[0])
 
     def save(self):
-        self.config.set_config(
+        QtCore.QSettings().setValue(self.settingsSection + u'/remote port',
-            u'remote port', unicode(self.RemotePortSpinBox.value()))
+            QtCore.QVariant(self.RemotePortSpinBox.value()))

openlp/plugins/remotes/remoteplugin.py

@@ -45,7 +45,9 @@ class RemotesPlugin(Plugin):
         Plugin.initialise(self)
         self.insert_toolbox_item()
         self.server = QtNetwork.QUdpSocket()
-        self.server.bind(int(self.config.get_config(u'remote port', 4316)))
+        self.server.bind(
+            QtCore.QSettings().value(self.settings_section + u'/remote port',
+            QtCore.QVariant(4316)).toInt()[0])
         QtCore.QObject.connect(self.server,
             QtCore.SIGNAL(u'readyRead()'), self.readData)
 

openlp/plugins/songs/lib/manager.py

@@ -25,6 +25,9 @@
 
 import logging
 
+from PyQt4 import QtCore
+
+from openlp.core.utils import AppLocation
 from openlp.plugins.songs.lib.models import init_models, metadata, Song, \
     Author, Topic, Book
 
@@ -37,26 +40,33 @@ class SongManager():
     """
     log.info(u'Song manager loaded')
 
-    def __init__(self, config):
+    def __init__(self):
         """
         Creates the connection to the database, and creates the tables if they
         don't exist.
         """
-        self.config = config
         log.debug(u'Song Initialising')
+        settings = QtCore.QSettings()
+        settings.beginGroup(u'songs')
         self.db_url = u''
-        db_type = self.config.get_config(u'db type', u'sqlite')
+        db_type = unicode(
+            settings.value(u'songs/db type', u'sqlite').toString())
         if db_type == u'sqlite':
             self.db_url = u'sqlite:///%s/songs.sqlite' % \
-                self.config.get_data_path()
+                AppLocation.get_section_data_path(u'songs')
         else:
-            self.db_url = db_type + 'u://' + \
+            self.db_url = u'%s://%s:%s@%s/%s' % (db_type,
-                self.config.get_config(u'db username') + u':' + \
+                unicode(settings.value(
-                self.config.get_config(u'db password') + u'@' + \
+                    u'db username', QtCore.QVariant(u'')).toString()),
-                self.config.get_config(u'db hostname') + u'/' + \
+                unicode(settings.value(
-                self.config.get_config(u'db database')
+                    u'db password', QtCore.QVariant(u'')).toString()),
+                unicode(settings.value(
+                    u'db hostname', QtCore.QVariant(u'')).toString()),
+                unicode(settings.value(
+                    u'db database', QtCore.QVariant(u'')).toString()))
         self.session = init_models(self.db_url)
         metadata.create_all(checkfirst=True)
+        settings.endGroup()
         log.debug(u'Song Initialised')
 
     def get_songs(self):

openlp/plugins/songs/lib/mediaitem.py

@@ -28,7 +28,7 @@ import logging
 from PyQt4 import QtCore, QtGui
 
 from openlp.core.lib import MediaManagerItem, SongXMLParser, \
-    BaseListWithDnD, Receiver,  str_to_bool, ItemCapabilities
+    BaseListWithDnD, Receiver, ItemCapabilities
 from openlp.plugins.songs.forms import EditSongForm, SongMaintenanceForm
 
 log = logging.getLogger(__name__)
@@ -46,7 +46,7 @@ class SongMediaItem(MediaManagerItem):
 
     def __init__(self, parent, icon, title):
         self.PluginNameShort = u'Song'
-        self.ConfigSection = title
+        self.SettingsSection = title.lower()
         self.IconPath = u'songs/song'
         self.ListViewWithDnD_class = SongListView
         MediaManagerItem.__init__(self, parent, icon, title)
@@ -133,8 +133,9 @@ class SongMediaItem(MediaManagerItem):
             QtCore.SIGNAL(u'songs_edit_clear'), self.onRemoteEditClear)
 
     def configUpdated(self):
-        self.searchAsYouType = str_to_bool(
+        self.searchAsYouType = QtCore.QSettings().value(
-            self.parent.config.get_config(u'search as type', u'False'))
+            self.SettingsSection + u'/search as type',
+            QtCore.QVariant(u'False')).toBool()
 
     def retranslateUi(self):
         self.SearchTextLabel.setText(self.trUtf8('Search:'))
@@ -350,7 +351,7 @@ class SongMediaItem(MediaManagerItem):
             author_list = author_list + unicode(author.display_name)
             author_audit.append(unicode(author.display_name))
         if song.ccli_number is None or len(song.ccli_number) == 0:
-            ccli = self.parent.settings.GeneralTab.CCLINumber
+            ccli = self.parent.settings_form.GeneralTab.CCLINumber
         else:
             ccli = unicode(song.ccli_number)
         raw_footer.append(song.title)

openlp/plugins/songs/lib/songstab.py

@@ -25,14 +25,14 @@
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import SettingsTab, str_to_bool
+from openlp.core.lib import SettingsTab
 
 class SongsTab(SettingsTab):
     """
     SongsTab is the Songs settings tab in the settings dialog.
     """
-    def __init__(self, title, section=None):
+    def __init__(self, title):
-        SettingsTab.__init__(self, title, section)
+        SettingsTab.__init__(self, title)
 
     def setupUi(self):
         self.setObjectName(u'SongsTab')
@@ -63,9 +63,9 @@ class SongsTab(SettingsTab):
     def retranslateUi(self):
         self.SongsModeGroupBox.setTitle(self.trUtf8('Songs Mode'))
         self.SearchAsTypeCheckBox.setText(
-            self.trUtf8('Enable search as you type:'))
+            self.trUtf8('Enable search as you type'))
         self.SongBarActiveCheckBox.setText(
-            self.trUtf8('Display Verses on Live Tool bar:'))
+            self.trUtf8('Display Verses on Live Tool bar'))
 
     def onSearchAsTypeCheckBoxChanged(self, check_state):
         self.song_search = False
@@ -80,13 +80,19 @@ class SongsTab(SettingsTab):
             self.song_bar = True
 
     def load(self):
-        self.song_search = str_to_bool(
+        settings = QtCore.QSettings()
-            self.config.get_config(u'search as type', False))
+        settings.beginGroup(self.settingsSection)
-        self.song_bar = str_to_bool(
+        self.song_search = settings.value(
-            self.config.get_config(u'display songbar', True))
+            u'search as type', QtCore.QVariant(False)).toBool()
+        self.song_bar = settings.value(
+            u'display songbar', QtCore.QVariant(True)).toBool()
         self.SearchAsTypeCheckBox.setChecked(self.song_search)
         self.SongBarActiveCheckBox.setChecked(self.song_bar)
+        settings.endGroup()
 
     def save(self):
-        self.config.set_config(u'search as type', unicode(self.song_search))
+        settings = QtCore.QSettings()
-        self.config.set_config(u'display songbar', unicode(self.song_bar))
+        settings.beginGroup(self.settingsSection)
+        settings.setValue(u'search as type', QtCore.QVariant(self.song_search))
+        settings.setValue(u'display songbar', QtCore.QVariant(self.song_bar))
+        settings.endGroup()

openlp/plugins/songs/songsplugin.py

@@ -51,7 +51,7 @@ class SongsPlugin(Plugin):
         """
         Plugin.__init__(self, u'Songs', u'1.9.1', plugin_helpers)
         self.weight = -10
-        self.songmanager = SongManager(self.config)
+        self.songmanager = SongManager()
         self.openlp_import_form = OpenLPImportForm()
         self.opensong_import_form = OpenSongImportForm()
         self.openlp_export_form = OpenLPExportForm()
@@ -65,7 +65,7 @@ class SongsPlugin(Plugin):
     def initialise(self):
         log.info(u'Songs Initialising')
         #if self.songmanager is None:
-        #    self.songmanager = SongManager(self.config)
+        #    self.songmanager = SongManager()
         Plugin.initialise(self)
         self.insert_toolbox_item()
         self.ImportSongMenu.menuAction().setVisible(True)

openlp/plugins/songusage/forms/songusagedetailform.py

@@ -23,10 +23,12 @@
 # Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
 ###############################################################################
 
+import logging
 import os
 
 from PyQt4 import QtCore, QtGui
-import logging
+
+from openlp.core.lib import SettingsManager
 
 from songusagedetaildialog import Ui_SongUsageDetailDialog
 
@@ -43,6 +45,7 @@ class SongUsageDetailForm(QtGui.QDialog, Ui_SongUsageDetailDialog):
         """
         QtGui.QDialog.__init__(self, None)
         self.parent = parent
+        self.settingsSection = u'songusage'
         self.setupUi(self)
 
     def initialise(self):
@@ -53,15 +56,16 @@ class SongUsageDetailForm(QtGui.QDialog, Ui_SongUsageDetailDialog):
         fromDate = QtCore.QDate(year - 1, 9, 1)
         self.FromDate.setSelectedDate(fromDate)
         self.ToDate.setSelectedDate(toDate)
-        self.FileLineEdit.setText(self.parent.config.get_last_dir(1))
+        self.FileLineEdit.setText(
+            SettingsManager.get_last_dir(self.settingsSection, 1))
 
     def defineOutputLocation(self):
         path = QtGui.QFileDialog.getExistingDirectory(self,
             self.trUtf8('Output File Location'),
-            self.parent.config.get_last_dir(1) )
+            SettingsManager.get_last_dir(self.settingsSection, 1))
         path = unicode(path)
         if path != u'':
-            self.parent.config.set_last_dir(path, 1)
+            SettingsManager.set_last_dir(self.settingsSection, path, 1)
             self.FileLineEdit.setText(path)
 
     def accept(self):
@@ -86,4 +90,3 @@ class SongUsageDetailForm(QtGui.QDialog, Ui_SongUsageDetailDialog):
         finally:
             if file:
                 file.close()
-

openlp/plugins/songusage/lib/manager.py

@@ -25,7 +25,11 @@
 
 import logging
 
-from openlp.plugins.songusage.lib.models import init_models, metadata, SongUsageItem
+from PyQt4 import QtCore
+
+from openlp.core.utils import AppLocation
+from openlp.plugins.songusage.lib.models import init_models, metadata, \
+    SongUsageItem
 
 log = logging.getLogger(__name__)
 
@@ -36,27 +40,33 @@ class SongUsageManager():
     """
     log.info(u'SongUsage manager loaded')
 
-    def __init__(self, config):
+    def __init__(self):
         """
         Creates the connection to the database, and creates the tables if they
         don't exist.
         """
-        self.config = config
         log.debug(u'SongUsage Initialising')
+        settings = QtCore.QSettings()
+        settings.beginGroup(u'songusage')
         self.db_url = u''
-        db_type = self.config.get_config(u'db type', u'sqlite')
+        db_type = unicode(
+            settings.value(u'db type', QtCore.QVariant(u'sqlite')).toString())
         if db_type == u'sqlite':
             self.db_url = u'sqlite:///%s/songusage.sqlite' % \
-                self.config.get_data_path()
+                AppLocation.get_section_data_path(u'songusage')
         else:
-            self.db_url = u'%s://%s:%s@%s/%s' % \
+            self.db_url = u'%s://%s:%s@%s/%s' % (db_type,
-                (db_type, self.config.get_config(u'db username'),
+                unicode(settings.value(u'db username',
-                    self.config.get_config(u'db password'),
+                    QtCore.QVariant(u'')).toString()),
-                    self.config.get_config(u'db hostname'),
+                unicode(settings.value(u'db password',
-                    self.config.get_config(u'db database'))
+                    QtCore.QVariant(u'')).toString()),
+                unicode(settings.value(u'db hostname',
+                    QtCore.QVariant(u'')).toString()),
+                unicode(settings.value(u'db database',
+                    QtCore.QVariant(u'')).toString()))
         self.session = init_models(self.db_url)
         metadata.create_all(checkfirst=True)
-
+        settings.endGroup()
         log.debug(u'SongUsage Initialised')
 
     def get_all_songusage(self, start_date, end_date):

openlp/plugins/songusage/songusageplugin.py

@@ -28,9 +28,10 @@ import logging
 
 from PyQt4 import QtCore, QtGui
 
-from openlp.core.lib import Plugin, Receiver, str_to_bool, build_icon
+from openlp.core.lib import Plugin, Receiver, build_icon
 from openlp.plugins.songusage.lib import SongUsageManager
-from openlp.plugins.songusage.forms import SongUsageDetailForm, SongUsageDeleteForm
+from openlp.plugins.songusage.forms import SongUsageDetailForm, \
+    SongUsageDeleteForm
 from openlp.plugins.songusage.lib.models import SongUsageItem
 
 log = logging.getLogger(__name__)
@@ -107,12 +108,14 @@ class SongUsagePlugin(Plugin):
         log.info(u'SongUsage Initialising')
         Plugin.initialise(self)
         QtCore.QObject.connect(Receiver.get_receiver(),
-            QtCore.SIGNAL(u'slidecontroller_live_started'), self.onReceiveSongUsage)
+            QtCore.SIGNAL(u'slidecontroller_live_started'),
-        self.SongUsageActive = str_to_bool(
+            self.onReceiveSongUsage)
-            self.config.get_config(u'active', False))
+        self.SongUsageActive = QtCore.QSettings().value(
+            self.settings_section + u'/active',
+            QtCore.QVariant(False)).toBool()
         self.SongUsageStatus.setChecked(self.SongUsageActive)
         if self.songusagemanager is None:
-            self.songusagemanager = SongUsageManager(self.config)
+            self.songusagemanager = SongUsageManager()
         self.SongUsagedeleteform = SongUsageDeleteForm(self.songusagemanager)
         self.SongUsagedetailform = SongUsageDetailForm(self)
         self.SongUsageMenu.menuAction().setVisible(True)
@@ -125,7 +128,8 @@ class SongUsagePlugin(Plugin):
 
     def toggleSongUsageState(self):
         self.SongUsageActive = not self.SongUsageActive
-        self.config.set_config(u'active', self.SongUsageActive)
+        QtCore.QSettings().setValue(self.settings_section + u'/active',
+            QtCore.QVariant(self.SongUsageActive))
 
     def onReceiveSongUsage(self, items):
         """

openlpcnv.pyw

@@ -35,6 +35,7 @@ if os.name == u'nt':
     import win32con
     from win32com.client import Dispatch
 
+from openlp.core.utils import AppLocation
 from openlp.migration.display import *
 from openlp.migration.migratefiles import *
 from openlp.migration.migratebibles import *
@@ -103,8 +104,10 @@ class Migration(object):
     def convert_sqlite2_to_3(self, olddb, newdb):
         print u'Converting sqlite2 ' + olddb + ' to sqlite3 ' + newdb
         if os.name == u'nt':
-            # we can't make this a raw unicode string as the \U within it causes much confusion
+            # we can't make this a raw unicode string as the \U within it
-            hKey = win32api.RegOpenKey(win32con.HKEY_LOCAL_MACHINE, u'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\SQLite ODBC Driver')
+            # causes much confusion
+            hKey = win32api.RegOpenKey(win32con.HKEY_LOCAL_MACHINE,
+                u'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\SQLite ODBC Driver')
             value, type = win32api.RegQueryValueEx (hKey, u'UninstallString')
             sqlitepath, temp = os.path.split(value)
             sqliteexe = os.path.join(sqlitepath, u'sqlite.exe')
@@ -133,10 +136,8 @@ class Migration(object):
 
 if __name__ == u'__main__':
     mig = Migration()
-    songconfig = PluginConfig(u'Songs')
+    newsongpath = AppLocation.get_section_data_path(u'songs')
-    newsongpath = songconfig.get_data_path()
+    newbiblepath = AppLocation.get_section_data_path(u'bibles')
-    bibleconfig = PluginConfig(u'Bibles')
-    newbiblepath = bibleconfig.get_data_path()
     if os.name == u'nt':
         if not os.path.isdir(newsongpath):
             os.makedirs(newsongpath)