Introduce system settings policies.

Release-Notes: It is now possible for sysadmins to deploy files with policies for configuration options, such as making it impossible for users to save passwords or to force sound notifications off, or to set defaults. Also allow changing an option so that Swift disconnects on idle timeout, instead of going away.
author: Kevin Smith <git@kismith.co.uk> 2012-02-17 16:57:01 (GMT)
committer: Kevin Smith <git@kismith.co.uk> 2012-02-21 14:34:55 (GMT)
commit: 3605b6622bc8b4abb810fac6b53f7f71be0fa7de (patch)
tree: 638a8fd6449dd235931fe307e50119adf9c9fe22 /Swift/QtUI
parent: b05f8fcb285d2d13d2be50a3eb1062048fbe30f5 (diff)
download: swift-contrib-3605b6622bc8b4abb810fac6b53f7f71be0fa7de.zip
swift-contrib-3605b6622bc8b4abb810fac6b53f7f71be0fa7de.tar.bz2
31 files changed, 314 insertions, 282 deletions
diff --git a/Swift/QtUI/ChatList/QtChatListWindow.cpp b/Swift/QtUI/ChatList/QtChatListWindow.cpp
index 8de5720..5181040 100644
--- a/Swift/QtUI/ChatList/QtChatListWindow.cpp
+++ b/Swift/QtUI/ChatList/QtChatListWindow.cpp
@@ -1,91 +1,99 @@
 /*
  * Copyright (c) 2010-2011 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "Swift/QtUI/ChatList/QtChatListWindow.h"
 
+#include <Boost/bind.hpp>
+
 #include <QMenu>
 #include <QContextMenuEvent>
 
 #include <Swift/QtUI/ChatList/ChatListMUCItem.h>
 #include <Swift/QtUI/ChatList/ChatListRecentItem.h>
 #include <Swift/QtUI/QtAddBookmarkWindow.h>
 #include <Swift/QtUI/QtEditBookmarkWindow.h>
+#include <Swift/QtUI/QtUISettingConstants.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/AddMUCBookmarkUIEvent.h>
 #include <Swift/Controllers/UIEvents/RemoveMUCBookmarkUIEvent.h>
 #include <Swift/Controllers/UIEvents/EditMUCBookmarkUIEvent.h>
-#include <Swift/QtUI/QtUIPreferences.h>
+#include <Swift/Controllers/Settings/SettingsProvider.h>
+
 
 namespace Swift {
 
-QtChatListWindow::QtChatListWindow(UIEventStream *uiEventStream, QtUIPreferences* uiPreferences, QWidget* parent) : QTreeView(parent) {
+QtChatListWindow::QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent) : QTreeView(parent) {
 	eventStream_ = uiEventStream;
-	uiPreferences_ = uiPreferences;
+	settings_ = settings;;
 	bookmarksEnabled_ = false;
 	model_ = new ChatListModel();
 	setModel(model_);
-	delegate_ = new ChatListDelegate(uiPreferences_->getCompactRosters());
+	delegate_ = new ChatListDelegate(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));
 	setItemDelegate(delegate_);
 	setHeaderHidden(true);
 #ifdef SWIFT_PLATFORM_MACOSX
 	setAlternatingRowColors(true);
 #endif
 	expandAll();
 	setAnimated(true);
 	setIndentation(0);
 	setRootIsDecorated(true);
 	setupContextMenus();
 	connect(this, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));
 	connect(this, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleClicked(const QModelIndex&)));
-	connect(uiPreferences_, SIGNAL(onCompactRostersChanged(bool)), this, SLOT(handleCompactRostersToggled(bool)));
+
+	settings_->onSettingChanged.connect(boost::bind(&QtChatListWindow::handleSettingChanged, this, _1));
 }
 
 QtChatListWindow::~QtChatListWindow() {
+	settings_->onSettingChanged.disconnect(boost::bind(&QtChatListWindow::handleSettingChanged, this, _1));
 	delete model_;
 	delete delegate_;
 	delete mucMenu_;
 	delete emptyMenu_;
 }
 
-void QtChatListWindow::handleCompactRostersToggled(bool compact) {
-	delegate_->setCompact(compact);
-	repaint();
+void QtChatListWindow::handleSettingChanged(const std::string& setting) {
+	if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {
+		delegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));
+		repaint();
+	}
 }
 
 void QtChatListWindow::setBookmarksEnabled(bool enabled) {
 	bookmarksEnabled_ = enabled;
 }
 
 void QtChatListWindow::handleClicked(const QModelIndex& index) {
 	ChatListGroupItem* item = dynamic_cast<ChatListGroupItem*>(static_cast<ChatListItem*>(index.internalPointer()));
 	if (item) {
 		setExpanded(index, !isExpanded(index));
 	}
 }
 
 void QtChatListWindow::setupContextMenus() {
 	mucMenu_ = new QMenu();
 	mucMenu_->addAction(tr("Add New Bookmark"), this, SLOT(handleAddBookmark()));
 	mucMenu_->addAction(tr("Edit Bookmark"), this, SLOT(handleEditBookmark()));
 	mucMenu_->addAction(tr("Remove Bookmark"), this, SLOT(handleRemoveBookmark()));
 	emptyMenu_ = new QMenu();
 	emptyMenu_->addAction(tr("Add New Bookmark"), this, SLOT(handleAddBookmark()));
 	
 }
 
 void QtChatListWindow::handleItemActivated(const QModelIndex& index) {
 	ChatListItem* item = model_->getItemForIndex(index);
 	if (ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(item)) {
 		if (bookmarksEnabled_) {
 			onMUCBookmarkActivated(mucItem->getBookmark());
 		}
 	}
 	else if (ChatListRecentItem* recentItem = dynamic_cast<ChatListRecentItem*>(item)) {
 		if (!recentItem->getChat().isMUC || bookmarksEnabled_) {
 			onRecentActivated(recentItem->getChat());
 		}
 	}
diff --git a/Swift/QtUI/ChatList/QtChatListWindow.h b/Swift/QtUI/ChatList/QtChatListWindow.h
index af37015..33131ce 100644
--- a/Swift/QtUI/ChatList/QtChatListWindow.h
+++ b/Swift/QtUI/ChatList/QtChatListWindow.h
@@ -1,55 +1,55 @@
 /*
  * Copyright (c) 2010-2011 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QTreeView>
 
 #include "Swift/Controllers/UIInterfaces/ChatListWindow.h"
 #include "Swift/Controllers/UIEvents/UIEventStream.h"
 #include "Swift/QtUI/ChatList/ChatListModel.h"
 #include "Swift/QtUI/ChatList/ChatListDelegate.h"
 
 namespace Swift {
-	class QtUIPreferences;
+	class SettingsProvider;
 	class QtChatListWindow : public QTreeView, public ChatListWindow {
 		Q_OBJECT
 		public:
-			QtChatListWindow(UIEventStream *uiEventStream, QtUIPreferences* uiPreferences, QWidget* parent = NULL);
+			QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent = NULL);
 			virtual ~QtChatListWindow();
 			void addMUCBookmark(const MUCBookmark& bookmark);
 			void removeMUCBookmark(const MUCBookmark& bookmark);
 			void setBookmarksEnabled(bool enabled);
 			void setRecents(const std::list<ChatListWindow::Chat>& recents);
 			void setUnreadCount(int unread);
 			void clearBookmarks();
 
 		signals:
 			void onCountUpdated(int count);
 		private slots:
 			void handleItemActivated(const QModelIndex&);
 			void handleAddBookmark();
 			void handleEditBookmark();
 			void handleRemoveBookmark();
 			void handleClicked(const QModelIndex& index);
-			void handleCompactRostersToggled(bool);
+			void handleSettingChanged(const std::string& setting);
 
 		protected:
 			void contextMenuEvent(QContextMenuEvent* event);
 
 		private:
 			void setupContextMenus();
 			bool bookmarksEnabled_;
 			UIEventStream* eventStream_;
 			ChatListModel* model_;
 			ChatListDelegate* delegate_;
 			QMenu* mucMenu_;
 			QMenu* emptyMenu_;
 			ChatListItem* contextMenuItem_;
-			QtUIPreferences* uiPreferences_;
+			SettingsProvider* settings_;
 	};
 
 }
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index 4cf606c..dd33e28 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -1,148 +1,147 @@
 /*
- * Copyright (c) 2010-2011 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtChatWindow.h"
 #include "QtSwiftUtil.h"
 #include "Swift/Controllers/Roster/Roster.h"
 #include "Swift/Controllers/Roster/RosterItem.h"
 #include "Swift/Controllers/Roster/ContactRosterItem.h"
 #include "Roster/QtOccupantListWidget.h"
 #include "SwifTools/Linkify.h"
 #include "QtChatView.h"
 #include "MessageSnippet.h"
 #include "SystemMessageSnippet.h"
 #include "QtTextEdit.h"
 #include "QtSettingsProvider.h"
 #include "QtScaledAvatarCache.h"
 
 #include "SwifTools/TabComplete.h"
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include "QtFileTransferJSBridge.h"
 
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <QLabel>
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QApplication>
 #include <QBoxLayout>
 #include <QCloseEvent>
 #include <QComboBox>
 #include <QFileInfo>
 #include <QLineEdit>
 #include <QSplitter>
 #include <QString>
 #include <QTextEdit>
 #include <QTime>
 #include <QUrl>
 #include <QPushButton>
 #include <QFileDialog>
 #include <QMenu>
-#include <Swift/QtUI/QtUIPreferences.h>
+#include <Swift/Controllers/Settings/SettingsProvider.h>
 
 #include <QDebug>
 
 namespace Swift {
-QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, QtUIPreferences* uiPreferences) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageWasSystem_(false), previousMessageWasPresence_(false), previousMessageWasFileTransfer_(false), eventStream_(eventStream) {
-	uiPreferences_ = uiPreferences;
+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageWasSystem_(false), previousMessageWasPresence_(false), previousMessageWasFileTransfer_(false), eventStream_(eventStream) {
+	settings_ = settings;
 	unreadCount_ = 0;
 	idCounter_ = 0;
 	inputEnabled_ = true;
 	completer_ = NULL;
 	affiliationEditor_ = NULL;
 	theme_ = theme;
 	isCorrection_ = false;
 	correctionEnabled_ = Maybe;
 	updateTitleWithUnreadCount();
-	QtSettingsProvider settings;
 
 #ifdef SWIFT_EXPERIMENTAL_FT
 	setAcceptDrops(true);
 #endif
 
 	alertStyleSheet_ = "background: rgb(255, 255, 153); color: black";
 
 	QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);
 	layout->setContentsMargins(0,0,0,0);
 	layout->setSpacing(2);
 
 	alertWidget_ = new QWidget(this);
 	QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget_);
 	layout->addWidget(alertWidget_);
 	alertLabel_ = new QLabel(this);
 	alertLayout->addWidget(alertLabel_);
 	alertButton_ = new QPushButton(this);
 	connect (alertButton_, SIGNAL(clicked()), this, SLOT(handleAlertButtonClicked()));
 	alertLayout->addWidget(alertButton_);
 	QPalette palette = alertWidget_->palette();
 	palette.setColor(QPalette::Window, QColor(Qt::yellow));
 	palette.setColor(QPalette::WindowText, QColor(Qt::black));
 	alertWidget_->setStyleSheet(alertStyleSheet_);
 	alertLabel_->setStyleSheet(alertStyleSheet_);
 	alertWidget_->hide();
 
 	QBoxLayout* subjectLayout = new QBoxLayout(QBoxLayout::LeftToRight);
 	subject_ = new QLineEdit(this);
 	subjectLayout->addWidget(subject_);
 	setSubject("");
 	subject_->setReadOnly(true);
 
 	actionButton_ = new QPushButton(this);
 	actionButton_->setIcon(QIcon(":/icons/actions.png"));
 	connect(actionButton_, SIGNAL(clicked()), this, SLOT(handleActionButtonClicked()));
 	subjectLayout->addWidget(actionButton_);
 
 	subject_->hide();
 	actionButton_->hide();
 
 	layout->addLayout(subjectLayout);
 
 	logRosterSplitter_ = new QSplitter(this);
 	logRosterSplitter_->setAutoFillBackground(true);
 	layout->addWidget(logRosterSplitter_);
 	messageLog_ = new QtChatView(theme, this);
 	logRosterSplitter_->addWidget(messageLog_);
 
-	treeWidget_ = new QtOccupantListWidget(eventStream_, uiPreferences_, this);
+	treeWidget_ = new QtOccupantListWidget(eventStream_, settings_, this);
 	treeWidget_->hide();
 	logRosterSplitter_->addWidget(treeWidget_);
 	logRosterSplitter_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 	connect(logRosterSplitter_, SIGNAL(splitterMoved(int, int)), this, SLOT(handleSplitterMoved(int, int)));
 
 	QWidget* midBar = new QWidget(this);
 	layout->addWidget(midBar);
 	midBar->setAutoFillBackground(true);
 	QHBoxLayout *midBarLayout = new QHBoxLayout(midBar);
 	midBarLayout->setContentsMargins(0,0,0,0);
 	midBarLayout->setSpacing(2);
 	midBarLayout->addStretch();
 
 	labelsWidget_ = new QComboBox(this);
 	labelsWidget_->setFocusPolicy(Qt::NoFocus);
 	labelsWidget_->hide();
 	labelsWidget_->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 	midBarLayout->addWidget(labelsWidget_,0);
 
 	QHBoxLayout* inputBarLayout = new QHBoxLayout();
 	inputBarLayout->setContentsMargins(0,0,0,0);
 	inputBarLayout->setSpacing(2);
 	input_ = new QtTextEdit(this);
 	input_->setAcceptRichText(false);
 	inputBarLayout->addWidget(input_);
 	correctingLabel_ = new QLabel(tr("Correcting"), this);
 	inputBarLayout->addWidget(correctingLabel_);
 	correctingLabel_->hide();
 	layout->addLayout(inputBarLayout);
 
 	inputClearing_ = false;
 	contactIsTyping_ = false;
 
 	connect(input_, SIGNAL(unhandledKeyPressEvent(QKeyEvent*)), this, SLOT(handleKeyPressEvent(QKeyEvent*)));
 	connect(input_, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
diff --git a/Swift/QtUI/QtChatWindow.h b/Swift/QtUI/QtChatWindow.h
index 4f997c0..9203068 100644
--- a/Swift/QtUI/QtChatWindow.h
+++ b/Swift/QtUI/QtChatWindow.h
@@ -1,75 +1,75 @@
 /*
- * Copyright (c) 2010-2011 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/QtUI/QtMUCConfigurationWindow.h>
 #include <Swift/QtUI/QtAffiliationEditor.h>
 
 #include <QtTabbable.h>
 
 #include <SwifTools/LastLineTracker.h>
 
 #include <map>
 #include <QPointer>
 
 class QTextEdit;
 class QLineEdit;
 class QComboBox;
 class QLabel;
 class QSplitter;
 class QPushButton;
 
 namespace Swift {
 	class QtChatView;
 	class QtOccupantListWidget;
 	class QtChatTheme;
 	class TreeWidget;
 	class QtTextEdit;
 	class UIEventStream;
 	class QtFileTransferJSBridge;
-	class QtUIPreferences;
+	class SettingsProvider;
 
 	class QtChatWindow : public QtTabbable, public ChatWindow {
 		Q_OBJECT
 		public:
-			QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, QtUIPreferences* uiPreferences);
+			QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings);
 			~QtChatWindow();
 			std::string addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time);
 			std::string addAction(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time);
 			void addSystemMessage(const std::string& message);
 			void addPresenceMessage(const std::string& message);
 			void addErrorMessage(const std::string& errorMessage);
 			void replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time);
 			// File transfer related stuff
 			std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes);
 			void setFileTransferProgress(std::string id, const int percentageDone);
 			void setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg);
 			
 			void show();
 			void activate();
 			void setUnreadMessageCount(int count);
 			void convertToMUC();
 //			TreeWidget *getTreeWidget();
 			void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels);
 			void setSecurityLabelsEnabled(bool enabled);
 			void setSecurityLabelsError();
 			SecurityLabelsCatalog::Item getSelectedSecurityLabel();
 			void setName(const std::string& name);
 			void setInputEnabled(bool enabled);
 			QtTabbable::AlertType getWidgetAlertState();
 			void setContactChatState(ChatState::ChatStateType state);
 			void setRosterModel(Roster* roster);
 			void setTabComplete(TabComplete* completer);
 			int getCount();
 			void replaceLastMessage(const std::string& message);
 			void setAckState(const std::string& id, AckState state);
 
 			// message receipts
 			void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state);
 
 			void flash();
@@ -130,38 +130,38 @@ namespace Swift {
 			int unreadCount_;
 			bool contactIsTyping_;
 			LastLineTracker lastLineTracker_;
 			QString contact_;
 			QString lastSentMessage_;
 			QtChatView* messageLog_;
 			QtChatTheme* theme_;
 			QtTextEdit* input_;
 			QComboBox* labelsWidget_;
 			QtOccupantListWidget* treeWidget_;
 			QLabel* correctingLabel_;
 			QLabel* alertLabel_;
 			QWidget* alertWidget_;
 			QPushButton* alertButton_;
 			TabComplete* completer_;
 			QLineEdit* subject_;
 			QPushButton* actionButton_;
 			std::vector<SecurityLabelsCatalog::Item> availableLabels_;
 			bool isCorrection_;
 			bool previousMessageWasSelf_;
 			bool previousMessageWasSystem_;
 			bool previousMessageWasPresence_;
 			bool previousMessageWasFileTransfer_;
 			QString previousSenderName_;
 			bool inputClearing_;
 			UIEventStream* eventStream_;
 			bool inputEnabled_;
 			QSplitter *logRosterSplitter_;
 			Tristate correctionEnabled_;
 			QString alertStyleSheet_;
 			std::map<QString, QString> descriptions;
 			QtFileTransferJSBridge* fileTransferJS;
 			QPointer<QtMUCConfigurationWindow> mucConfigurationWindow_;
 			QPointer<QtAffiliationEditor> affiliationEditor_;
 			int idCounter_;
-			QtUIPreferences* uiPreferences_;
+			SettingsProvider* settings_;
 	};
 }
diff --git a/Swift/QtUI/QtChatWindowFactory.cpp b/Swift/QtUI/QtChatWindowFactory.cpp
index b860dae..7610082 100644
--- a/Swift/QtUI/QtChatWindowFactory.cpp
+++ b/Swift/QtUI/QtChatWindowFactory.cpp
@@ -1,83 +1,83 @@
 /*
  * Copyright (c) 2010 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtChatWindowFactory.h"
 
 #include <QDesktopWidget>
 
 #include "QtChatTabs.h"
 #include "QtChatWindow.h"
 #include "QtSwiftUtil.h"
 #include "QtChatTheme.h"
 #include <qdebug.h>
 
 
 namespace Swift {
 
 static const QString SPLITTER_STATE = "mucSplitterState";
 static const QString CHAT_TABS_GEOMETRY = "chatTabsGeometry";
 
-QtChatWindowFactory::QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs, const QString& themePath, QtUIPreferences* uiPreferences) : themePath_(themePath) {
+QtChatWindowFactory::QtChatWindowFactory(QSplitter* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath) : themePath_(themePath) {
+	qtOnlySettings_ = qtSettings;
 	settings_ = settings;
 	tabs_ = tabs;
-	uiPreferences_ = uiPreferences;
 	theme_ = NULL;
 	if (splitter) {
 		splitter->addWidget(tabs_);
 	} else if (tabs_) {
-		QVariant chatTabsGeometryVariant = settings_->getQSettings()->value(CHAT_TABS_GEOMETRY);
+		QVariant chatTabsGeometryVariant = qtOnlySettings_->getQSettings()->value(CHAT_TABS_GEOMETRY);
 		if (chatTabsGeometryVariant.isValid()) {
 			tabs_->restoreGeometry(chatTabsGeometryVariant.toByteArray());
 		}
 		connect(tabs_, SIGNAL(geometryChanged()), this, SLOT(handleWindowGeometryChanged()));
 	}
 }
 
 QtChatWindowFactory::~QtChatWindowFactory() {
 	delete theme_;
 }
 
 ChatWindow* QtChatWindowFactory::createChatWindow(const JID &contact,UIEventStream* eventStream) {
 	if (!theme_) {
 		theme_ = new QtChatTheme(themePath_);
 		if (theme_->getIncomingContent().isEmpty()) {
 			delete theme_;
 			theme_ = new QtChatTheme(""); /* Use the inbuilt theme */
 		}
 	}
 
