+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/SettingConstants.h>

+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider), eventStream_(eventStream), userWantsReceipts_(userWantsReceipts), settings_(settings) {

+

+ settings_->onSettingChanged.connect(boost::bind(&ChatController::handleSettingChanged, this, _1));

+ settings_->onSettingChanged.disconnect(boost::bind(&ChatController::handleSettingChanged, this, _1));

+void ChatController::handleSettingChanged(const std::string& settingPath) {

+ if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

+ userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/Chat/ChatControllerBase.h>

+ class SettingsProvider;

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings);

+ void handleSettingChanged(const std::string& settingPath);

+ SettingsProvider* settings_;

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/SettingConstants.h>

+ ProfileSettingsProvider* profileSettings,

+ bool eagleMode,

+ SettingsProvider* settings) :

+ eagleMode_(eagleMode),

+ settings_(settings) {

+ profileSettings_ = profileSettings;

+ mucSearchController_ = new MUCSearchController(jid_, mucSearchWindowFactory, iqRouter, profileSettings_);

+

+ settings_->onSettingChanged.connect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));

+

+ settings_->onSettingChanged.disconnect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));

+void ChatsManager::handleSettingChanged(const std::string& settingPath) {

+ if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

+ userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

+ return;

+ }

+}

+

+

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_);

+ class SettingsProvider;

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* settings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings);

+ void handleSettingChanged(const std::string& settingPath);

+ SettingsProvider* settings_;

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/SettingConstants.h>

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_);

+ delete settings_;

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/SettingConstants.h>

+ SettingsProvider* settings,

+ bool useDelayForLatency) :

+ soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings);

+ std::string selectedLoginJID = settings_->getSetting(SettingConstants::LAST_LOGIN_JID);

+ bool loginAutomatically = settings_->getSetting(SettingConstants::LOGIN_AUTOMATICALLY);

+ bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