-	QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), theme_, eventStream, uiPreferences_);
+	QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), theme_, eventStream, settings_);
 	connect(chatWindow, SIGNAL(splitterMoved()), this, SLOT(handleSplitterMoved()));
 	connect(this, SIGNAL(changeSplitterState(QByteArray)), chatWindow, SLOT(handleChangeSplitterState(QByteArray)));
 
-	QVariant splitterState = settings_->getQSettings()->value(SPLITTER_STATE);
+	QVariant splitterState = qtOnlySettings_->getQSettings()->value(SPLITTER_STATE);
 	if(splitterState.isValid()) {
 		chatWindow->handleChangeSplitterState(splitterState.toByteArray());
 	}
 
 	if (tabs_) {
 		tabs_->addTab(chatWindow);
 	} else {
-		QVariant chatGeometryVariant = settings_->getQSettings()->value(CHAT_TABS_GEOMETRY);
+		QVariant chatGeometryVariant = qtOnlySettings_->getQSettings()->value(CHAT_TABS_GEOMETRY);
 		if (chatGeometryVariant.isValid()) {
 			chatWindow->restoreGeometry(chatGeometryVariant.toByteArray());
 		}
 		connect(chatWindow, SIGNAL(geometryChanged()), this, SLOT(handleWindowGeometryChanged()));
 	}
 	return chatWindow;
 }
 
 void QtChatWindowFactory::handleWindowGeometryChanged() {
-	settings_->getQSettings()->setValue(CHAT_TABS_GEOMETRY, qobject_cast<QWidget*>(sender())->saveGeometry());
+	qtOnlySettings_->getQSettings()->setValue(CHAT_TABS_GEOMETRY, qobject_cast<QWidget*>(sender())->saveGeometry());
 }
 
 void QtChatWindowFactory::handleSplitterMoved() {
 	QByteArray splitterState = qobject_cast<QtChatWindow*>(sender())->getSplitterState();
-	settings_->getQSettings()->setValue(SPLITTER_STATE, QVariant(splitterState));
+	qtOnlySettings_->getQSettings()->setValue(SPLITTER_STATE, QVariant(splitterState));
 	emit changeSplitterState(splitterState);
 }
 
 }
diff --git a/Swift/QtUI/QtChatWindowFactory.h b/Swift/QtUI/QtChatWindowFactory.h
index f664c43..2a16c3b 100644
--- a/Swift/QtUI/QtChatWindowFactory.h
+++ b/Swift/QtUI/QtChatWindowFactory.h
@@ -1,39 +1,39 @@
 /*
  * Copyright (c) 2010 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include "Swift/Controllers/UIInterfaces/ChatWindowFactory.h"
 #include "Swiften/JID/JID.h"
 #include "QtSettingsProvider.h"
 
 #include <QObject>
 #include <QSplitter>
 namespace Swift {
 	class QtChatTabs;
 	class QtChatTheme;
 	class UIEventStream;
 	class QtUIPreferences;
 	class QtChatWindowFactory : public QObject, public ChatWindowFactory {
 		Q_OBJECT
 		public:
-			QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs, const QString& themePath, QtUIPreferences* uiPreferences);
+			QtChatWindowFactory(QSplitter* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath);
 			~QtChatWindowFactory();
 			ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);
 		signals:
 			void changeSplitterState(QByteArray);
 		private slots:
 			void handleWindowGeometryChanged();
 			void handleSplitterMoved();
 		private:
 			QString themePath_;
-			QtSettingsProvider* settings_;
+			SettingsProvider* settings_;
+			QtSettingsProvider* qtOnlySettings_;
 			QtChatTabs* tabs_;
 			QtChatTheme* theme_;
-			QtUIPreferences* uiPreferences_;
 	};
 }
 
diff --git a/Swift/QtUI/QtLoginWindow.cpp b/Swift/QtUI/QtLoginWindow.cpp
index fc99633..aafdef8 100644
--- a/Swift/QtUI/QtLoginWindow.cpp
+++ b/Swift/QtUI/QtLoginWindow.cpp
@@ -1,80 +1,81 @@
 /*
- * Copyright (c) 2010-2011 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtLoginWindow.h"
 
 #include <boost/bind.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <algorithm>
 #include <cassert>
 
 #include <QApplication>
 #include <QBoxLayout>
 #include <QComboBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QStatusBar>
 #include <QToolButton>
 #include <QLabel>
 #include <QMenuBar>
 #include <QHBoxLayout>
 #include <qdebug.h>
 #include <QCloseEvent>
 #include <QCursor>
 #include <QMessageBox>
 #include <QKeyEvent>
  
-#include "Swift/Controllers/UIEvents/UIEventStream.h"
-#include "Swift/Controllers/UIEvents/RequestXMLConsoleUIEvent.h"
-#include "Swift/Controllers/UIEvents/RequestFileTransferListUIEvent.h"
-#include "Swift/Controllers/UIEvents/ToggleSoundsUIEvent.h"
-#include "Swift/Controllers/UIEvents/ToggleNotificationsUIEvent.h"
-#include "Swiften/Base/Platform.h"
-#include "Swiften/Base/Paths.h"
-
-#include "QtAboutWidget.h"
-#include "QtSwiftUtil.h"
-#include "QtMainWindow.h"
-#include "QtUtilities.h"
+#include <Swift/Controllers/UIEvents/UIEventStream.h>
+#include <Swift/Controllers/UIEvents/RequestXMLConsoleUIEvent.h>
+#include <Swift/Controllers/UIEvents/RequestFileTransferListUIEvent.h>
+#include <Swift/Controllers/Settings/SettingsProvider.h>
+#include <Swift/Controllers/SettingConstants.h>
+#include <Swift/QtUI/QtUISettingConstants.h>
+#include <Swiften/Base/Platform.h>
+#include <Swiften/Base/Paths.h>
+
+#include <QtAboutWidget.h>
+#include <QtSwiftUtil.h>
+#include <QtMainWindow.h>
+#include <QtUtilities.h>
 
 namespace Swift{
 
-QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, bool eagleMode) : QMainWindow(), eagleMode_(eagleMode) {
+QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings) : QMainWindow(), settings_(settings) {
 	uiEventStream_ = uiEventStream;
 
 	setWindowTitle("Swift");
 #ifndef Q_WS_MAC
 	setWindowIcon(QIcon(":/logo-icon-16.png"));
 #endif
 	QtUtilities::setX11Resource(this, "Main");
 
 	resize(200, 500);
 	setContentsMargins(0,0,0,0);
 	QWidget *centralWidget = new QWidget(this);
 	setCentralWidget(centralWidget);
 	QBoxLayout *topLayout = new QBoxLayout(QBoxLayout::TopToBottom, centralWidget);
 	stack_ = new QStackedWidget(centralWidget);
 	topLayout->addWidget(stack_);
 	topLayout->setMargin(0);
 	loginWidgetWrapper_ = new QWidget(this);
 	loginWidgetWrapper_->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
 	QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, loginWidgetWrapper_);
 	layout->addStretch(2);
 
 	QLabel* logo = new QLabel(this);
 	logo->setPixmap(QPixmap(":/logo-shaded-text.256.png"));
 	logo->setScaledContents(true);
 	logo->setFixedSize(192,192);
 
 	QWidget *logoWidget = new QWidget(this);
 	QHBoxLayout *logoLayout = new QHBoxLayout();
 	logoLayout->setMargin(0);
 	logoLayout->addStretch(0);
 	logoLayout->addWidget(logo);
 	logoLayout->addStretch(0);
 	logoWidget->setLayout(logoLayout);
 	layout->addWidget(logoWidget);
 
@@ -167,116 +168,114 @@ QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, bool eagleMode) : QMa
 
 	xmlConsoleAction_ = new QAction(tr("&Show Debug Console"), this);
 	connect(xmlConsoleAction_, SIGNAL(triggered()), SLOT(handleShowXMLConsole()));
 	generalMenu_->addAction(xmlConsoleAction_);
 
 #ifdef SWIFT_EXPERIMENTAL_FT
 	fileTransferOverviewAction_ = new QAction(tr("Show &File Transfer Overview"), this);
 	connect(fileTransferOverviewAction_, SIGNAL(triggered()), SLOT(handleShowFileTransferOverview()));
 	generalMenu_->addAction(fileTransferOverviewAction_);
 #endif
 
 	toggleSoundsAction_ = new QAction(tr("&Play Sounds"), this);
 	toggleSoundsAction_->setCheckable(true);
 	toggleSoundsAction_->setChecked(true);
 	connect(toggleSoundsAction_, SIGNAL(toggled(bool)), SLOT(handleToggleSounds(bool)));
 	generalMenu_->addAction(toggleSoundsAction_);
 
 	toggleNotificationsAction_ = new QAction(tr("Display Pop-up &Notifications"), this);
 	toggleNotificationsAction_->setCheckable(true);
 	toggleNotificationsAction_->setChecked(true);
 	connect(toggleNotificationsAction_, SIGNAL(toggled(bool)), SLOT(handleToggleNotifications(bool)));
 
 #ifndef SWIFTEN_PLATFORM_MACOSX
 	swiftMenu_->addSeparator();
 #endif
 
 #ifdef SWIFTEN_PLATFORM_MACOSX
 	QAction* quitAction = new QAction("&Quit", this);
 #else
 	QAction* quitAction = new QAction(tr("&Quit"), this);
 #endif
 	connect(quitAction, SIGNAL(triggered()), SLOT(handleQuit()));
 	swiftMenu_->addAction(quitAction);
 
 	setInitialMenus();
-	uiEventStream_->onUIEvent.connect(boost::bind(&QtLoginWindow::handleUIEvent, this, _1));
+	settings_->onSettingChanged.connect(boost::bind(&QtLoginWindow::handleSettingChanged, this, _1));
 
-
-	remember_->setEnabled(!eagleMode_);
-	loginAutomatically_->setEnabled(!eagleMode_);
-	xmlConsoleAction_->setEnabled(!eagleMode_);
-	if (eagleMode_) {
+	bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);
+	remember_->setEnabled(!eagle);
+	loginAutomatically_->setEnabled(!eagle);
+	xmlConsoleAction_->setEnabled(!eagle);
+	if (eagle) {
 		remember_->setChecked(false);
 		loginAutomatically_->setChecked(false);
 	}
 
 	this->show();
 }
 
 void QtLoginWindow::setShowNotificationToggle(bool toggle) {
 	if (toggle) {
 		generalMenu_->addAction(toggleNotificationsAction_);
 	}
 	else {
 		generalMenu_->removeAction(toggleNotificationsAction_);
 	}
 }
 
 bool QtLoginWindow::eventFilter(QObject *obj, QEvent *event) {
 	if (obj == username_->view() && event->type() == QEvent::KeyPress) {
 		QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 		if (keyEvent->key() == Qt::Key_Delete || keyEvent->key() == Qt::Key_Backspace) {
 			QString jid(username_->view()->currentIndex().data().toString());
 			int result = QMessageBox::question(this, tr("Remove profile"), tr("Remove the profile '%1'?").arg(jid), QMessageBox::Yes | QMessageBox::No);
 			if (result == QMessageBox::Yes) {
 				onPurgeSavedLoginRequest(Q2PSTRING(jid));
 			}
 			return true;
 		}
 	}
 	return QObject::eventFilter(obj, event);
 }
 
-void QtLoginWindow::handleUIEvent(boost::shared_ptr<UIEvent> event) {
-	boost::shared_ptr<ToggleSoundsUIEvent> soundEvent = boost::dynamic_pointer_cast<ToggleSoundsUIEvent>(event);
-	if (soundEvent) {
-		toggleSoundsAction_->setChecked(soundEvent->getEnabled());
+void QtLoginWindow::handleSettingChanged(const std::string& settingPath) {
+	if (settingPath == SettingConstants::PLAY_SOUNDS.getKey()) {
+		toggleSoundsAction_->setChecked(settings_->getSetting(SettingConstants::PLAY_SOUNDS));
 	}
-	boost::shared_ptr<ToggleNotificationsUIEvent> notificationsEvent = boost::dynamic_pointer_cast<ToggleNotificationsUIEvent>(event);
-	if (notificationsEvent) {
-		toggleNotificationsAction_->setChecked(notificationsEvent->getEnabled());
+	if (settingPath == SettingConstants::SHOW_NOTIFICATIONS.getKey()) {
+		toggleNotificationsAction_->setChecked(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));
 	}
 }
 
 void QtLoginWindow::selectUser(const std::string& username) {
 	for (int i = 0; i < usernames_.count(); i++) {
 		if (P2QSTRING(username) == usernames_[i]) {
 			username_->setCurrentIndex(i);
 			password_->setFocus();
 			break;
 		}
 	}
 }
 
 void QtLoginWindow::removeAvailableAccount(const std::string& jid) {
 	QString username = P2QSTRING(jid);
 	int index = -1;
 	for (int i = 0; i < usernames_.count(); i++) {
 		if (username == usernames_[i]) {
 			index = i;
 		}
 	}
 	if (index >= 0) {
 		usernames_.removeAt(index);
 		passwords_.removeAt(index);
 		certificateFiles_.removeAt(index);
 		username_->removeItem(index);
 	}
 }
 
 void QtLoginWindow::addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) {
 	QString username = P2QSTRING(defaultJID);
 	int index = -1;
 	for (int i = 0; i < usernames_.count(); i++) {
 		if (username == usernames_[i]) {
 			index = i;
@@ -291,150 +290,141 @@ void QtLoginWindow::addAvailableAccount(const std::string& defaultJID, const std
 		usernames_[index] = username;
 		passwords_[index] = P2QSTRING(defaultPassword);
 		certificateFiles_[index] = P2QSTRING(defaultCertificate);
 	}
 }
 
 void QtLoginWindow::handleUsernameTextChanged() {
 	QString username = username_->currentText();
 	for (int i = 0; i < usernames_.count(); i++) {
 		if (username_->currentText() == usernames_[i]) {
 			certificateFile_ = certificateFiles_[i];
 			password_->setText(passwords_[i]);
 			remember_->setChecked(password_->text() != "");
 		}
 	}
 	if (!certificateFile_.isEmpty()) {
 		certificateButton_->setChecked(true);
 	}
 }
 
 void QtLoginWindow::loggedOut() {
 	stack_->removeWidget(stack_->currentWidget());
 	stack_->addWidget(loginWidgetWrapper_);
 	stack_->setCurrentWidget(loginWidgetWrapper_);
 	setInitialMenus();
 	setIsLoggingIn(false);
 }
 
 void QtLoginWindow::setIsLoggingIn(bool loggingIn) {
 	/* Change the for loop as well if you add to this.*/
 	QWidget* widgets[5] = {username_, password_, remember_, loginAutomatically_, certificateButton_};
 	loginButton_->setText(loggingIn ? tr("Cancel") : tr("Connect"));
 	for (int i = 0; i < 5; i++) {
 		widgets[i]->setEnabled(!loggingIn);
 	}
-	remember_->setEnabled(!eagleMode_);
-	loginAutomatically_->setEnabled(!eagleMode_);
+	bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);
+	remember_->setEnabled(!eagle);
+	loginAutomatically_->setEnabled(!eagle);
 }
 
 void QtLoginWindow::loginClicked() {
 	if (username_->isEnabled()) {
-		if (eagleMode_) {
-			QString clickThroughPath(P2QSTRING((Paths::getExecutablePath() / "eagle-banner.txt").string()));
-			QFile clickThroughFile(clickThroughPath);
-			if (clickThroughFile.exists() && clickThroughFile.open(QIODevice::ReadOnly)) {
-				QString banner;
-				while (!clickThroughFile.atEnd()) {
-					QByteArray line = clickThroughFile.readLine();
-					banner += line + "\n";
-				}
-				if (!banner.isEmpty()) {
-					QMessageBox msgBox;
-					msgBox.setWindowTitle(tr("Confirm terms of use"));
-					msgBox.setText("");
-					msgBox.setInformativeText(banner);
-					msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
-					msgBox.setDefaultButton(QMessageBox::No);
-					if (msgBox.exec() != QMessageBox::Yes) {
-						return;
-					}
-				}
+		std::string banner = settings_->getSetting(QtUISettingConstants::CLICKTHROUGH_BANNER);
+		if (!banner.empty()) {
+			QMessageBox msgBox;
+			msgBox.setWindowTitle(tr("Confirm terms of use"));
+			msgBox.setText("");
+			msgBox.setInformativeText(P2QSTRING(banner));
+			msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+			msgBox.setDefaultButton(QMessageBox::No);
+			if (msgBox.exec() != QMessageBox::Yes) {
+				return;
 			}
 		}
 		onLoginRequest(Q2PSTRING(username_->currentText()), Q2PSTRING(password_->text()), Q2PSTRING(certificateFile_), remember_->isChecked(), loginAutomatically_->isChecked());
-		if (eagleMode_) { /* Mustn't remember logins */
+		if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) { /* Mustn't remember logins */
 			username_->clearEditText();
 			password_->setText("");
 		}
 	} else {
 		onCancelLoginRequest();
 	}
 }
 
 void QtLoginWindow::setLoginAutomatically(bool loginAutomatically) {
 	loginAutomatically_->setChecked(loginAutomatically);
 }
 
 void QtLoginWindow::handleCertficateChecked(bool checked) {
 	if (checked) {
 		 certificateFile_ = QFileDialog::getOpenFileName(this, tr("Select an authentication certificate"), QString(), QString("*.cert;*.p12;*.pfx"));
 		 if (certificateFile_.isEmpty()) {
 			 certificateButton_->setChecked(false);
 		 }
 	}
 	else {
 		certificateFile_ = "";
 	}
 }
 
 void QtLoginWindow::handleAbout() {
 	if (!aboutDialog_) {
 		aboutDialog_ = new QtAboutWidget();
 		aboutDialog_->show();
 	}
 	else {
 		aboutDialog_->show();
 		aboutDialog_->raise();
 		aboutDialog_->activateWindow();
 	}
 }
 
 void QtLoginWindow::handleShowXMLConsole() {
 	uiEventStream_->send(boost::shared_ptr<RequestXMLConsoleUIEvent>(new RequestXMLConsoleUIEvent()));
 }
 
 void QtLoginWindow::handleShowFileTransferOverview() {
 	uiEventStream_->send(boost::make_shared<RequestFileTransferListUIEvent>());
 }
 
 void QtLoginWindow::handleToggleSounds(bool enabled) {
-	uiEventStream_->send(boost::shared_ptr<ToggleSoundsUIEvent>(new ToggleSoundsUIEvent(enabled)));
+	settings_->storeSetting(SettingConstants::PLAY_SOUNDS, enabled);
 }
 
 void QtLoginWindow::handleToggleNotifications(bool enabled) {
-	uiEventStream_->send(boost::shared_ptr<ToggleNotificationsUIEvent>(new ToggleNotificationsUIEvent(enabled)));
+	settings_->storeSetting(SettingConstants::SHOW_NOTIFICATIONS, enabled);
 }
 
 void QtLoginWindow::handleQuit() {
 	onQuitRequest();
 }
 
 void QtLoginWindow::quit() {
 	QApplication::quit();
 }
 
 void QtLoginWindow::setInitialMenus() {
 	menuBar_->clear();
 	menuBar_->addMenu(swiftMenu_);
 #ifdef SWIFTEN_PLATFORM_MACOSX
 	menuBar_->addMenu(generalMenu_);
 #endif
 }
 
 void QtLoginWindow::morphInto(MainWindow *mainWindow) {
 	QtMainWindow *qtMainWindow = dynamic_cast<QtMainWindow*>(mainWindow);
 	assert(qtMainWindow);
 	stack_->removeWidget(loginWidgetWrapper_);
 	stack_->addWidget(qtMainWindow);
 	stack_->setCurrentWidget(qtMainWindow);
 	setEnabled(true);
 	setInitialMenus();
 	foreach (QMenu* menu, qtMainWindow->getMenus()) {
 		menuBar_->addMenu(menu);
 	}
 }
 
 void QtLoginWindow::setMessage(const std::string& message) {
 	if (!message.empty()) {
 		message_->setText("<center><font color=\"red\">" + P2QSTRING(message) + "</font></center>");
 	}
diff --git a/Swift/QtUI/QtLoginWindow.h b/Swift/QtUI/QtLoginWindow.h
index df133b1..dcd7c18 100644
--- a/Swift/QtUI/QtLoginWindow.h
+++ b/Swift/QtUI/QtLoginWindow.h
@@ -1,101 +1,102 @@
 /*
- * Copyright (c) 2010-2011 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QMainWindow>
 #include <QPointer>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QCheckBox>
 #include <QStackedWidget>
 #include <QMenuBar>
 
-#include "Swift/Controllers/UIInterfaces/LoginWindow.h"
-#include "Swift/Controllers/UIEvents/UIEventStream.h"
-#include "Swift/Controllers/UIInterfaces/MainWindow.h"
-#include "QtAboutWidget.h"
+#include <Swift/Controllers/UIInterfaces/LoginWindow.h>
+#include <Swift/Controllers/UIEvents/UIEventStream.h>
+#include <Swift/Controllers/UIInterfaces/MainWindow.h>
+#include <QtAboutWidget.h>
 
 class QLabel;
 class QToolButton;
 class QComboBox;
 
 namespace Swift {
+	class SettingsProvider;
 	class QtLoginWindow : public QMainWindow, public LoginWindow {
 		Q_OBJECT
 		public:
 			struct QtMenus {
 				QtMenus(QMenu* swiftMenu, QMenu* generalMenu) : swiftMenu(swiftMenu), generalMenu(generalMenu) {}
 				QMenu* swiftMenu;
 				QMenu* generalMenu;
 			};
 
 		public:
-			QtLoginWindow(UIEventStream* uiEventStream, bool eagleMode);
+			QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings);
 
 			void morphInto(MainWindow *mainWindow);
 			virtual void loggedOut();
 			virtual void setShowNotificationToggle(bool);
 			virtual void setMessage(const std::string& message);
 			virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate);
 			virtual void removeAvailableAccount(const std::string& jid);
 			virtual void setLoginAutomatically(bool loginAutomatically);
 			virtual void setIsLoggingIn(bool loggingIn);
 			void selectUser(const std::string& user);
 			bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref certificate);
 			void hide();
 			QtMenus getMenus() const;
 			virtual void quit();
 
 		signals:
 			void geometryChanged();
 
 		private slots:
 			void loginClicked();
 			void handleCertficateChecked(bool);
 			void handleQuit();
 			void handleShowXMLConsole();
 			void handleShowFileTransferOverview();
 			void handleToggleSounds(bool enabled);
 			void handleToggleNotifications(bool enabled);
 			void handleAbout();
 			void bringToFront();
 			void handleUsernameTextChanged();
 			void resizeEvent(QResizeEvent* event);
 			void moveEvent(QMoveEvent* event);
-			void handleUIEvent(boost::shared_ptr<UIEvent> event);
+			void handleSettingChanged(const std::string& settingPath);
 
 		protected:
 			bool eventFilter(QObject *obj, QEvent *event);
 
 		private:
 			void setInitialMenus();
 			QWidget* loginWidgetWrapper_;
 			QStringList usernames_;
 			QStringList passwords_;
 			QStringList certificateFiles_;
 			QComboBox* username_;
 			QLineEdit* password_;
 			QPushButton* loginButton_;
 			/* If you add a widget here, change setLoggingIn as well.*/
 			QCheckBox* remember_;
 			QCheckBox* loginAutomatically_;
 			QStackedWidget* stack_;
 			QLabel* message_;
 			QString certificateFile_;
 			QToolButton* certificateButton_;
 			QMenuBar* menuBar_;
 			QMenu* swiftMenu_;
 			QMenu* generalMenu_;
 			QAction* toggleSoundsAction_;
 			QAction* toggleNotificationsAction_;
 			UIEventStream* uiEventStream_;
 			QPointer<QtAboutWidget> aboutDialog_;
-			bool eagleMode_;
+			SettingsProvider* settings_;
 			QAction* xmlConsoleAction_;
 			QAction* fileTransferOverviewAction_;
 	};
 }
diff --git a/Swift/QtUI/QtMainWindow.cpp b/Swift/QtUI/QtMainWindow.cpp
index 199e388..9f66b31 100644
--- a/Swift/QtUI/QtMainWindow.cpp
+++ b/Swift/QtUI/QtMainWindow.cpp
@@ -1,273 +1,268 @@
 /*
  * Copyright (c) 2010-2011 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtMainWindow.h"
 
 #include <boost/optional.hpp>
 #include <boost/bind.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
 #include <QBoxLayout>
 #include <QComboBox>
 #include <QLineEdit>
 #include <QListWidget>
 #include <QListWidgetItem>
 #include <QPushButton>
 #include <QMenuBar>
 #include <QToolBar>
 #include <QAction>
 #include <QTabWidget>
 
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtTabWidget.h>
 #include <Swift/QtUI/QtSettingsProvider.h>
-#include <Swift/QtUI/QtUIPreferences.h>
 #include <Swift/QtUI/QtLoginWindow.h>
 #include <Roster/QtRosterWidget.h>
 #include <Swift/Controllers/UIEvents/RequestJoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestAddUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatWithUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestProfileEditorUIEvent.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
-#include <Swift/Controllers/UIEvents/ToggleShowOfflineUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestAdHocUIEvent.h>
-#include <Swift/Controllers/UIEvents/ToggleRequestDeliveryReceiptsUIEvent.h>
+#include <Swift/QtUI/QtUISettingConstants.h>
+#include <Swift/Controllers/SettingConstants.h>
 
 namespace Swift {
 
-#define CURRENT_ROSTER_TAB "current_roster_tab"
-
-QtMainWindow::QtMainWindow(QtSettingsProvider* settings, UIEventStream* uiEventStream, QtUIPreferences* uiPreferences, QtLoginWindow::QtMenus loginMenus) : QWidget(), MainWindow(false), loginMenus_(loginMenus) {
+QtMainWindow::QtMainWindow(SettingsProvider* settings, UIEventStream* uiEventStream, QtLoginWindow::QtMenus loginMenus) : QWidget(), MainWindow(false), loginMenus_(loginMenus) {
 	uiEventStream_ = uiEventStream;
-	uiPreferences_ = uiPreferences;
 	settings_ = settings;
 	setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
 	QBoxLayout *mainLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);
 	mainLayout->setContentsMargins(0,0,0,0);
 	mainLayout->setSpacing(0);
 	meView_ = new QtRosterHeader(settings, this);
 	mainLayout->addWidget(meView_);
 	connect(meView_, SIGNAL(onChangeStatusRequest(StatusShow::Type, const QString&)), this, SLOT(handleStatusChanged(StatusShow::Type, const QString&)));
 	connect(meView_, SIGNAL(onEditProfileRequest()), this, SLOT(handleEditProfileRequest()));
 
 	tabs_ = new QtTabWidget(this);
 #if QT_VERSION >= 0x040500
 	tabs_->setDocumentMode(true);
 #endif
 	tabs_->setTabPosition(QTabWidget::South);
 	mainLayout->addWidget(tabs_);
 	contactsTabWidget_ = new QWidget(this);
 	contactsTabWidget_->setContentsMargins(0, 0, 0, 0);
 	QBoxLayout *contactTabLayout = new QBoxLayout(QBoxLayout::TopToBottom, contactsTabWidget_);
 	contactsTabWidget_->setLayout(contactTabLayout);
 	contactTabLayout->setSpacing(0);
 	contactTabLayout->setContentsMargins(0, 0, 0, 0);
 
-	treeWidget_ = new QtRosterWidget(uiEventStream_, uiPreferences_, this);
+	treeWidget_ = new QtRosterWidget(uiEventStream_, settings_, this);
 	contactTabLayout->addWidget(treeWidget_);
 
 	tabs_->addTab(contactsTabWidget_, tr("&Contacts"));
 
 	eventWindow_ = new QtEventWindow(uiEventStream_);
 	connect(eventWindow_, SIGNAL(onNewEventCountUpdated(int)), this, SLOT(handleEventCountUpdated(int)));
 
-	chatListWindow_ = new QtChatListWindow(uiEventStream_, uiPreferences_);
+	chatListWindow_ = new QtChatListWindow(uiEventStream_, settings_);
 	connect(chatListWindow_, SIGNAL(onCountUpdated(int)), this, SLOT(handleChatCountUpdated(int)));
 
 	tabs_->addTab(chatListWindow_, tr("C&hats"));
 	tabs_->addTab(eventWindow_, tr("&Notices"));
 
-	tabs_->setCurrentIndex(settings_->getIntSetting(CURRENT_ROSTER_TAB, 0));
+	tabs_->setCurrentIndex(settings_->getSetting(QtUISettingConstants::CURRENT_ROSTER_TAB));
 
 	connect(tabs_, SIGNAL(currentChanged(int)), this, SLOT(handleTabChanged(int)));
 
 	this->setLayout(mainLayout);
 
 	QMenu* viewMenu = new QMenu(tr("&View"), this);
 	menus_.push_back(viewMenu);
 	showOfflineAction_ = new QAction(tr("&Show offline contacts"), this);
 	showOfflineAction_->setCheckable(true);
 	showOfflineAction_->setChecked(false);
 	connect(showOfflineAction_, SIGNAL(toggled(bool)), SLOT(handleShowOfflineToggled(bool)));
 	viewMenu->addAction(showOfflineAction_);
 
 	//QAction* compactRosterAction_ = new QAction(tr("&Compact Roster"), this);
 	//compactRosterAction_->setCheckable(true);
 	//compactRosterAction_->setChecked(false);
 	//connect(compactRosterAction_, SIGNAL(toggled(bool)), uiPreferences_, SLOT(setCompactRosters(bool)));
 	//viewMenu->addAction(compactRosterAction_);
 
 	QMenu* actionsMenu = new QMenu(tr("&Actions"), this);
 	menus_.push_back(actionsMenu);
 	QAction* editProfileAction = new QAction(tr("Edit &Profile"), this);
 	connect(editProfileAction, SIGNAL(triggered()), SLOT(handleEditProfileAction()));
 	actionsMenu->addAction(editProfileAction);
 	QAction* joinMUCAction = new QAction(tr("Enter &Room"), this);
 	connect(joinMUCAction, SIGNAL(triggered()), SLOT(handleJoinMUCAction()));
 	actionsMenu->addAction(joinMUCAction);
 	addUserAction_ = new QAction(tr("&Add Contact"), this);
 	connect(addUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleAddUserActionTriggered(bool)));
 	actionsMenu->addAction(addUserAction_);
 	editUserAction_ = new QAction(tr("&Edit Selected Contact"), this);
 	connect(editUserAction_, SIGNAL(triggered(bool)), treeWidget_, SLOT(handleEditUserActionTriggered(bool)));
 	actionsMenu->addAction(editUserAction_);
 	editUserAction_->setEnabled(false);
 	chatUserAction_ = new QAction(tr("Start &Chat"), this);
 	connect(chatUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleChatUserActionTriggered(bool)));
 	actionsMenu->addAction(chatUserAction_);
 	serverAdHocMenu_ = new QMenu(tr("Run Server Command"), this);
 	actionsMenu->addMenu(serverAdHocMenu_);
 	actionsMenu->addSeparator();
 	QAction* signOutAction = new QAction(tr("&Sign Out"), this);
 	connect(signOutAction, SIGNAL(triggered()), SLOT(handleSignOutAction()));
 	actionsMenu->addAction(signOutAction);
 
 	toggleRequestDeliveryReceipts_ = new QAction(tr("&Request Delivery Receipts"), this);
 	toggleRequestDeliveryReceipts_->setCheckable(true);
 	toggleRequestDeliveryReceipts_->setChecked(false);
 	connect(toggleRequestDeliveryReceipts_, SIGNAL(toggled(bool)), SLOT(handleToggleRequestDeliveryReceipts(bool)));
 	loginMenus_.generalMenu->addAction(toggleRequestDeliveryReceipts_);
 
 	treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QAction::setEnabled, editUserAction_, _1));
 
 	setAvailableAdHocCommands(std::vector<DiscoItems::Item>());
 	QAction* adHocAction = new QAction(tr("Collecting commands..."), this);
 	adHocAction->setEnabled(false);
 	serverAdHocMenu_->addAction(adHocAction);
 	serverAdHocCommandActions_.append(adHocAction);
 
 	lastOfflineState_ = false;
-	uiEventStream_->onUIEvent.connect(boost::bind(&QtMainWindow::handleUIEvent, this, _1));
+
+	settings_->onSettingChanged.connect(boost::bind(&QtMainWindow::handleSettingChanged, this, _1));
 }
 
 QtMainWindow::~QtMainWindow() {
-	uiEventStream_->onUIEvent.disconnect(boost::bind(&QtMainWindow::handleUIEvent, this, _1));
+	settings_->onSettingChanged.disconnect(boost::bind(&QtMainWindow::handleSettingChanged, this, _1));
 }
 
 void QtMainWindow::handleTabChanged(int index) {
-	settings_->storeInt(CURRENT_ROSTER_TAB, index);
+	settings_->storeSetting(QtUISettingConstants::CURRENT_ROSTER_TAB, index);
 }
 
 void QtMainWindow::handleToggleRequestDeliveryReceipts(bool enabled) {
-	uiEventStream_->send(boost::make_shared<ToggleRequestDeliveryReceiptsUIEvent>(enabled));
+	settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, enabled);
 }
 
 QtEventWindow* QtMainWindow::getEventWindow() {
 	return eventWindow_;
 }
 
 QtChatListWindow* QtMainWindow::getChatListWindow() {
 	return chatListWindow_;
 }
 
 void QtMainWindow::setRosterModel(Roster* roster) {
 	treeWidget_->setRosterModel(roster);
 }
 
 void QtMainWindow::handleEditProfileRequest() {
 	uiEventStream_->send(boost::make_shared<RequestProfileEditorUIEvent>());
 }
 
 void QtMainWindow::handleEventCountUpdated(int count) {
 	QColor eventTabColor = (count == 0) ? QColor() : QColor(255, 0, 0); // invalid resets to default
 	int eventIndex = 2;
 	tabs_->tabBar()->setTabTextColor(eventIndex, eventTabColor);
 	QString text = tr("&Notices");
 	if (count > 0) {
 		text += QString(" (%1)").arg(count);
 	}
 	tabs_->setTabText(eventIndex, text);
 }
 
 void QtMainWindow::handleChatCountUpdated(int count) {
 	QColor chatTabColor = (count == 0) ? QColor() : QColor(255, 0, 0); // invalid resets to default
 	int chatIndex = 1;
 	tabs_->tabBar()->setTabTextColor(chatIndex, chatTabColor);
 	QString text = tr("&Chats");
 	if (count > 0) {
 		text += QString(" (%1)").arg(count);
 	}
 	tabs_->setTabText(chatIndex, text);
 }
 
 void QtMainWindow::handleAddUserActionTriggered(bool /*checked*/) {
 	boost::shared_ptr<UIEvent> event(new RequestAddUserDialogUIEvent());
 	uiEventStream_->send(event);
 }
 
 void QtMainWindow::handleChatUserActionTriggered(bool /*checked*/) {
 	boost::shared_ptr<UIEvent> event(new RequestChatWithUserDialogUIEvent());
 	uiEventStream_->send(event);
 }
 
 void QtMainWindow::handleSignOutAction() {
 	loginMenus_.generalMenu->removeAction(toggleRequestDeliveryReceipts_);
 	onSignOutRequest();
 }
 
 void QtMainWindow::handleEditProfileAction() {
 	uiEventStream_->send(boost::make_shared<RequestProfileEditorUIEvent>());
 }
 
 void QtMainWindow::handleJoinMUCAction() {
 	uiEventStream_->send(boost::make_shared<RequestJoinMUCUIEvent>());
 }
 
 void QtMainWindow::handleStatusChanged(StatusShow::Type showType, const QString &statusMessage) {
 	onChangeStatusRequest(showType, Q2PSTRING(statusMessage));
 }
 