+ if (!eagle) {

+ std::string password = profileSettings.getStringSetting("pass");

+ idleDetector_->setIdleTimeSeconds(settings->getSetting(SettingConstants::IDLE_TIMEOUT));

+ settings_->onSettingChanged.connect(boost::bind(&MainController::handleSettingChanged, this, _1));

+void MainController::handleSettingChanged(const std::string& settingPath) {

+ if (settingPath == SettingConstants::SHOW_NOTIFICATIONS.getKey()) {

+ notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_);

+

+ if (settings_->getSetting(SettingConstants::IDLE_GOES_OFFLINE)) {

+ if (idle) {

+ logout();

+ }

+ else {

+ if (idle) {

+ if (statusTracker_->goAutoAway()) {

+ if (client_ && client_->isAvailable()) {

+ sendPresence(statusTracker_->getNextPresence());

+ }

+ }

+ } else {

+ if (statusTracker_->goAutoUnAway()) {

+ if (client_ && client_->isAvailable()) {

+ sendPresence(statusTracker_->getNextPresence());

+ }

+ if (!settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ settings_->storeSetting(SettingConstants::LAST_LOGIN_JID, username);

+ settings_->storeSetting(SettingConstants::LOGIN_AUTOMATICALLY, loginAutomatically);

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS) && password_.empty()) {

+ bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

+ clientOptions.forgetPassword = eagle;

+ clientOptions.useTLS = eagle ? ClientOptions::RequireTLS : ClientOptions::UseTLSWhenAvailable;

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ * Copyright (c) 2010-2012 Kevin Smith

+ bool useDelayForLatency);

+ void handleSettingChanged(const std::string& settingPath);

+/*

+ * Copyright (c) 2010-2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swift/Controllers/ProfileSettingsProvider.h"

+

+namespace Swift {

+

+ProfileSettingsProvider::ProfileSettingsProvider(const std::string& profile, SettingsProvider* provider) :

+ profile_(profile) {

+ provider_ = provider;

+ bool found = false;

+ foreach (std::string existingProfile, provider->getAvailableProfiles()) {

+ if (existingProfile == profile) {

+ found = true;

+ }

+ }

+ if (!found) {

+ provider_->createProfile(profile);

+ }

+}

+

+ProfileSettingsProvider::~ProfileSettingsProvider() {

+}

+

+std::string ProfileSettingsProvider::getStringSetting(const std::string &settingPath) {

+ //FIXME: Remove shim

+ SettingsProvider::Setting<std::string> setting(profileSettingPath(settingPath), "");

+ return provider_->getSetting(setting);

+}

+

+void ProfileSettingsProvider::storeString(const std::string &settingPath, const std::string &settingValue) {

+ //FIXME: Remove shim

+ if (!getIsSettingFinal(settingPath)) {

+ SettingsProvider::Setting<std::string> setting(profileSettingPath(settingPath), "");

+ provider_->storeSetting(setting, settingValue);

+ }

+}

+

+int ProfileSettingsProvider::getIntSetting(const std::string& settingPath, int defaultValue) {

+ //FIXME: Remove shim

+ SettingsProvider::Setting<int> setting(profileSettingPath(settingPath), defaultValue);

+ return provider_->getSetting(setting);

+}

+void ProfileSettingsProvider::storeInt(const std::string& settingPath, int settingValue) {

+ //FIXME: Remove shim

+ if (!getIsSettingFinal(settingPath)) {

+ SettingsProvider::Setting<int> setting(profileSettingPath(settingPath), 0);

+ provider_->storeSetting(setting, settingValue);

+ }

+}

+

+bool ProfileSettingsProvider::getIsSettingFinal(const std::string& settingPath) {

+ //FIXME: Remove shim

+ SettingsProvider::Setting<int> setting(settingPath, 0);

+ return provider_->getIsSettingFinal(setting);

+}

+

+

+std::string ProfileSettingsProvider::profileSettingPath(const std::string &settingPath) {

+ return profile_ + ":" + settingPath;

+}

+

+

+}

+

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+ ProfileSettingsProvider(const std::string& profile, SettingsProvider* provider);

+ virtual ~ProfileSettingsProvider();

+ virtual std::string getStringSetting(const std::string &settingPath);

+ virtual void storeString(const std::string &settingPath, const std::string &settingValue);

+ virtual int getIntSetting(const std::string& settingPath, int defaultValue);

+ virtual void storeInt(const std::string& settingPath, int settingValue);

+ /** See @SettingsProvider::getIsSettingFinal for discussion of what this means.*/

+ virtual bool getIsSettingFinal(const std::string& settingPath);

+ std::string profileSettingPath(const std::string &settingPath);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/SettingConstants.h>

+ settings_->onSettingChanged.connect(boost::bind(&RosterController::handleSettingChanged, this, _1));

+

+ settings_->onSettingChanged.disconnect(boost::bind(&RosterController::handleSettingChanged, this, _1));

+ if (state != settings_->getSetting(SettingConstants::SHOW_OFFLINE)) {

+ settings_->storeSetting(SettingConstants::SHOW_OFFLINE, state);

+void RosterController::handleSettingChanged(const std::string& settingPath) {

+ if (settingPath == SettingConstants::SHOW_OFFLINE.getKey()) {

+ handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));

+}

+

+void RosterController::handleUIEvent(boost::shared_ptr<UIEvent> event) {

+ if (boost::shared_ptr<AddContactUIEvent> addContactEvent = boost::dynamic_pointer_cast<AddContactUIEvent>(event)) {

+ void handleSettingChanged(const std::string& settingPath);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/Roster/RosterGroupExpandinessPersister.h>

+#include <Swiften/Base/String.h>

+#include <Swift/Controllers/Roster/GroupRosterItem.h>

+#include <Swift/Controllers/SettingConstants.h>

+ settings_->storeSetting(SettingConstants::EXPANDED_ROSTER_GROUPS, setting);

+ std::string saved = settings_->getSetting(SettingConstants::EXPANDED_ROSTER_GROUPS);

+

+ * Copyright (c) 2010-2012 Kevin Smith

+ "ProfileSettingsProvider.cpp",

+ "Settings/SettingsProviderHierachy.cpp",

+ "Settings/XMLSettingsProvider.cpp",

+ "SettingConstants.cpp"

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <Swift/Controllers/SettingConstants.h>

+

+namespace Swift {

+

+const SettingsProvider::Setting<bool> SettingConstants::IDLE_GOES_OFFLINE = SettingsProvider::Setting<bool>("idleGoesOffline", false);

+const SettingsProvider::Setting<int> SettingConstants::IDLE_TIMEOUT = SettingsProvider::Setting<int>("idleTimeout", 600);

+const SettingsProvider::Setting<bool> SettingConstants::SHOW_NOTIFICATIONS = SettingsProvider::Setting<bool>("showNotifications", true);

+const SettingsProvider::Setting<bool> SettingConstants::REQUEST_DELIVERYRECEIPTS = SettingsProvider::Setting<bool>("requestDeliveryReceipts", false);

+const SettingsProvider::Setting<bool> SettingConstants::FORGET_PASSWORDS = SettingsProvider::Setting<bool>("forgetPasswords", false);

+const SettingsProvider::Setting<bool> SettingConstants::REMEMBER_RECENT_CHATS = SettingsProvider::Setting<bool>("rememberRecentChats", true);

+const SettingsProvider::Setting<std::string> SettingConstants::LAST_LOGIN_JID = SettingsProvider::Setting<std::string>("lastLoginJID", "");

+const SettingsProvider::Setting<bool> SettingConstants::LOGIN_AUTOMATICALLY = SettingsProvider::Setting<bool>("loginAutomatically", false);

+const SettingsProvider::Setting<bool> SettingConstants::SHOW_OFFLINE("showOffline", false);

+const SettingsProvider::Setting<std::string> SettingConstants::EXPANDED_ROSTER_GROUPS("GroupExpandiness", "");

+const SettingsProvider::Setting<bool> SettingConstants::PLAY_SOUNDS("playSounds", true);

+}

+/*

+ * 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 SettingConstants {

+ public:

+ static const SettingsProvider::Setting<bool> IDLE_GOES_OFFLINE;

+ static const SettingsProvider::Setting<int> IDLE_TIMEOUT;

+ static const SettingsProvider::Setting<bool> SHOW_NOTIFICATIONS;

+ static const SettingsProvider::Setting<bool> REQUEST_DELIVERYRECEIPTS;

+ static const SettingsProvider::Setting<bool> FORGET_PASSWORDS;

+ static const SettingsProvider::Setting<bool> REMEMBER_RECENT_CHATS;

+ static const SettingsProvider::Setting<std::string> LAST_LOGIN_JID;

+ static const SettingsProvider::Setting<bool> LOGIN_AUTOMATICALLY;

+ static const SettingsProvider::Setting<bool> SHOW_OFFLINE;

+ static const SettingsProvider::Setting<std::string> EXPANDED_ROSTER_GROUPS;

+ static const SettingsProvider::Setting<bool> PLAY_SOUNDS;

+ };

+}

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+

+#include <map>

+ virtual std::string getSetting(const Setting<std::string>& setting) {

+ return stringValues.find(setting.getKey()) != stringValues.end() ? stringValues[setting.getKey()] : setting.getDefaultValue();

+ };

+ virtual void storeSetting(const Setting<std::string>& setting, const std::string& value) {

+ stringValues[setting.getKey()] = value;

+ onSettingChanged(setting.getKey());

+ };

+ virtual bool getSetting(const Setting<bool>& setting) {

+ return boolValues.find(setting.getKey()) != boolValues.end() ? boolValues[setting.getKey()] : setting.getDefaultValue();

+ };

+ virtual void storeSetting(const Setting<bool>& setting, const bool& value) {

+ boolValues[setting.getKey()] = value;

+ onSettingChanged(setting.getKey());

+ };

+ virtual int getSetting(const Setting<int>& setting) {

+ return intValues.find(setting.getKey()) != intValues.end() ? intValues[setting.getKey()] : setting.getDefaultValue();

+ };

+ virtual void storeSetting(const Setting<int>& setting, const int& value) {

+ intValues[setting.getKey()] = value;

+ onSettingChanged(setting.getKey());

+ };

+ virtual bool getIsSettingFinal(const std::string& ) {return false;}

+ private:

+ std::map<std::string, std::string> stringValues;

+ std::map<std::string, int> intValues;

+ std::map<std::string, bool> boolValues;

+ * Copyright (c) 2010-2012 Remko Tronçon

+#pragma once

+#include <Swiften/Base/boost_bsignals.h>

+#include <string>

+

+ public:

+ template <typename T>

+ class Setting {

+ public:

+ Setting(const std::string& key, const T& defaultValue) : key(key), defaultValue(defaultValue) {

+

+ }

+

+ const std::string& getKey() const {

+ return key;

+ }

+

+ const T& getDefaultValue() const {

+ return defaultValue;

+ }

+

+ private:

+ std::string key;

+ T defaultValue;

+ };

+

+ virtual std::string getSetting(const Setting<std::string>& setting) = 0;

+ virtual void storeSetting(const Setting<std::string>& setting, const std::string& value) = 0;

+ virtual bool getSetting(const Setting<bool>& setting) = 0;

+ virtual void storeSetting(const Setting<bool>& setting, const bool& value) = 0;

+ virtual int getSetting(const Setting<int>& setting) = 0;

+ virtual void storeSetting(const Setting<int>& setting, const int& value) = 0;

+

+ /** A final setting is one that this settings provider says may not be overriden by lower priority profiles.

+ * e.g. An Administrator-set configuration to disallow saving user passwords could not be overridden by the user.

+ */

+ template<typename T>

+ bool getIsSettingFinal(const Setting<T>& setting) {

+ return getIsSettingFinal(setting.getKey());

+ }

+

+ friend class SettingsProviderHierachy;

+ protected:

+ virtual bool getIsSettingFinal(const std::string& settingPath) = 0;

+

+ public:

+ /**

+ * Emitted when a setting is changed.

+ */

+ boost::signal<void (const std::string& /*Setting's Path*/)> onSettingChanged;

+

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/Log.h>

+namespace Swift {

+

+SettingsProviderHierachy::~SettingsProviderHierachy() {

+}

+

+std::string SettingsProviderHierachy::getSetting(const Setting<std::string>& setting) {

+ foreach (SettingsProvider* provider, providers_) {

+ std::string providerSetting = provider->getSetting(setting);

+ if (providerSetting != setting.getDefaultValue()) {

+ return providerSetting;

+ }

+ }

+ return setting.getDefaultValue();

+}

+

+void SettingsProviderHierachy::storeSetting(const Setting<std::string>& setting, const std::string& settingValue) {

+ if (!getIsSettingFinal(setting.getKey())) {

+ getWritableProvider()->storeSetting(setting, settingValue);

+ }

+}

+

+bool SettingsProviderHierachy::getSetting(const Setting<bool>& setting) {

+ foreach (SettingsProvider* provider, providers_) {

+ bool providerSetting = provider->getSetting(setting);

+ if (providerSetting != setting.getDefaultValue()) {

+ return providerSetting;

+ }

+ }

+ return setting.getDefaultValue();

+}

+

+void SettingsProviderHierachy::storeSetting(const Setting<bool>& setting, const bool& settingValue) {

+ if (!getIsSettingFinal(setting.getKey())) {

+ getWritableProvider()->storeSetting(setting, settingValue);

+ }

+}

+

+int SettingsProviderHierachy::getSetting(const Setting<int>& setting) {

+ foreach (SettingsProvider* provider, providers_) {

+ int providerSetting = provider->getSetting(setting);

+ if (providerSetting != setting.getDefaultValue()) {

+ return providerSetting;

+ }

+ }

+ return setting.getDefaultValue();

+}

+

+void SettingsProviderHierachy::storeSetting(const Setting<int>& setting, const int& settingValue) {

+ if (!getIsSettingFinal(setting.getKey())) {

+ getWritableProvider()->storeSetting(setting, settingValue);

+ }

+}

+

+std::vector<std::string> SettingsProviderHierachy::getAvailableProfiles() {

+ /* Always pull profiles from the topmost */

+ return getWritableProvider()->getAvailableProfiles();

+}

+

+void SettingsProviderHierachy::createProfile(const std::string& profile) {

+ return getWritableProvider()->createProfile(profile);

+}

+

+void SettingsProviderHierachy::removeProfile(const std::string& profile) {

+ return getWritableProvider()->removeProfile(profile);

+}

+

+bool SettingsProviderHierachy::getIsSettingFinal(const std::string& settingPath) {

+ bool isFinal = false;

+ foreach (SettingsProvider* provider, providers_) {

+ isFinal |= provider->getIsSettingFinal(settingPath);

+ }

+ return isFinal;

+}

+

+SettingsProvider* SettingsProviderHierachy::getWritableProvider() {

+ return providers_.back();

+}

+

+void SettingsProviderHierachy::addProviderToTopOfStack(SettingsProvider* provider) {

+ providers_.push_back(provider);

+ provider->onSettingChanged.connect(onSettingChanged);

+}

+

+}

+

+/*

+ * 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 SettingsProviderHierachy : public SettingsProvider {

+ public:

+ virtual ~SettingsProviderHierachy();

+ 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);

+ protected:

+ virtual bool getIsSettingFinal(const std::string& settingPath);

+

+ public:

+ /**

+ * Adds a provider less significant than any already added.

+ * This means that if an existing provider has a setting, this provider won't be asked.

+ * Any settings will be pushed into the topmost (least significant) provider.

+ * Does not take ownership of provider.

+ */

+ void addProviderToTopOfStack(SettingsProvider* provider);

+ private:

+ SettingsProvider* getWritableProvider();

+ private:

+ /* Start/Left is most significant (lowest), left overrides right.*/

+ std::vector<SettingsProvider*> providers_;

+};

+

+}

+

+

+

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <Swift/Controllers/Settings/XMLSettingsProvider.h>

+

+#include <boost/lexical_cast.hpp>

+#include <boost/algorithm/string.hpp>

+

+#include <Swiften/Parser/PlatformXMLParserFactory.h>

+#include <Swiften/Parser/XMLParser.h>

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+XMLSettingsProvider::XMLSettingsProvider(const std::string& xmlConfig) : level_(0) {

+ if (!xmlConfig.empty()) {

+ PlatformXMLParserFactory factory;

+ XMLParser* parser = factory.createXMLParser(this);

+ if (parser->parse(xmlConfig)) {

+ SWIFT_LOG(debug) << "Found and parsed system config" << std::endl;

+ }

+ else {

+ SWIFT_LOG(debug) << "Found invalid system config" << std::endl;

+ }

+ delete parser;

+ }

+ else {

+ SWIFT_LOG(debug) << "No system config found" << std::endl;

+ }

+}

+

+XMLSettingsProvider::~XMLSettingsProvider() {

+

+}

+

+std::string XMLSettingsProvider::getSetting(const Setting<std::string>& setting) {

+ if (values_.find(setting.getKey()) != values_.end()) {

+ std::string value = values_[setting.getKey()];

+ return value;

+ }

+ return setting.getDefaultValue();

+}

+

+void XMLSettingsProvider::storeSetting(const Setting<std::string>& /*settingPath*/, const std::string& /*settingValue*/) {

+ assert(false);

+}

+

+bool XMLSettingsProvider::getSetting(const Setting<bool>& setting) {

+ if (values_.find(setting.getKey()) != values_.end()) {

+ std::string value = values_[setting.getKey()];

+ return boost::iequals(value, "true") || value == "1";

+ }

+ return setting.getDefaultValue();

+}

+

+void XMLSettingsProvider::storeSetting(const Setting<bool>& /*settingPath*/, const bool& /*settingValue*/) {

+ assert(false);

+}

+

+int XMLSettingsProvider::getSetting(const Setting<int>& setting) {

+ if (values_.find(setting.getKey()) != values_.end()) {

+ std::string value = values_[setting.getKey()];

+ try {

+ return value.empty() ? setting.getDefaultValue() : boost::lexical_cast<int>(value);;

+ }

+ catch(boost::bad_lexical_cast &) {}

+ }

+ return setting.getDefaultValue();

+}

+

+void XMLSettingsProvider::storeSetting(const Setting<int>& /*settingPath*/, const int& /*settingValue*/) {

+ assert(false);

+}

+

+std::vector<std::string> XMLSettingsProvider::getAvailableProfiles() {

+ assert(false);

+}

+

+void XMLSettingsProvider::createProfile(const std::string& /*profile*/) {

+ assert(false);

+}

+

+void XMLSettingsProvider::removeProfile(const std::string& /*profile*/) {

+ assert(false);

+}

+

+bool XMLSettingsProvider::getIsSettingFinal(const std::string& settingPath) {

+ return finals_.count(settingPath);

+}

+

+void XMLSettingsProvider::handleStartElement(const std::string& element, const std::string& /*ns*/, const AttributeMap& attributes) {

+ level_++;

+ if (level_ == SettingLevel) {

+ if (attributes.getBoolAttribute("final", false)) {

+ finals_.insert(element);

+ }

+ currentElement_ = element;

+ currentText_ = "";

+ }

+}

+

+void XMLSettingsProvider::handleEndElement(const std::string& /*element*/, const std::string& /*ns*/) {

+ if (level_ == SettingLevel) {

+ values_[currentElement_] = currentText_;

+ SWIFT_LOG(debug) << "Setting value of " << currentElement_ << " to " << currentText_ << std::endl;

+ }

+ level_--;

+}

+

+void XMLSettingsProvider::handleCharacterData(const std::string& data) {

+ if (level_ >= SettingLevel) {

+ currentText_ += data;

+ }

+}

+

+

+}

+

+

+

+

+/*

+ * 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>

+#include <Swiften/Parser/XMLParserClient.h>

+

+#include <map>

+#include <set>

+

+namespace Swift {

+

+class XMLSettingsProvider : public SettingsProvider, public XMLParserClient {

+ public:

+ XMLSettingsProvider(const std::string& xmlConfig);

+ virtual ~XMLSettingsProvider();

+ 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);

+

+ virtual void handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes);

+ virtual void handleEndElement(const std::string& element, const std::string& ns);

+ virtual void handleCharacterData(const std::string& data);

+

+ protected:

+ virtual bool getIsSettingFinal(const std::string& settingPath);

+ private:

+ std::map<std::string /*settingPath*/, std::string /*settingValue*/> values_;

+ /* Settings that are final*/

+ std::set<std::string /*settingPath*/> finals_;

+

+ enum Level {

+ TopLevel = 0,

+ SettingLevel = 2

+ };

+

+ int level_;

+ std::string currentElement_;

+ std::string currentText_;

+};

+

+}

+

+

+

+

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/SoundEventController.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+#include <Swift/Controllers/SoundPlayer.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/SettingConstants.h>

+SoundEventController::SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, SettingsProvider* settings) {

+ settings_->onSettingChanged.connect(boost::bind(&SoundEventController::handleSettingChanged, this, _1));

+ playSounds_ = settings->getSetting(SettingConstants::PLAY_SOUNDS);

+ settings_->storeSetting(SettingConstants::PLAY_SOUNDS, playSounds);

+void SoundEventController::handleSettingChanged(const std::string& settingPath) {

+ if (SettingConstants::PLAY_SOUNDS.getKey() == settingPath) {

+ playSounds_ = settings_->getSetting(SettingConstants::PLAY_SOUNDS);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/XMPPEvents/StanzaEvent.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+ SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, SettingsProvider* settings);

+ void handleSettingChanged(const std::string& settingPath);