-void QtMainWindow::handleUIEvent(boost::shared_ptr<UIEvent> event) {
-	boost::shared_ptr<ToggleShowOfflineUIEvent> toggleEvent = boost::dynamic_pointer_cast<ToggleShowOfflineUIEvent>(event);
-	if (toggleEvent) {
-		handleShowOfflineToggled(toggleEvent->getShow());
+void QtMainWindow::handleSettingChanged(const std::string& settingPath) {
+	if (settingPath == SettingConstants::SHOW_OFFLINE.getKey()) {
+		handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));
 	}
-	boost::shared_ptr<ToggleRequestDeliveryReceiptsUIEvent> deliveryReceiptEvent = boost::dynamic_pointer_cast<ToggleRequestDeliveryReceiptsUIEvent>(event);
-	if (deliveryReceiptEvent) {
-		toggleRequestDeliveryReceipts_->setChecked(deliveryReceiptEvent->getEnabled());
+	if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {
+		toggleRequestDeliveryReceipts_->setChecked(settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS));
 	}
 }
 
 void QtMainWindow::handleShowOfflineToggled(bool state) {
 	if (state != lastOfflineState_) {
 		lastOfflineState_ = state;
 		showOfflineAction_->setChecked(state);
-		uiEventStream_->onUIEvent(boost::shared_ptr<UIEvent>(new ToggleShowOfflineUIEvent(state)));
+		settings_->storeSetting(SettingConstants::SHOW_OFFLINE, state);
 	}
 }
 
 void QtMainWindow::setMyNick(const std::string& nick) {
 	meView_->setNick(P2QSTRING(nick));
 }
 
 void QtMainWindow::setMyJID(const JID& jid) {
 	meView_->setJID(P2QSTRING(jid.toBare().toString()));
 }
 
 void QtMainWindow::setMyAvatarPath(const std::string& path) {
 	meView_->setAvatar(P2QSTRING(path));
 }
 
 void QtMainWindow::setMyStatusText(const std::string& status) {
 	meView_->setStatusText(P2QSTRING(status));
 }
 
 void QtMainWindow::setMyStatusType(StatusShow::Type type) {
 	meView_->setStatusType(type);
 }
 
 void QtMainWindow::setConnecting() {
 	meView_->setConnecting();
 }
 
 void QtMainWindow::handleAdHocActionTriggered(bool /*checked*/) {
 	QAction* action = qobject_cast<QAction*>(sender());
 	assert(action);
 	DiscoItems::Item command = serverAdHocCommands_[serverAdHocCommandActions_.indexOf(action)];
 	uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestAdHocUIEvent(command)));
 }
 
 void QtMainWindow::setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) {
diff --git a/Swift/QtUI/QtMainWindow.h b/Swift/QtUI/QtMainWindow.h
index 3c8bdec..44f8a25 100644
--- a/Swift/QtUI/QtMainWindow.h
+++ b/Swift/QtUI/QtMainWindow.h
@@ -1,91 +1,90 @@
 /*
  * Copyright (c) 2010-2011 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QWidget>
 #include <QMenu>
 #include <QList>
 #include "Swift/Controllers/UIInterfaces/MainWindow.h"
 #include "Swift/QtUI/QtRosterHeader.h"
 #include "Swift/QtUI/EventViewer/QtEventWindow.h"
 #include "Swift/QtUI/ChatList/QtChatListWindow.h"
 #include "Swift/QtUI/QtLoginWindow.h"
 
 #include <vector>
 
 class QComboBox;
 class QLineEdit;
 class QPushButton;
 class QToolBar;
 class QAction;
 class QMenu;
 class QTabWidget;
 
 namespace Swift {
 	class QtRosterWidget;
 	class TreeWidget;
 	class UIEventStream;
 	class QtTabWidget;
-	class QtSettingsProvider;
+	class SettingsProvider;
 	class QtUIPreferences;
 
 	class QtMainWindow : public QWidget, public MainWindow {
 		Q_OBJECT
 		public:
-			QtMainWindow(QtSettingsProvider*, UIEventStream* eventStream, QtUIPreferences* uiPreferences, QtLoginWindow::QtMenus loginMenus);
+			QtMainWindow(SettingsProvider*, UIEventStream* eventStream, QtLoginWindow::QtMenus loginMenus);
 			virtual ~QtMainWindow();
 			std::vector<QMenu*> getMenus() {return menus_;}
 			void setMyNick(const std::string& name);
 			void setMyJID(const JID& jid);
 			void setMyAvatarPath(const std::string& path);
 			void setMyStatusText(const std::string& status);
 			void setMyStatusType(StatusShow::Type type);
 			void setConnecting();
 			QtEventWindow* getEventWindow();
 			QtChatListWindow* getChatListWindow();
 			void setRosterModel(Roster* roster);
 			void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands);
 		private slots:
 			void handleStatusChanged(StatusShow::Type showType, const QString &statusMessage);
-			void handleUIEvent(boost::shared_ptr<UIEvent> event);
+			void handleSettingChanged(const std::string& settingPath);
 			void handleShowOfflineToggled(bool);
 			void handleJoinMUCAction();
 			void handleSignOutAction();
 			void handleEditProfileAction();
 			void handleAddUserActionTriggered(bool checked);
 			void handleChatUserActionTriggered(bool checked);
 			void handleAdHocActionTriggered(bool checked);
 			void handleEventCountUpdated(int count);
 			void handleChatCountUpdated(int count);
 			void handleEditProfileRequest();
 			void handleTabChanged(int index);
 			void handleToggleRequestDeliveryReceipts(bool enabled);
 
 		private:
-			QtSettingsProvider* settings_;
+			SettingsProvider* settings_;
 			QtLoginWindow::QtMenus loginMenus_;
 			std::vector<QMenu*> menus_;
 			QtRosterWidget* treeWidget_;
 			QtRosterHeader* meView_;
 			QAction* addUserAction_;
 			QAction* editUserAction_;
 			QAction* chatUserAction_;
 			QAction* showOfflineAction_;
 			QAction* toggleRequestDeliveryReceipts_;
 			QMenu* serverAdHocMenu_;
 			QtTabWidget* tabs_;
 			QWidget* contactsTabWidget_;
 			QWidget* eventsTabWidget_;
 			QtEventWindow* eventWindow_;
 			QtChatListWindow* chatListWindow_;
 			UIEventStream* uiEventStream_;
 			bool lastOfflineState_;
 			std::vector<DiscoItems::Item> serverAdHocCommands_;
 			QList<QAction*> serverAdHocCommandActions_;
-			QtUIPreferences* uiPreferences_;
 	};
 }
diff --git a/Swift/QtUI/QtNameWidget.cpp b/Swift/QtUI/QtNameWidget.cpp
index 96f9c0d..08e32f5 100644
--- a/Swift/QtUI/QtNameWidget.cpp
+++ b/Swift/QtUI/QtNameWidget.cpp
@@ -1,95 +1,96 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2012 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtNameWidget.h"
 
 #include <QHBoxLayout>
 #include <QMenu>
 #include <QMouseEvent>
 #include <QtDebug>
 
 #include <Swift/QtUI/QtElidingLabel.h>
 #include <Swift/QtUI/QtSettingsProvider.h>
+#include <Swift/QtUI/QtUISettingConstants.h>
 
 namespace Swift {
 
-QtNameWidget::QtNameWidget(QtSettingsProvider* settings, QWidget *parent) : QWidget(parent), settings(settings) {
+QtNameWidget::QtNameWidget(SettingsProvider* settings, QWidget *parent) : QWidget(parent), settings(settings) {
 	QHBoxLayout* mainLayout = new QHBoxLayout(this);
 	mainLayout->setSpacing(0);
 	mainLayout->setContentsMargins(0,0,0,0);
 
-	mode = settings->getBoolSetting("showNickInRosterHeader", true) ? ShowNick : ShowJID;
+	mode = settings->getSetting(QtUISettingConstants::SHOW_NICK_IN_ROSTER_HEADER) ? ShowNick : ShowJID;
 
 	textLabel = new QtElidingLabel(this);
 	QFont font = textLabel->font();
 	font.setBold(true);
 	textLabel->setFont(font);
 	mainLayout->addWidget(textLabel);
 }
 
 void QtNameWidget::setNick(const QString& nick) {
 	this->nick = nick;
 	updateText();
 }
 
 void QtNameWidget::setJID(const QString& jid) {
 	this->jid = jid;
 	updateText();
 }
 
 void QtNameWidget::mousePressEvent(QMouseEvent* event) {
 	QMenu menu;
 	bool hasNick = !nick.isEmpty();
 
 	QAction* showAsNick = new QAction(hasNick ? tr("Show Nickname") : tr("(No Nickname Set)"), this);
 	showAsNick->setCheckable(true);
 	showAsNick->setEnabled(hasNick);
 	if (mode == ShowNick && hasNick) {
 		showAsNick->setChecked(true);
 	}
 	menu.addAction(showAsNick);
 
 	QAction* showAsJID = new QAction(tr("Show Address"), this);
 	showAsJID->setCheckable(true);
 	if (mode == ShowJID || !hasNick) {
 		showAsJID->setChecked(true);
 	}
 	menu.addAction(showAsJID);
 
 	QAction* editProfile = new QAction(tr("Edit Profile"), this);
 	menu.addAction(editProfile);
 
 	QAction* result = menu.exec(event->globalPos());
 	if (result == showAsJID) {
 		mode = ShowJID;
 	}
 	else if (result == showAsNick) {
 		mode = ShowNick;
 	}
 	else if (result == editProfile) {
 		emit onChangeNickRequest();
 	}
-	settings->storeBool("showNickInRosterHeader", mode == ShowNick);
+	settings->storeSetting(QtUISettingConstants::SHOW_NICK_IN_ROSTER_HEADER, mode == ShowNick);
 	updateText();
 }
 
 void QtNameWidget::updateText() {
 	QString text;
 	if (mode == ShowNick && !nick.isEmpty()) {
 		text = nick;
 	}
 	else {
 		text = jid;
 	}
 	text.replace("<","&lt;");
 	textLabel->setText(text);
 }
 
 }
 
 
 
 
diff --git a/Swift/QtUI/QtNameWidget.h b/Swift/QtUI/QtNameWidget.h
index 674d55c..0f00c41 100644
--- a/Swift/QtUI/QtNameWidget.h
+++ b/Swift/QtUI/QtNameWidget.h
@@ -1,44 +1,44 @@
 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QWidget>
 
 namespace Swift {
 	class QtElidingLabel;
-	class QtSettingsProvider;
+	class SettingsProvider;
 
 	class QtNameWidget : public QWidget {
 			Q_OBJECT
 
 		public:
-			QtNameWidget(QtSettingsProvider* settings, QWidget *parent);
+			QtNameWidget(SettingsProvider* settings, QWidget *parent);
 
 			void setNick(const QString& text);
 			void setJID(const QString& jid);
 
 		signals:
 			void onChangeNickRequest();
 
 		private:
 			void updateText();
 			virtual void mousePressEvent(QMouseEvent* event);
 
 		private:
 			enum Mode {
 				ShowNick,
 				ShowJID,
 			};
 
-			QtSettingsProvider* settings;
+			SettingsProvider* settings;
 			Mode mode;
 			QtElidingLabel* textLabel;
 			QString jid;
 			QString nick;
 	};
 }
 
diff --git a/Swift/QtUI/QtRosterHeader.cpp b/Swift/QtUI/QtRosterHeader.cpp
index 5fb4d1a..98e75c2 100644
--- a/Swift/QtUI/QtRosterHeader.cpp
+++ b/Swift/QtUI/QtRosterHeader.cpp
@@ -1,61 +1,61 @@
 /*
  * Copyright (c) 2010 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtRosterHeader.h"
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QFileInfo>
 #include <QIcon>
 #include <QSizePolicy>
 #include <qdebug.h>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QBitmap>
 
 #include "QtStatusWidget.h"
 #include <Swift/QtUI/QtElidingLabel.h>
 #include <Swift/QtUI/QtClickableLabel.h>
 #include <Swift/QtUI/QtNameWidget.h>
 #include "QtScaledAvatarCache.h"
 
 namespace Swift {
-QtRosterHeader::QtRosterHeader(QtSettingsProvider* settings, QWidget* parent) : QWidget(parent) {
+QtRosterHeader::QtRosterHeader(SettingsProvider* settings, QWidget* parent) : QWidget(parent) {
 	QHBoxLayout* topLayout = new QHBoxLayout();
 	topLayout->setSpacing(3);
 	topLayout->setContentsMargins(4,4,4,4);
 	setLayout(topLayout);
 	setMinimumHeight(50);
 	setMaximumHeight(50);
 
 	avatarLabel_ = new QtClickableLabel(this);
 	avatarLabel_->setMinimumSize(avatarSize_, avatarSize_);
 	avatarLabel_->setMaximumSize(avatarSize_, avatarSize_);
 	avatarLabel_->setAlignment(Qt::AlignCenter);
 	setAvatar(":/icons/avatar.png");
 	avatarLabel_->setScaledContents(false);
 	topLayout->addWidget(avatarLabel_);
 	connect(avatarLabel_, SIGNAL(clicked()), this, SIGNAL(onEditProfileRequest()));
 
 	QVBoxLayout* rightLayout = new QVBoxLayout();
 	rightLayout->setSpacing(4);
 	rightLayout->setContentsMargins(4,0,0,0);
 	topLayout->addLayout(rightLayout);
 
 	nameWidget_ = new QtNameWidget(settings, this);
 	connect(nameWidget_, SIGNAL(onChangeNickRequest()), this, SIGNAL(onEditProfileRequest()));
 	rightLayout->addWidget(nameWidget_);
 
 
 	statusWidget_ = new QtStatusWidget(this);
 	connect(statusWidget_, SIGNAL(onChangeStatusRequest(StatusShow::Type, const QString&)), this, SLOT(handleChangeStatusRequest(StatusShow::Type, const QString&)));
 	rightLayout->addWidget(statusWidget_);
 	show();
 }
 
 void QtRosterHeader::handleChangeStatusRequest(StatusShow::Type type, const QString& text) {
 	emit onChangeStatusRequest(type, text);
 }
diff --git a/Swift/QtUI/QtRosterHeader.h b/Swift/QtUI/QtRosterHeader.h
index 3380610..050460c 100644
--- a/Swift/QtUI/QtRosterHeader.h
+++ b/Swift/QtUI/QtRosterHeader.h
@@ -1,55 +1,55 @@
 /*
  * Copyright (c) 2010 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QWidget>
 #include <QLabel>
 #include <QPixmap>
 #include <QSize>
 #include <QToolBar>
 
 #include <string>
 #include "Swiften/Elements/StatusShow.h"
 
 #include "QtTextEdit.h"
 
 class QHBoxLayout;
 
 namespace Swift {
 	class QtClickableLabel;
 	class QtStatusWidget;
 	class QtNameWidget;
-	class QtSettingsProvider;
+	class SettingsProvider;
 	
 	class QtRosterHeader : public QWidget {
 		Q_OBJECT
 	public:
-		QtRosterHeader(QtSettingsProvider* settings, QWidget* parent = NULL);
+		QtRosterHeader(SettingsProvider* settings, QWidget* parent = NULL);
 		void setAvatar(const QString& path);
 
 		void setJID(const QString& jid);
 		void setNick(const QString& nick);
 
 		void setStatusText(const QString& statusMessage);
 		void setStatusType(StatusShow::Type type);
 		void setConnecting();
 	signals:
 		void onChangeStatusRequest(StatusShow::Type showType, const QString &statusMessage);
 		void onEditProfileRequest();
 
 	private slots:
 		void handleChangeStatusRequest(StatusShow::Type type, const QString &statusMessage);
 	private:
 		QString name_;
 		QtClickableLabel* avatarLabel_;
 		QtNameWidget* nameWidget_;
 		QtTextEdit* statusEdit_;
 		QToolBar* toolBar_;
 		QtStatusWidget* statusWidget_;
 		static const int avatarSize_;
 	};
 }
diff --git a/Swift/QtUI/QtSettingsProvider.cpp b/Swift/QtUI/QtSettingsProvider.cpp
index b8ef9bb..0c4d49b 100644
--- a/Swift/QtUI/QtSettingsProvider.cpp
+++ b/Swift/QtUI/QtSettingsProvider.cpp
@@ -1,94 +1,119 @@
 /*
- * Copyright (c) 2010 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "QtSettingsProvider.h"
+#include <QtSettingsProvider.h>
 
 #include <QStringList>
 #include <QFile>
 
 namespace Swift {
 
 QtSettingsProvider::QtSettingsProvider() {
 }
 
 QtSettingsProvider::~QtSettingsProvider() {
 
 }
 
-std::string QtSettingsProvider::getStringSetting(const std::string &settingPath) {
-	QVariant setting = settings_.value(settingPath.c_str());
-	return setting.isNull() ? "" : std::string(setting.toString().toUtf8());
+std::string QtSettingsProvider::getSetting(const Setting<std::string>& setting) {
+	QVariant variant = settings_.value(setting.getKey().c_str());
+	return variant.isNull() ? setting.getDefaultValue() : std::string(variant.toString().toUtf8());
 }
 
-void QtSettingsProvider::storeString(const std::string &settingPath, const std::string &settingValue) {
-	settings_.setValue(settingPath.c_str(), settingValue.c_str());
+void QtSettingsProvider::storeSetting(const Setting<std::string>& setting, const std::string& settingValue) {
+	bool changed = false;
+	if (getSetting(setting) != settingValue) {
+		changed = true;
+	}
+	settings_.setValue(setting.getKey().c_str(), settingValue.c_str());
+	if (changed) {
+		onSettingChanged(setting.getKey());
+	}
 	updatePermissions();
 }
 
-bool QtSettingsProvider::getBoolSetting(const std::string &settingPath, bool defaultValue) {
-	QVariant setting = settings_.value(settingPath.c_str());
-	return setting.isNull() ? defaultValue : setting.toBool();
+bool QtSettingsProvider::getSetting(const Setting<bool>& setting) {
+	QVariant variant = settings_.value(setting.getKey().c_str());
+	return variant.isNull() ? setting.getDefaultValue() : variant.toBool();
 }
 
-void QtSettingsProvider::storeBool(const std::string &settingPath, bool settingValue) {
-	settings_.setValue(settingPath.c_str(), settingValue);
+void QtSettingsProvider::storeSetting(const Setting<bool>& setting, const bool& settingValue) {
+	bool changed = false;
+	if (getSetting(setting) != settingValue) {
+		changed = true;
+	}
+	settings_.setValue(setting.getKey().c_str(), settingValue);
+	if (changed) {
+		onSettingChanged(setting.getKey());
+	}
 	updatePermissions();
 }
 
-int QtSettingsProvider::getIntSetting(const std::string &settingPath, int defaultValue) {
-	QVariant setting = settings_.value(settingPath.c_str());
-	return setting.isNull() ? defaultValue : setting.toInt();
+int QtSettingsProvider::getSetting(const Setting<int>& setting) {
+	QVariant variant = settings_.value(setting.getKey().c_str());
+	return variant.isNull() ? setting.getDefaultValue() : variant.toInt();
 }
 
-void QtSettingsProvider::storeInt(const std::string &settingPath, int settingValue) {
-	settings_.setValue(settingPath.c_str(), settingValue);
+void QtSettingsProvider::storeSetting(const Setting<int>& setting, const int& settingValue) {
+	bool changed = false;
+	if (getSetting(setting) != settingValue) {
+		changed = true;
+	}
+	settings_.setValue(setting.getKey().c_str(), settingValue);
+	if (changed) {
+		onSettingChanged(setting.getKey());
+	}
 	updatePermissions();
 }
 
 std::vector<std::string> QtSettingsProvider::getAvailableProfiles() {
 	std::vector<std::string> profiles;
 	QVariant profilesVariant = settings_.value("profileList");
 	foreach(QString profileQString, profilesVariant.toStringList()) {
 		profiles.push_back(std::string(profileQString.toUtf8()));
 	}
 	return profiles;
 }
 
 void QtSettingsProvider::createProfile(const std::string& profile) {
 	QStringList stringList = settings_.value("profileList").toStringList();
 	stringList.append(profile.c_str());
 	settings_.setValue("profileList", stringList);
 	updatePermissions();
 }
 
 void QtSettingsProvider::removeProfile(const std::string& profile) {
 	QString profileStart(QString(profile.c_str()) + ":");
 	foreach (QString key, settings_.allKeys()) {
 		if (key.startsWith(profileStart)) {
 			settings_.remove(key);
 		}
 	}
 	QStringList stringList = settings_.value("profileList").toStringList();
 	stringList.removeAll(profile.c_str());
 	settings_.setValue("profileList", stringList);
 	updatePermissions();
 }
 
 QSettings* QtSettingsProvider::getQSettings() {
 	return &settings_;
 }
 
 void QtSettingsProvider::updatePermissions() {
 #if !defined(Q_WS_WIN) && !defined(Q_WS_MAC)
 	QFile file(settings_.fileName());
 	if (file.exists()) {
 		file.setPermissions(QFile::ReadOwner|QFile::WriteOwner);
 	}
 #endif
 }
 
+bool QtSettingsProvider::getIsSettingFinal(const std::string& /*settingPath*/) {
+	return false;
+}
+
 }
 
diff --git a/Swift/QtUI/QtSettingsProvider.h b/Swift/QtUI/QtSettingsProvider.h
index 8eeb854..ececa6e 100644
--- a/Swift/QtUI/QtSettingsProvider.h
+++ b/Swift/QtUI/QtSettingsProvider.h
@@ -1,42 +1,43 @@
 /*
- * Copyright (c) 2010 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#ifndef SWIFT_QtSettingsProvider_H
-#define SWIFT_QtSettingsProvider_H
+#pragma once
 
-#include "Swift/Controllers/Settings/SettingsProvider.h"
+#include <Swift/Controllers/Settings/SettingsProvider.h>
 
 #include <QSettings>
 
 namespace Swift {
 
 class QtSettingsProvider : public SettingsProvider {
 	public:
 		QtSettingsProvider();
 		virtual ~QtSettingsProvider();
-		virtual std::string getStringSetting(const std::string &settingPath);
-		virtual void storeString(const std::string &settingPath, const std::string &settingValue);
-		virtual bool getBoolSetting(const std::string &settingPath, bool defaultValue);
-		virtual void storeBool(const std::string &settingPath, bool settingValue);
-		virtual int getIntSetting(const std::string &settingPath, int defaultValue);
-		virtual void storeInt(const std::string &settingPath, int settingValue);
+		virtual std::string getSetting(const Setting<std::string>& setting);
+		virtual void storeSetting(const Setting<std::string>& setting, const std::string& value);
+		virtual bool getSetting(const Setting<bool>& setting);
+		virtual void storeSetting(const Setting<bool>& setting, const bool& value);
+		virtual int getSetting(const Setting<int>& setting);
+		virtual void storeSetting(const Setting<int>& setting, const int& value);
 		virtual std::vector<std::string> getAvailableProfiles();
 		virtual void createProfile(const std::string& profile);
 		virtual void removeProfile(const std::string& profile);
 		QSettings* getQSettings();
+	protected:
+		virtual bool getIsSettingFinal(const std::string& settingPath);
 	
 	private:
 		void updatePermissions();
 
 	private:
 		QSettings settings_;
 };
 
 }
-#endif
+
 
 
 
diff --git a/Swift/QtUI/QtSwift.cpp b/Swift/QtUI/QtSwift.cpp
index f706deb..066d22e 100644
--- a/Swift/QtUI/QtSwift.cpp
+++ b/Swift/QtUI/QtSwift.cpp
@@ -1,208 +1,228 @@
 /*
- * Copyright (c) 2010-2011 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtSwift.h"
 
 #include <string>
 #include <QSplitter>
 #include <QFile>
 #include <boost/bind.hpp>
 #include <QMessageBox>
 #include <QApplication>
-
-#include "QtLoginWindow.h"
-#include "QtChatTabs.h"
-#include "QtSystemTray.h"
-#include "QtSoundPlayer.h"
-#include "QtSwiftUtil.h"
-#include "QtUIFactory.h"
-#include "QtChatWindowFactory.h"
+#include <qDebug.h>
+
+#include <QtLoginWindow.h>
+#include <QtChatTabs.h>
+#include <QtSystemTray.h>
+#include <QtSoundPlayer.h>
+#include <QtSwiftUtil.h>
+#include <QtUIFactory.h>
+#include <QtChatWindowFactory.h>
 #include <Swiften/Base/Log.h>
 #include <Swift/Controllers/Storages/CertificateFileStorageFactory.h>
-#include "Swift/Controllers/Storages/FileStoragesFactory.h"
-#include "SwifTools/Application/PlatformApplicationPathProvider.h"
+#include <Swift/Controllers/Storages/FileStoragesFactory.h>
+#include <SwifTools/Application/PlatformApplicationPathProvider.h>
 #include <string>
-#include "Swiften/Base/Platform.h"
-#include "Swiften/Elements/Presence.h"
-#include "Swiften/Client/Client.h"
-#include "Swift/Controllers/MainController.h"
-#include "Swift/Controllers/ApplicationInfo.h"
-#include "Swift/Controllers/BuildVersion.h"
-#include "SwifTools/AutoUpdater/AutoUpdater.h"
-#include "SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h"
+#include <Swiften/Base/Platform.h>
+#include <Swiften/Elements/Presence.h>
+#include <Swiften/Client/Client.h>
+#include <Swift/Controllers/Settings/XMLSettingsProvider.h>
+#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>
+#include <Swift/Controllers/MainController.h>
+#include <Swift/Controllers/ApplicationInfo.h>
+#include <Swift/Controllers/BuildVersion.h>
+#include <SwifTools/AutoUpdater/AutoUpdater.h>
+#include <SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h>
+#include "Swiften/Base/Paths.h"
 
 #if defined(SWIFTEN_PLATFORM_WINDOWS)
 #include "WindowsNotifier.h"
 #elif defined(HAVE_GROWL)
 #include "SwifTools/Notifier/GrowlNotifier.h"
 #elif defined(SWIFTEN_PLATFORM_LINUX)
 #include "FreeDesktopNotifier.h"
 #else
 #include "SwifTools/Notifier/NullNotifier.h"
 #endif
 
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 #include "SwifTools/Dock/MacOSXDock.h"
 #else
 #include "SwifTools/Dock/NullDock.h"
 #endif
 
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 #include "QtURIHandler.h"
 #elif defined(SWIFTEN_PLATFORM_WIN32)
 #include <SwifTools/URIHandler/NullURIHandler.h>
 #else
 #include "QtDBUSURIHandler.h"
 #endif
 
 namespace Swift{
 
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 #define SWIFT_APPCAST_URL "http://swift.im/appcast/swift-mac-dev.xml"
 #else 
 #define SWIFT_APPCAST_URL ""
 #endif
 
 po::options_description QtSwift::getOptionsDescription() {
 	po::options_description result("Options");
 	result.add_options()
 		("debug", "Turn on debug logging")
 		("help", "Show this help message")
 		("version", "Show version information")
 		("netbook-mode", "Use netbook mode display (unsupported)")
 		("no-tabs", "Don't manage chat windows in tabs (unsupported)")
 		("latency-debug", "Use latency debugging (unsupported)")
 		("multi-account", po::value<int>()->default_value(1), "Number of accounts to open windows for (unsupported)")
 		("start-minimized", "Don't show the login/roster window at startup")
-		("eagle-mode", "Settings more suitable for military/secure deployments")
 		;
 	return result;
 }
 
+XMLSettingsProvider* QtSwift::loadSettingsFile(const QString& fileName) {
+	QFile configFile(fileName);
+	if (configFile.exists() && configFile.open(QIODevice::ReadOnly)) {
+		QString xmlString;
+		while (!configFile.atEnd()) {
+			QByteArray line = configFile.readLine();
+			xmlString += line + "\n";
+		}
+		return new XMLSettingsProvider(Q2PSTRING(xmlString));
+	}
+	return new XMLSettingsProvider("");
+}
 
 QtSwift::QtSwift(const po::variables_map& options) : networkFactories_(&clientMainThreadCaller_), autoUpdater_(NULL), idleDetector_(&idleQuerier_, networkFactories_.getTimerFactory(), 1000) {
 	if (options.count("netbook-mode")) {
 		splitter_ = new QSplitter();
 	} else {
 		splitter_ = NULL;
 	}
 	QCoreApplication::setApplicationName(SWIFT_APPLICATION_NAME);
 	QCoreApplication::setOrganizationName(SWIFT_ORGANIZATION_NAME);
 	QCoreApplication::setOrganizationDomain(SWIFT_ORGANIZATION_DOMAIN);
 	QCoreApplication::setApplicationVersion(buildVersion);
 
+	qtSettings_ = new QtSettingsProvider();
+	xmlSettings_ = loadSettingsFile(P2QSTRING((Paths::getExecutablePath() / "system-settings.xml").string()));
+	settingsHierachy_ = new SettingsProviderHierachy();
+	settingsHierachy_->addProviderToTopOfStack(xmlSettings_);
+	settingsHierachy_->addProviderToTopOfStack(qtSettings_);
+
 	int numberOfAccounts = 1;
 	try {
 		numberOfAccounts = options["multi-account"].as<int>();
 	} catch (...) {
 		/* This seems to fail on a Mac when the .app is launched directly (the usual path).*/
 		numberOfAccounts = 1;
 	}
 
 	if (options.count("debug")) {
 		Swift::logging = true;
 	}
 
 	tabs_ = options.count("no-tabs") && !(splitter_ > 0) ? NULL : new QtChatTabs();
 	bool startMinimized = options.count("start-minimized") > 0;
-	bool eagleMode = options.count("eagle-mode") > 0;
-	settings_ = new QtSettingsProvider();
 	applicationPathProvider_ = new PlatformApplicationPathProvider(SWIFT_APPLICATION_NAME);
 	storagesFactory_ = new FileStoragesFactory(applicationPathProvider_->getDataDir());
 	certificateStorageFactory_ = new CertificateFileStorageFactory(applicationPathProvider_->getDataDir(), tlsFactories_.getCertificateFactory());
-	chatWindowFactory_ = new QtChatWindowFactory(splitter_, settings_, tabs_, "", &uiPreferences_);
+	chatWindowFactory_ = new QtChatWindowFactory(splitter_, settingsHierachy_, qtSettings_, tabs_, "");
 	soundPlayer_ = new QtSoundPlayer(applicationPathProvider_);
 
 	// Ugly, because the dock depends on the tray, but the temporary
 	// multi-account hack creates one tray per account.
 	QtSystemTray* systemTray = new QtSystemTray();
 	systemTrays_.push_back(systemTray);
 
 #if defined(HAVE_GROWL)
 	notifier_ = new GrowlNotifier(SWIFT_APPLICATION_NAME);
 #elif defined(SWIFTEN_PLATFORM_WINDOWS)
 	notifier_ = new WindowsNotifier(SWIFT_APPLICATION_NAME, applicationPathProvider_->getResourcePath("/images/logo-icon-32.png"), systemTray->getQSystemTrayIcon());
 #elif defined(SWIFTEN_PLATFORM_LINUX)
 	notifier_ = new FreeDesktopNotifier(SWIFT_APPLICATION_NAME);
 #else
 	notifier_ = new NullNotifier();
 #endif
 
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 	dock_ = new MacOSXDock(&cocoaApplication_);
 #else
 	dock_ = new NullDock();
 #endif
 
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 	uriHandler_ = new QtURIHandler();
 #elif defined(SWIFTEN_PLATFORM_WIN32)
 	uriHandler_ = new NullURIHandler();
 #else
 	uriHandler_ = new QtDBUSURIHandler();
 #endif
 
 	if (splitter_) {
 		splitter_->show();
 	}
 
 	for (int i = 0; i < numberOfAccounts; i++) {
 		if (i > 0) {
 			// Don't add the first tray (see note above)
 			systemTrays_.push_back(new QtSystemTray());
 		}
-		QtUIFactory* uiFactory = new QtUIFactory(settings_, tabs_, splitter_, systemTrays_[i], chatWindowFactory_, startMinimized, eagleMode, &uiPreferences_);
+		QtUIFactory* uiFactory = new QtUIFactory(settingsHierachy_, qtSettings_, tabs_, splitter_, systemTrays_[i], chatWindowFactory_, startMinimized);
 		uiFactories_.push_back(uiFactory);
 		MainController* mainController = new MainController(
 				&clientMainThreadCaller_,
 				&networkFactories_,
 				uiFactory,
-				settings_,
+				settingsHierachy_,
 				systemTrays_[i],
 				soundPlayer_,
 				storagesFactory_,
 				certificateStorageFactory_,
 				dock_,
 				notifier_,
 				uriHandler_,
 				&idleDetector_,
-				options.count("latency-debug") > 0,
-				eagleMode);
+				options.count("latency-debug") > 0);
 		mainControllers_.push_back(mainController);
 	}
 
 
 	// PlatformAutoUpdaterFactory autoUpdaterFactory;
 	// if (autoUpdaterFactory.isSupported()) {
 	// 	autoUpdater_ = autoUpdaterFactory.createAutoUpdater(SWIFT_APPCAST_URL);
 	// 	autoUpdater_->checkForUpdates();
 	// }
 }
 
 QtSwift::~QtSwift() {
 	delete notifier_;
 	delete autoUpdater_;
 	foreach (QtUIFactory* factory, uiFactories_) {
 		delete factory;
 	}
 	foreach (MainController* controller, mainControllers_) {
 		delete controller;
 	}
-	delete settings_;
+	delete settingsHierachy_;
+	delete qtSettings_;
+	delete xmlSettings_;
 	foreach (QtSystemTray* tray, systemTrays_) {
 		delete tray;
 	}
 	delete tabs_;
 	delete splitter_;
 	delete uriHandler_;
 	delete dock_;
 	delete soundPlayer_;
 	delete chatWindowFactory_;
 	delete certificateStorageFactory_;
 	delete storagesFactory_;
 }
 
 }
diff --git a/Swift/QtUI/QtSwift.h b/Swift/QtUI/QtSwift.h
index c808fa0..7a49fa7 100644
--- a/Swift/QtUI/QtSwift.h
+++ b/Swift/QtUI/QtSwift.h
@@ -1,84 +1,88 @@
 /*
- * Copyright (c) 2010 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <boost/program_options/variables_map.hpp>
 #include <boost/program_options/options_description.hpp>
 
 #include <Swiften/TLS/PlatformTLSFactories.h>
 #include <Swiften/Network/BoostNetworkFactories.h>
 #include <string>
 #include "Swiften/Base/Platform.h"
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "QtSettingsProvider.h"
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 #include "SwifTools/Application/CocoaApplication.h"
 #endif
 #if defined(SWIFTEN_PLATFORM_WINDOWS)
 #include "WindowsNotifier.h"
 #endif
 #include "SwifTools/Idle/PlatformIdleQuerier.h"
 #include "SwifTools/Idle/ActualIdleDetector.h"
-#include <Swift/QtUI/QtUIPreferences.h>
 
 namespace po = boost::program_options;
 
 class QSplitter;
 
 namespace Swift {
 	class QtUIFactory;
 	class CertificateStorageFactory;
 	class Dock;
 	class Notifier;
 	class StoragesFactory;
 	class AutoUpdater;
 	class ApplicationPathProvider;
 	class AvatarStorage;
 	class CapsStorage;
 	class MainController;
 	class QtSystemTray;
 	class QtChatTabs;
 	class QtChatWindowFactory;
 	class QtSoundPlayer;
 	class QtMUCSearchWindowFactory;
 	class QtUserSearchWindowFactory;
 	class EventLoop;
 	class URIHandler;
+	class SettingsProviderHierachy;
+	class XMLSettingsProvider;
 		
 	class QtSwift : public QObject {
 		Q_OBJECT
 		public:
 			QtSwift(const po::variables_map& options);
 			static po::options_description getOptionsDescription();
 			~QtSwift();
 		private:
+			XMLSettingsProvider* loadSettingsFile(const QString& fileName);
+		private:
 			QtEventLoop clientMainThreadCaller_;
 			PlatformTLSFactories tlsFactories_;
 			BoostNetworkFactories networkFactories_;
 			QtChatWindowFactory* chatWindowFactory_;
 			std::vector<MainController*> mainControllers_;
 			std::vector<QtSystemTray*> systemTrays_;
 			std::vector<QtUIFactory*> uiFactories_;
-			QtSettingsProvider *settings_;
+			QtSettingsProvider* qtSettings_;
+			XMLSettingsProvider* xmlSettings_;
+			SettingsProviderHierachy* settingsHierachy_;
 			QSplitter* splitter_;
 			QtSoundPlayer* soundPlayer_;
 			Dock* dock_;
 			URIHandler* uriHandler_;
 			QtChatTabs* tabs_;
 			ApplicationPathProvider* applicationPathProvider_;
 			StoragesFactory* storagesFactory_;
 			CertificateStorageFactory* certificateStorageFactory_;
 			AutoUpdater* autoUpdater_;
 			Notifier* notifier_;
 			PlatformIdleQuerier idleQuerier_;
 			ActualIdleDetector idleDetector_;
-			QtUIPreferences uiPreferences_;
 #if defined(SWIFTEN_PLATFORM_MACOSX)
 			CocoaApplication cocoaApplication_;
 #endif
 	};
 }
diff --git a/Swift/QtUI/QtUIFactory.cpp b/Swift/QtUI/QtUIFactory.cpp
index 88da781..c686442 100644
--- a/Swift/QtUI/QtUIFactory.cpp
+++ b/Swift/QtUI/QtUIFactory.cpp
@@ -1,141 +1,141 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2012 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtUIFactory.h"
 
 #include <QSplitter>
 
 #include "QtXMLConsoleWidget.h"
 #include "QtChatTabs.h"
 #include "QtMainWindow.h"
 #include "QtLoginWindow.h"
 #include "QtSystemTray.h"
 #include "QtSettingsProvider.h"
 #include "QtMainWindow.h"
 #include "QtChatWindow.h"
 #include "QtJoinMUCWindow.h"
 #include "QtChatWindowFactory.h"
 #include "QtSwiftUtil.h"
 #include "MUCSearch/QtMUCSearchWindow.h"
 #include "UserSearch/QtUserSearchWindow.h"
 #include "QtProfileWindow.h"
 #include "QtContactEditWindow.h"
 #include "QtAdHocCommandWindow.h"
 #include "QtFileTransferListWidget.h"
-
-#define CHATWINDOW_FONT_SIZE "chatWindowFontSize"
+#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>
+#include <Swift/QtUI/QtUISettingConstants.h>
 
 namespace Swift {
 
-QtUIFactory::QtUIFactory(QtSettingsProvider* settings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized, bool eagleMode, QtUIPreferences* uiPreferences) : settings(settings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), lastMainWindow(NULL), loginWindow(NULL), startMinimized(startMinimized), eagleMode(eagleMode), uiPreferences(uiPreferences)  {
-	chatFontSize = settings->getIntSetting(CHATWINDOW_FONT_SIZE, 0);
+QtUIFactory::QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized) : settings(settings), qtOnlySettings(qtOnlySettings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), lastMainWindow(NULL), loginWindow(NULL), startMinimized(startMinimized) {
+	chatFontSize = settings->getSetting(QtUISettingConstants::CHATWINDOW_FONT_SIZE);
 }
 
 XMLConsoleWidget* QtUIFactory::createXMLConsoleWidget() {
 	QtXMLConsoleWidget* widget = new QtXMLConsoleWidget();
 	tabs->addTab(widget);
 	if (!tabs->isVisible()) {
 		tabs->show();
 	}
 	widget->show();
 	return widget;
 }
 
 FileTransferListWidget* QtUIFactory::createFileTransferListWidget() {
 	QtFileTransferListWidget* widget = new QtFileTransferListWidget();
 	tabs->addTab(widget);
 	if (!tabs->isVisible()) {
 		tabs->show();
 	}
 	widget->show();
 	return widget;
 }
 
 MainWindow* QtUIFactory::createMainWindow(UIEventStream* eventStream) {
-	lastMainWindow  = new QtMainWindow(settings, eventStream, uiPreferences, loginWindow->getMenus());
+	lastMainWindow  = new QtMainWindow(settings, eventStream, loginWindow->getMenus());
 	return lastMainWindow;
 }
 
 LoginWindow* QtUIFactory::createLoginWindow(UIEventStream* eventStream) {
-	loginWindow = new QtLoginWindow(eventStream, eagleMode);
+	loginWindow = new QtLoginWindow(eventStream, settings);
 	if (netbookSplitter) {
 		netbookSplitter->insertWidget(0, loginWindow);
 	}
 	connect(systemTray, SIGNAL(clicked()), loginWindow, SLOT(bringToFront()));
 
 #ifndef SWIFT_MOBILE
-	QVariant loginWindowGeometryVariant = settings->getQSettings()->value("loginWindowGeometry");
+	QVariant loginWindowGeometryVariant = qtOnlySettings->getQSettings()->value("loginWindowGeometry");
 	if (loginWindowGeometryVariant.isValid()) {
 		loginWindow->restoreGeometry(loginWindowGeometryVariant.toByteArray());
 	}
 	connect(loginWindow, SIGNAL(geometryChanged()), this, SLOT(handleLoginWindowGeometryChanged()));
 	if (startMinimized) loginWindow->hide();
 #endif
 	return loginWindow;
 }
 
 void QtUIFactory::handleLoginWindowGeometryChanged() {
-	settings->getQSettings()->setValue("loginWindowGeometry", loginWindow->saveGeometry());
+	qtOnlySettings->getQSettings()->setValue("loginWindowGeometry", loginWindow->saveGeometry());
 }
 
 EventWindow* QtUIFactory::createEventWindow() {
 	return lastMainWindow->getEventWindow();
 }
 
 ChatListWindow* QtUIFactory::createChatListWindow(UIEventStream*) {
 	return lastMainWindow->getChatListWindow();
 }
 
 MUCSearchWindow* QtUIFactory::createMUCSearchWindow() {
 		return new QtMUCSearchWindow();
 }
 
 ChatWindow* QtUIFactory::createChatWindow(const JID& contact, UIEventStream* eventStream) {
 	QtChatWindow* window = dynamic_cast<QtChatWindow*>(chatWindowFactory->createChatWindow(contact, eventStream));
 	chatWindows.push_back(window);
 	std::vector<QPointer<QtChatWindow> > deletions;
 	foreach (QPointer<QtChatWindow> existingWindow, chatWindows) {
 		if (existingWindow.isNull()) {
 			deletions.push_back(existingWindow);
 		} else {
 			connect(window, SIGNAL(fontResized(int)), existingWindow, SLOT(handleFontResized(int)));
 			connect(existingWindow, SIGNAL(fontResized(int)), window, SLOT(handleFontResized(int)));
 		}
 	}
 	foreach (QPointer<QtChatWindow> deletedWindow, deletions) {
 		chatWindows.erase(std::remove(chatWindows.begin(), chatWindows.end(), deletedWindow), chatWindows.end());
 	}
 	connect(window, SIGNAL(fontResized(int)), this, SLOT(handleChatWindowFontResized(int)));
 	window->handleFontResized(chatFontSize);
 	return window;
 }
 
 void QtUIFactory::handleChatWindowFontResized(int size) {
 	chatFontSize = size;
-	settings->storeInt(CHATWINDOW_FONT_SIZE, size);
+	settings->storeSetting(QtUISettingConstants::CHATWINDOW_FONT_SIZE, size);
 }
 
 UserSearchWindow* QtUIFactory::createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) {
 	return new QtUserSearchWindow(eventStream, type, groups);
 };
 
 JoinMUCWindow* QtUIFactory::createJoinMUCWindow(UIEventStream* uiEventStream) {
 	return new QtJoinMUCWindow(uiEventStream);
 }
 
 ProfileWindow* QtUIFactory::createProfileWindow() {
 	return new QtProfileWindow();
 }
 
 ContactEditWindow* QtUIFactory::createContactEditWindow() {
 	return new QtContactEditWindow();
 }
 
 void QtUIFactory::createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) {
 	new QtAdHocCommandWindow(command);
 }
 
 }
diff --git a/Swift/QtUI/QtUIFactory.h b/Swift/QtUI/QtUIFactory.h
index db33365..c9e2f2e 100644
--- a/Swift/QtUI/QtUIFactory.h
+++ b/Swift/QtUI/QtUIFactory.h
@@ -1,64 +1,63 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2012 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QObject>
 #include <QPointer>
 
 #include <Swift/Controllers/UIInterfaces/UIFactory.h>
-#include <Swift/QtUI/QtUIPreferences.h>
 
 class QSplitter;
 
 namespace Swift {
 	class QtSettingsProvider;
+	class SettingsProviderHierachy;
 	class QtChatTabs;
 	class QtSystemTray;
 	class QtLoginWindow;
 	class QtMainWindow;
 	class QtChatTheme;
 	class QtChatWindowFactory;
 	class QtChatWindow;
 
 	class QtUIFactory : public QObject, public UIFactory {
 			Q_OBJECT
 		public:
-			QtUIFactory(QtSettingsProvider* settings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized, bool eagleMode, QtUIPreferences* uiPreferences);
+			QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized);
 
 			virtual XMLConsoleWidget* createXMLConsoleWidget();
 			virtual MainWindow* createMainWindow(UIEventStream* eventStream);
 			virtual LoginWindow* createLoginWindow(UIEventStream* eventStream);
 			virtual EventWindow* createEventWindow();
 			virtual ChatListWindow* createChatListWindow(UIEventStream*);
 			virtual MUCSearchWindow* createMUCSearchWindow();
 			virtual ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);
 			virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups);
 			virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream);
 			virtual ProfileWindow* createProfileWindow();
 			virtual ContactEditWindow* createContactEditWindow();
 			virtual FileTransferListWidget* createFileTransferListWidget();
 			virtual void createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command);
 
 		private slots:
 			void handleLoginWindowGeometryChanged();
 			void handleChatWindowFontResized(int);
 
 		private:
-			QtSettingsProvider* settings;
+			SettingsProviderHierachy* settings;
+			QtSettingsProvider* qtOnlySettings;
 			QtChatTabs* tabs;
 			QSplitter* netbookSplitter;
 			QtSystemTray* systemTray;
 			QtChatWindowFactory* chatWindowFactory;
 			QtMainWindow* lastMainWindow;
 			QtLoginWindow* loginWindow;
 			std::vector<QPointer<QtChatWindow> > chatWindows;
 			bool startMinimized;
 			int chatFontSize;
-			bool eagleMode;
-			QtUIPreferences* uiPreferences;
 	};
 }
diff --git a/Swift/QtUI/QtUIPreferences.cpp b/Swift/QtUI/QtUIPreferences.cpp
deleted file mode 100644
index 6662e71..0000000
--- a/Swift/QtUI/QtUIPreferences.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2011 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
- */
-
-#include <Swift/QtUI/QtUIPreferences.h>
-
-namespace Swift {
-QtUIPreferences::QtUIPreferences() : compactRosters_(false) {
-	
-}
-
-QtUIPreferences::~QtUIPreferences() {
-	
-}
-
-void QtUIPreferences::setCompactRosters(bool compact) {
-	compactRosters_ = compact;
-	emit onCompactRostersChanged(compact);
-}
-
-bool QtUIPreferences::getCompactRosters() {
-	return compactRosters_;
-}
-
-}
diff --git a/Swift/QtUI/QtUIPreferences.h b/Swift/QtUI/QtUIPreferences.h
deleted file mode 100644
index e537e80..0000000
--- a/Swift/QtUI/QtUIPreferences.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2011 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
- */
-
-#pragma once
-
-#include <QObject>
-
-namespace Swift {
-	class QtUIPreferences : public QObject {
-		Q_OBJECT
-		public:
-			QtUIPreferences();
-			~QtUIPreferences();
-			bool getCompactRosters();
-		public slots:
-			void setCompactRosters(bool compact);
-		signals:
-			void onCompactRostersChanged(bool /*now*/);
-		private:
-			bool compactRosters_;
-	};
-}
-\ No newline at end of file
diff --git a/Swift/QtUI/QtUISettingConstants.cpp b/Swift/QtUI/QtUISettingConstants.cpp
new file mode 100644
index 0000000..046ccc1
--- /dev/null
+++ b/Swift/QtUI/QtUISettingConstants.cpp
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2012 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include <Swift/QtUI/QtUISettingConstants.h>
+
+namespace Swift {
+
+const SettingsProvider::Setting<bool> QtUISettingConstants::COMPACT_ROSTER("compactRoster", false);
+const SettingsProvider::Setting<std::string> QtUISettingConstants::CLICKTHROUGH_BANNER("clickthroughBanner", "");
+const SettingsProvider::Setting<int> QtUISettingConstants::CURRENT_ROSTER_TAB("currentRosterTab", 0);
+const SettingsProvider::Setting<bool> QtUISettingConstants::SHOW_NICK_IN_ROSTER_HEADER("showNickInRosterHeader", true);
+const SettingsProvider::Setting<int> QtUISettingConstants::CHATWINDOW_FONT_SIZE("chatWindowFontSize", 0);
+}
diff --git a/Swift/QtUI/QtUISettingConstants.h b/Swift/QtUI/QtUISettingConstants.h
new file mode 100644
index 0000000..82f98bb
--- /dev/null
+++ b/Swift/QtUI/QtUISettingConstants.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2012 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#pragma once
+
+#include <Swift/Controllers/Settings/SettingsProvider.h>
+
+namespace Swift {
+	class QtUISettingConstants {
+		public:
+			static const SettingsProvider::Setting<bool> COMPACT_ROSTER;
+			static const SettingsProvider::Setting<std::string> CLICKTHROUGH_BANNER;
+			static const SettingsProvider::Setting<int> CURRENT_ROSTER_TAB;
+			static const SettingsProvider::Setting<bool> SHOW_NICK_IN_ROSTER_HEADER;
+			static const SettingsProvider::Setting<int> CHATWINDOW_FONT_SIZE;
+	};
+}
diff --git a/Swift/QtUI/Roster/QtOccupantListWidget.cpp b/Swift/QtUI/Roster/QtOccupantListWidget.cpp
index f864919..0b3722c 100644
--- a/Swift/QtUI/Roster/QtOccupantListWidget.cpp
+++ b/Swift/QtUI/Roster/QtOccupantListWidget.cpp
@@ -1,57 +1,57 @@
 /*
- * Copyright (c) 2011 Kevin Smith
+ * Copyright (c) 2011-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 
 #include "Roster/QtOccupantListWidget.h"
 
 #include <QContextMenuEvent>
 #include <QMenu>
 #include <QAction>
 #include <QInputDialog>
 
 #include "Swift/Controllers/Roster/ContactRosterItem.h"
 #include "Swift/Controllers/Roster/GroupRosterItem.h"
 #include "Swift/Controllers/UIEvents/UIEventStream.h"
 #include "QtSwiftUtil.h"
 
 namespace Swift {
 
-QtOccupantListWidget::QtOccupantListWidget(UIEventStream* eventStream, QtUIPreferences* uiPreferences, QWidget* parent) : QtTreeWidget(eventStream, uiPreferences, parent) {
+QtOccupantListWidget::QtOccupantListWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent) : QtTreeWidget(eventStream, settings, parent) {
 
 }
 
 QtOccupantListWidget::~QtOccupantListWidget() {
 
 }
 
 void QtOccupantListWidget::setAvailableOccupantActions(const std::vector<ChatWindow::OccupantAction>& actions) {
 	availableOccupantActions_ = actions;
 }
 
 void QtOccupantListWidget::contextMenuEvent(QContextMenuEvent* event) {
 	QModelIndex index = indexAt(event->pos());
 	if (!index.isValid()) {
 		return;
 	}
 
 	RosterItem* item = static_cast<RosterItem*>(index.internalPointer());
 	ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);
 	if (contact) {
 		onSomethingSelectedChanged(contact);
 		QMenu contextMenu;
 		if (availableOccupantActions_.empty()) {
 			QAction* noAction = contextMenu.addAction(tr("No actions for this user"));
 			noAction->setEnabled(false);
 			contextMenu.exec(event->globalPos());
 		}
 		else {
 			std::map<QAction*, ChatWindow::OccupantAction> actions;
 			foreach (ChatWindow::OccupantAction availableAction, availableOccupantActions_) {
 				QString text = "Error: missing string";
 				switch (availableAction) {
 					case ChatWindow::Kick: text = tr("Kick user"); break;
 					case ChatWindow::Ban: text = tr("Kick and ban user"); break;
 					case ChatWindow::MakeModerator: text = tr("Make moderator"); break;
diff --git a/Swift/QtUI/Roster/QtOccupantListWidget.h b/Swift/QtUI/Roster/QtOccupantListWidget.h
index da7c463..729115a 100644
--- a/Swift/QtUI/Roster/QtOccupantListWidget.h
+++ b/Swift/QtUI/Roster/QtOccupantListWidget.h
@@ -1,31 +1,31 @@
 /*
- * Copyright (c) 2011 Kevin Smith
+ * Copyright (c) 2011-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include "Swift/QtUI/Roster/QtTreeWidget.h"
 
 #include "Swiften/Base/boost_bsignals.h"
 #include "Swift/Controllers/UIInterfaces/ChatWindow.h"
 
 namespace Swift {
-class QtUIPreferences;
+class SettingsProvider;
 
 class QtOccupantListWidget : public QtTreeWidget {
 	Q_OBJECT
 	public:
-		QtOccupantListWidget(UIEventStream* eventStream, QtUIPreferences* uiPreferences, QWidget* parent = 0);
+		QtOccupantListWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent = 0);
 		virtual ~QtOccupantListWidget();
 		void setAvailableOccupantActions(const std::vector<ChatWindow::OccupantAction>& actions);
 		boost::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;
 	protected:
 		void contextMenuEvent(QContextMenuEvent* event);
 	private:
 		std::vector<ChatWindow::OccupantAction> availableOccupantActions_;
 };
 
 }
 
diff --git a/Swift/QtUI/Roster/QtRosterWidget.cpp b/Swift/QtUI/Roster/QtRosterWidget.cpp
index ac4b500..e3fee24 100644
--- a/Swift/QtUI/Roster/QtRosterWidget.cpp
+++ b/Swift/QtUI/Roster/QtRosterWidget.cpp
@@ -1,61 +1,61 @@
 /*
  * Copyright (c) 2011 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "Roster/QtRosterWidget.h"
 
 #include <QContextMenuEvent>
 #include <QMenu>
 #include <QInputDialog>
 #include <QFileDialog>
 
 #include "Swift/Controllers/UIEvents/RequestContactEditorUIEvent.h"
 #include "Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h"
 #include "Swift/Controllers/UIEvents/RenameGroupUIEvent.h"
 #include "Swift/Controllers/UIEvents/SendFileUIEvent.h"
 #include "QtContactEditWindow.h"
 #include "Swift/Controllers/Roster/ContactRosterItem.h"
 #include "Swift/Controllers/Roster/GroupRosterItem.h"
 #include "Swift/Controllers/UIEvents/UIEventStream.h"
 #include "QtSwiftUtil.h"
 
 namespace Swift {
 
-QtRosterWidget::QtRosterWidget(UIEventStream* eventStream, QtUIPreferences* uiPreferences, QWidget* parent) : QtTreeWidget(eventStream, uiPreferences, parent) {
+QtRosterWidget::QtRosterWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent) : QtTreeWidget(eventStream, settings, parent) {
 
 }
 
 QtRosterWidget::~QtRosterWidget() {
 
 }
 
 void QtRosterWidget::handleEditUserActionTriggered(bool /*checked*/) {
 	QModelIndexList selectedIndexList = getSelectedIndexes();
 	if (selectedIndexList.empty()) {
 		return;
 	}
 	QModelIndex index = selectedIndexList[0];
 	if (!index.isValid()) {
 		return;
 	}
 	RosterItem* item = static_cast<RosterItem*>(index.internalPointer());
 	if (ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item)) {
 		eventStream_->send(boost::make_shared<RequestContactEditorUIEvent>(contact->getJID()));
 	}
 }
 
 void QtRosterWidget::contextMenuEvent(QContextMenuEvent* event) {
 	QModelIndex index = indexAt(event->pos());
 	if (!index.isValid()) {
 		return;
 	}
 	RosterItem* item = static_cast<RosterItem*>(index.internalPointer());
 	QMenu contextMenu;
 	if (ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item)) {
 		QAction* editContact = contextMenu.addAction(tr("Edit"));
 		QAction* removeContact = contextMenu.addAction(tr("Remove"));
 #ifdef SWIFT_EXPERIMENTAL_FT
 		QAction* sendFile = NULL;
 		if (contact->supportsFeature(ContactRosterItem::FileTransferFeature)) {
diff --git a/Swift/QtUI/Roster/QtRosterWidget.h b/Swift/QtUI/Roster/QtRosterWidget.h
index 01f4726..549fe92 100644
--- a/Swift/QtUI/Roster/QtRosterWidget.h
+++ b/Swift/QtUI/Roster/QtRosterWidget.h
@@ -1,27 +1,27 @@
 /*
  * Copyright (c) 2011 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include "Swift/QtUI/Roster/QtTreeWidget.h"
 
 namespace Swift {
 class QtUIPreferences;
 
 class QtRosterWidget : public QtTreeWidget {
 	Q_OBJECT
 	public:
-		QtRosterWidget(UIEventStream* eventStream, QtUIPreferences* uiPreferences, QWidget* parent = 0);
+		QtRosterWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent = 0);
 		virtual ~QtRosterWidget();
 	public slots:
 		void handleEditUserActionTriggered(bool checked);
 	protected:
 		void contextMenuEvent(QContextMenuEvent* event);
 	private:
 		void renameGroup(GroupRosterItem* group);
 };
 
 }
diff --git a/Swift/QtUI/Roster/QtTreeWidget.cpp b/Swift/QtUI/Roster/QtTreeWidget.cpp
index 4382125..5fdf138 100644
--- a/Swift/QtUI/Roster/QtTreeWidget.cpp
+++ b/Swift/QtUI/Roster/QtTreeWidget.cpp
@@ -1,93 +1,99 @@
 /*
- * Copyright (c) 2010 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "Roster/QtTreeWidget.h"
 
 #include <boost/smart_ptr/make_shared.hpp>
+#include <boost/bind.hpp>
 
 #include <QUrl>
 
 #include <Swiften/Base/Platform.h>
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <QtSwiftUtil.h>
-#include <Swift/QtUI/QtUIPreferences.h>
+#include <Swift/Controllers/Settings/SettingsProvider.h>
+#include <Swift/QtUI/QtUISettingConstants.h>
 
 namespace Swift {
 
-QtTreeWidget::QtTreeWidget(UIEventStream* eventStream, QtUIPreferences* uiPreferences, QWidget* parent) : QTreeView(parent) {
+QtTreeWidget::QtTreeWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent) : QTreeView(parent) {
 	eventStream_ = eventStream;
-	uiPreferences_ = uiPreferences;
+	settings_ = settings;
 	model_ = new RosterModel(this);
 	setModel(model_);
-	delegate_ = new RosterDelegate(this, uiPreferences_->getCompactRosters());
+	delegate_ = new RosterDelegate(this, settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));
 	setItemDelegate(delegate_);
 	setHeaderHidden(true);
 #ifdef SWIFT_PLATFORM_MACOSX
 	setAlternatingRowColors(true);
 #endif
 	setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
 	expandAll();
 	setAnimated(true);
 	setIndentation(0);
 #ifdef SWIFT_EXPERIMENTAL_FT
 	setAcceptDrops(true);
 #endif
 	setRootIsDecorated(true);
 	connect(this, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));
 	connect(model_, SIGNAL(itemExpanded(const QModelIndex&, bool)), this, SLOT(handleModelItemExpanded(const QModelIndex&, bool)));
 	connect(this, SIGNAL(expanded(const QModelIndex&)), this, SLOT(handleExpanded(const QModelIndex&)));
 	connect(this, SIGNAL(collapsed(const QModelIndex&)), this, SLOT(handleCollapsed(const QModelIndex&)));
 	connect(this, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleClicked(const QModelIndex&)));
-	connect(uiPreferences_, SIGNAL(onCompactRostersChanged(bool)), this, SLOT(handleCompactRostersToggled(bool)));
+
+	settings_->onSettingChanged.connect(boost::bind(&QtTreeWidget::handleSettingChanged, this, _1));
 }
 
 QtTreeWidget::~QtTreeWidget() {
+	settings_->onSettingChanged.disconnect(boost::bind(&QtTreeWidget::handleSettingChanged, this, _1));
 	delete model_;
 	delete delegate_;
 }
 
-void QtTreeWidget::handleCompactRostersToggled(bool compact) {
-	delegate_->setCompact(compact);
-	repaint();
+void QtTreeWidget::handleSettingChanged(const std::string& setting) {
+	if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {
+		delegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));
+		repaint();
+	}
 }
 
 void QtTreeWidget::setRosterModel(Roster* roster) {
 	roster_ = roster;
 	model_->setRoster(roster);
 	expandAll();
 }
 
 QtTreeWidgetItem* QtTreeWidget::getRoot() {
 	return treeRoot_;
 }
 
 void QtTreeWidget::handleClicked(const QModelIndex& index) {
 	GroupRosterItem* item = dynamic_cast<GroupRosterItem*>(static_cast<RosterItem*>(index.internalPointer()));
 	if (item) {
 		setExpanded(index, !isExpanded(index));
 	}
 	currentChanged(index, QModelIndex());
 }
 
 QModelIndexList QtTreeWidget::getSelectedIndexes() const {
 	// Not using selectedIndexes(), because this seems to cause a crash in Qt (4.7.0) in the
 	// QModelIndexList destructor.
 	// This is a workaround posted in http://www.qtcentre.org/threads/16933 (although this case
 	// was resolved by linking against the debug libs, ours isn't, and we're not alone)
 	QItemSelection ranges = selectionModel()->selection();
 	QModelIndexList selectedIndexList;
 	for (int i = 0; i < ranges.count(); ++i) {
 		QModelIndex parent = ranges.at(i).parent();
 		int right = ranges.at(i).model()->columnCount(parent) - 1;
 		if (ranges.at(i).left() == 0 && ranges.at(i).right() == right) {
 			for (int r = ranges.at(i).top(); r <= ranges.at(i).bottom(); ++r) {
 				selectedIndexList.append(ranges.at(i).model()->index(r, 0, parent));
 			}
 		}
diff --git a/Swift/QtUI/Roster/QtTreeWidget.h b/Swift/QtUI/Roster/QtTreeWidget.h
index 705c039..7c10a6a 100644
--- a/Swift/QtUI/Roster/QtTreeWidget.h
+++ b/Swift/QtUI/Roster/QtTreeWidget.h
@@ -1,61 +1,61 @@
 /*
- * Copyright (c) 2010 Kevin Smith
+ * Copyright (c) 2010-2012 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QTreeView>
 #include <QModelIndex>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QDragMoveEvent>
 #include "Swift/QtUI/Roster/RosterModel.h"
 #include "Swift/QtUI/Roster/RosterDelegate.h"
 
 namespace Swift {
 class UIEventStream;
-class QtUIPreferences;
+class SettingsProvider;
 
 class QtTreeWidget : public QTreeView{
 	Q_OBJECT
 	public:
-		QtTreeWidget(UIEventStream* eventStream, QtUIPreferences* uiPreferences, QWidget* parent = 0);
+		QtTreeWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent = 0);
 		~QtTreeWidget();
 		void show();
 		QtTreeWidgetItem* getRoot();
 		void setRosterModel(Roster* roster);
 		Roster* getRoster() {return roster_;}
 		boost::signal<void (RosterItem*)> onSomethingSelectedChanged;
 
 	private slots:
 		void handleItemActivated(const QModelIndex&);
 		void handleModelItemExpanded(const QModelIndex&, bool expanded);
 		void handleExpanded(const QModelIndex&);
 		void handleCollapsed(const QModelIndex&);
 		void handleClicked(const QModelIndex&);
-		void handleCompactRostersToggled(bool compact);
+		void handleSettingChanged(const std::string& setting);
 	protected:
 		void dragEnterEvent(QDragEnterEvent* event);
 		void dropEvent(QDropEvent* event);
 		void dragMoveEvent(QDragMoveEvent* event);
 
 	protected:
 		QModelIndexList getSelectedIndexes() const;
 	private:
 		void drawBranches(QPainter*, const QRect&, const QModelIndex&) const;
 	protected slots:
 		virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous);
 	protected:
 		UIEventStream* eventStream_;
 
 	private:
 		RosterModel* model_;
 		Roster* roster_;
 		RosterDelegate* delegate_;
 		QtTreeWidgetItem* treeRoot_;
-		QtUIPreferences* uiPreferences_;
+		SettingsProvider* settings_;
 };
 
 }
diff --git a/Swift/QtUI/SConscript b/Swift/QtUI/SConscript
index 2283001..d37958f 100644
--- a/Swift/QtUI/SConscript
+++ b/Swift/QtUI/SConscript
@@ -40,139 +40,139 @@ if myenv.get("HAVE_SNARL", False) :
 	myenv.UseFlags(myenv["SNARL_FLAGS"])
 	myenv.Append(CPPDEFINES = ["HAVE_SNARL"])
 myenv.UseFlags(myenv["PLATFORM_FLAGS"])
 
 myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.Tool("nsis", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.Tool("wix", toolpath = ["#/BuildTools/SCons/Tools"])
 qt4modules = ['QtCore', 'QtGui', 'QtWebKit']
 if env["PLATFORM"] == "posix" :
 	qt4modules += ["QtDBus"]
 myenv.EnableQt4Modules(qt4modules, debug = False)
 
 myenv.Append(CPPPATH = ["."])
 
 if env["PLATFORM"] == "win32" :
   #myenv["LINKFLAGS"] = ["/SUBSYSTEM:CONSOLE"]
   myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])
   myenv.Append(LIBS = "qtmain")
 
 myenv.WriteVal("DefaultTheme.qrc", myenv.Value(generateDefaultTheme(myenv.Dir("#/Swift/resources/themes/Default"))))
 
 sources = [
     "main.cpp",
     "QtAboutWidget.cpp",
     "QtAvatarWidget.cpp",
     "QtUIFactory.cpp",
     "QtChatWindowFactory.cpp",
     "QtChatWindow.cpp",
     "QtClickableLabel.cpp",
     "QtLoginWindow.cpp",
     "QtMainWindow.cpp",
     "QtProfileWindow.cpp",
     "QtNameWidget.cpp",
     "QtSettingsProvider.cpp",
     "QtStatusWidget.cpp",
-		"QtScaledAvatarCache.cpp",
+    "QtScaledAvatarCache.cpp",
     "QtSwift.cpp",
     "QtURIHandler.cpp",
     "QtChatView.cpp",
     "QtChatTheme.cpp",
     "QtChatTabs.cpp",
     "QtSoundPlayer.cpp",
     "QtSystemTray.cpp",
     "QtCachedImageScaler.cpp",
     "QtTabbable.cpp",
     "QtTabWidget.cpp",
     "QtTextEdit.cpp",
     "QtXMLConsoleWidget.cpp",
     "QtFileTransferListWidget.cpp",
     "QtFileTransferListItemModel.cpp",
     "QtAdHocCommandWindow.cpp",
     "QtUtilities.cpp",
     "QtBookmarkDetailWindow.cpp",
     "QtAddBookmarkWindow.cpp",
     "QtEditBookmarkWindow.cpp",
     "QtContactEditWindow.cpp",
     "QtContactEditWidget.cpp",
     "ChatSnippet.cpp",
     "MessageSnippet.cpp",
     "SystemMessageSnippet.cpp",
     "QtElidingLabel.cpp",
     "QtFormWidget.cpp",
-	"QtFormResultItemModel.cpp",
+    "QtFormResultItemModel.cpp",
     "QtLineEdit.cpp",
     "QtJoinMUCWindow.cpp",
     "Roster/RosterModel.cpp",
     "Roster/QtTreeWidget.cpp",
 #    "Roster/QtTreeWidgetItem.cpp",
     "Roster/RosterDelegate.cpp",
     "Roster/GroupItemDelegate.cpp",
     "Roster/DelegateCommons.cpp",
     "Roster/QtRosterWidget.cpp",
     "Roster/QtOccupantListWidget.cpp",
     "EventViewer/EventModel.cpp",
     "EventViewer/EventDelegate.cpp",
     "EventViewer/TwoLineDelegate.cpp",
     "EventViewer/QtEventWindow.cpp",
     "EventViewer/QtEvent.cpp",
     "ChatList/QtChatListWindow.cpp",
     "ChatList/ChatListModel.cpp",
     "ChatList/ChatListDelegate.cpp",
     "ChatList/ChatListMUCItem.cpp",
     "ChatList/ChatListRecentItem.cpp",
     "MUCSearch/QtMUCSearchWindow.cpp",
     "MUCSearch/MUCSearchModel.cpp",
     "MUCSearch/MUCSearchRoomItem.cpp",
     "MUCSearch/MUCSearchEmptyItem.cpp",
     "MUCSearch/MUCSearchDelegate.cpp",
     "UserSearch/QtUserSearchFirstPage.cpp",
     "UserSearch/QtUserSearchFieldsPage.cpp",
     "UserSearch/QtUserSearchResultsPage.cpp",
     "UserSearch/QtUserSearchDetailsPage.cpp",
     "UserSearch/QtUserSearchWindow.cpp",
     "UserSearch/UserSearchModel.cpp",
     "UserSearch/UserSearchDelegate.cpp",
     "QtSubscriptionRequestWindow.cpp",
     "QtRosterHeader.cpp",
     "QtWebView.cpp",
     "qrc_DefaultTheme.cc",
     "qrc_Swift.cc",
     "QtFileTransferJSBridge.cpp",
     "QtMUCConfigurationWindow.cpp",
     "QtAffiliationEditor.cpp",
-    "QtUIPreferences.cpp"
+    "QtUISettingConstants.cpp"
   ]
 
 myenv["SWIFT_VERSION"] = Version.getBuildVersion(env.Dir("#").abspath, "swift")
 
 if env["PLATFORM"] == "win32" :
   res = myenv.RES("#/Swift/resources/Windows/Swift.rc")
   # For some reason, SCons isn't picking up the dependency correctly
 	# Adding it explicitly until i figure out why
   myenv.Depends(res, "../Controllers/BuildVersion.h")
   sources += [
 			"WindowsNotifier.cpp",
 			"#/Swift/resources/Windows/Swift.res"
 		]
 
 if env["PLATFORM"] == "posix" :
 	sources += [
 			"FreeDesktopNotifier.cpp",
 			"QtDBUSURIHandler.cpp",
 	]
 
 if env["PLATFORM"] == "darwin" or env["PLATFORM"] == "win32" :
   swiftProgram = myenv.Program("Swift", sources)
 else :
   swiftProgram = myenv.Program("swift", sources)
 
 if env["PLATFORM"] != "darwin" and env["PLATFORM"] != "win32" :
 	openURIProgram = myenv.Program("swift-open-uri", "swift-open-uri.cpp")
 else :
 	openURIProgram = []
 
 myenv.Uic4("MUCSearch/QtMUCSearchWindow.ui")
 myenv.Uic4("UserSearch/QtUserSearchWizard.ui")
 myenv.Uic4("UserSearch/QtUserSearchFirstPage.ui")
 myenv.Uic4("UserSearch/QtUserSearchFieldsPage.ui")
 myenv.Uic4("UserSearch/QtUserSearchResultsPage.ui")
author	Kevin Smith <git@kismith.co.uk>	2012-02-17 16:57:01 (GMT)
committer	Kevin Smith <git@kismith.co.uk>	2012-02-21 14:34:55 (GMT)
commit	3605b6622bc8b4abb810fac6b53f7f71be0fa7de (patch)
tree	638a8fd6449dd235931fe307e50119adf9c9fe22 /Swift/QtUI
parent	b05f8fcb285d2d13d2be50a3eb1062048fbe30f5 (diff)
download	swift-contrib-3605b6622bc8b4abb810fac6b53f7f71be0fa7de.zip swift-contrib-3605b6622bc8b4abb810fac6b53f7f71be0fa7de.tar.bz2