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

+#include <Boost/bind.hpp>

+

+#include <Swift/QtUI/QtUISettingConstants.h>

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

+

+QtChatListWindow::QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent) : QTreeView(parent) {

+ settings_ = settings;;

+ delegate_ = new ChatListDelegate(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+

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

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

+void QtChatListWindow::handleSettingChanged(const std::string& setting) {

+ if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {

+ delegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ repaint();

+ }

+ class SettingsProvider;

+ QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent = NULL);

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

+ SettingsProvider* settings_;

+ * Copyright (c) 2010-2012 Kevin Smith

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

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

+ treeWidget_ = new QtOccupantListWidget(eventStream_, settings_, this);

+ * Copyright (c) 2010-2012 Kevin Smith

+ class SettingsProvider;

+ QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings);

+ SettingsProvider* settings_;

+QtChatWindowFactory::QtChatWindowFactory(QSplitter* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath) : themePath_(themePath) {

+ qtOnlySettings_ = qtSettings;

+ QVariant chatTabsGeometryVariant = qtOnlySettings_->getQSettings()->value(CHAT_TABS_GEOMETRY);

+ QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), theme_, eventStream, settings_);

+ QVariant splitterState = qtOnlySettings_->getQSettings()->value(SPLITTER_STATE);

+ QVariant chatGeometryVariant = qtOnlySettings_->getQSettings()->value(CHAT_TABS_GEOMETRY);

+ qtOnlySettings_->getQSettings()->setValue(CHAT_TABS_GEOMETRY, qobject_cast<QWidget*>(sender())->saveGeometry());

+ qtOnlySettings_->getQSettings()->setValue(SPLITTER_STATE, QVariant(splitterState));

+ QtChatWindowFactory(QSplitter* splitter, SettingsProvider* settings, QtSettingsProvider* qtSettings, QtChatTabs* tabs, const QString& themePath);

+ SettingsProvider* settings_;

+ QtSettingsProvider* qtOnlySettings_;

+ * Copyright (c) 2010-2012 Kevin Smith

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

+QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings) : QMainWindow(), settings_(settings) {

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

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

+ remember_->setEnabled(!eagle);

+ loginAutomatically_->setEnabled(!eagle);

+ xmlConsoleAction_->setEnabled(!eagle);

+ if (eagle) {

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

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

+ toggleSoundsAction_->setChecked(settings_->getSetting(SettingConstants::PLAY_SOUNDS));

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

+ toggleNotificationsAction_->setChecked(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

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

+ remember_->setEnabled(!eagle);

+ loginAutomatically_->setEnabled(!eagle);

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

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) { /* Mustn't remember logins */

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

+ settings_->storeSetting(SettingConstants::SHOW_NOTIFICATIONS, enabled);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <Swift/Controllers/UIInterfaces/LoginWindow.h>

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

+#include <Swift/Controllers/UIInterfaces/MainWindow.h>

+#include <QtAboutWidget.h>

+ class SettingsProvider;

+ QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings);

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

+ SettingsProvider* settings_;

+#include <Swift/QtUI/QtUISettingConstants.h>

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

+QtMainWindow::QtMainWindow(SettingsProvider* settings, UIEventStream* uiEventStream, QtLoginWindow::QtMenus loginMenus) : QWidget(), MainWindow(false), loginMenus_(loginMenus) {

+ treeWidget_ = new QtRosterWidget(uiEventStream_, settings_, this);

+ chatListWindow_ = new QtChatListWindow(uiEventStream_, settings_);

+ tabs_->setCurrentIndex(settings_->getSetting(QtUISettingConstants::CURRENT_ROSTER_TAB));

+

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

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

+ settings_->storeSetting(QtUISettingConstants::CURRENT_ROSTER_TAB, index);

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

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

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

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

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

+ toggleRequestDeliveryReceipts_->setChecked(settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS));

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

+ class SettingsProvider;

+ QtMainWindow(SettingsProvider*, UIEventStream* eventStream, QtLoginWindow::QtMenus loginMenus);

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

+ SettingsProvider* settings_;

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

+#include <Swift/QtUI/QtUISettingConstants.h>

+QtNameWidget::QtNameWidget(SettingsProvider* settings, QWidget *parent) : QWidget(parent), settings(settings) {

+ mode = settings->getSetting(QtUISettingConstants::SHOW_NICK_IN_ROSTER_HEADER) ? ShowNick : ShowJID;

+ settings->storeSetting(QtUISettingConstants::SHOW_NICK_IN_ROSTER_HEADER, mode == ShowNick);

+ class SettingsProvider;

+ QtNameWidget(SettingsProvider* settings, QWidget *parent);

+ SettingsProvider* settings;

+QtRosterHeader::QtRosterHeader(SettingsProvider* settings, QWidget* parent) : QWidget(parent) {

+ class SettingsProvider;

+ QtRosterHeader(SettingsProvider* settings, QWidget* parent = NULL);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <QtSettingsProvider.h>

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

+ }

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

+ QVariant variant = settings_.value(setting.getKey().c_str());

+ return variant.isNull() ? setting.getDefaultValue() : variant.toBool();

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

+ }

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

+ QVariant variant = settings_.value(setting.getKey().c_str());

+ return variant.isNull() ? setting.getDefaultValue() : variant.toInt();

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

+ }

+bool QtSettingsProvider::getIsSettingFinal(const std::string& /*settingPath*/) {

+ return false;

+}

+

+ * Copyright (c) 2010-2012 Kevin Smith

+#pragma once

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

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

+ protected:

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

+

+ * Copyright (c) 2010-2012 Kevin Smith

+#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 <Swift/Controllers/Storages/FileStoragesFactory.h>

+#include <SwifTools/Application/PlatformApplicationPathProvider.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"

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

+}

+ qtSettings_ = new QtSettingsProvider();

+ xmlSettings_ = loadSettingsFile(P2QSTRING((Paths::getExecutablePath() / "system-settings.xml").string()));

+ settingsHierachy_ = new SettingsProviderHierachy();

+ settingsHierachy_->addProviderToTopOfStack(xmlSettings_);

+ settingsHierachy_->addProviderToTopOfStack(qtSettings_);

+

+ chatWindowFactory_ = new QtChatWindowFactory(splitter_, settingsHierachy_, qtSettings_, tabs_, "");

+ QtUIFactory* uiFactory = new QtUIFactory(settingsHierachy_, qtSettings_, tabs_, splitter_, systemTrays_[i], chatWindowFactory_, startMinimized);

+ settingsHierachy_,

+ options.count("latency-debug") > 0);

+ delete settingsHierachy_;

+ delete qtSettings_;

+ delete xmlSettings_;

+ * Copyright (c) 2010-2012 Kevin Smith

+ class SettingsProviderHierachy;

+ class XMLSettingsProvider;

+ XMLSettingsProvider* loadSettingsFile(const QString& fileName);

+ private:

+ QtSettingsProvider* qtSettings_;

+ XMLSettingsProvider* xmlSettings_;

+ SettingsProviderHierachy* settingsHierachy_;

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

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

+#include <Swift/QtUI/QtUISettingConstants.h>

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

+ lastMainWindow = new QtMainWindow(settings, eventStream, loginWindow->getMenus());

+ loginWindow = new QtLoginWindow(eventStream, settings);

+ QVariant loginWindowGeometryVariant = qtOnlySettings->getQSettings()->value("loginWindowGeometry");

+ qtOnlySettings->getQSettings()->setValue("loginWindowGeometry", loginWindow->saveGeometry());

+ settings->storeSetting(QtUISettingConstants::CHATWINDOW_FONT_SIZE, size);

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

+ class SettingsProviderHierachy;

+ QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized);

+ SettingsProviderHierachy* settings;

+ QtSettingsProvider* qtOnlySettings;

+/*

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

+}

+/*

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

+ };

+}

+ * Copyright (c) 2011-2012 Kevin Smith

+QtOccupantListWidget::QtOccupantListWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent) : QtTreeWidget(eventStream, settings, parent) {

+ * Copyright (c) 2011-2012 Kevin Smith

+class SettingsProvider;

+ QtOccupantListWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent = 0);

+QtRosterWidget::QtRosterWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent) : QtTreeWidget(eventStream, settings, parent) {

+ QtRosterWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent = 0);

+ * Copyright (c) 2010-2012 Kevin Smith

+#include <boost/bind.hpp>

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

+#include <Swift/QtUI/QtUISettingConstants.h>

+QtTreeWidget::QtTreeWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent) : QTreeView(parent) {

+ settings_ = settings;

+ delegate_ = new RosterDelegate(this, settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+

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

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

+void QtTreeWidget::handleSettingChanged(const std::string& setting) {

+ if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {

+ delegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ repaint();

+ }

+ * Copyright (c) 2010-2012 Kevin Smith

+class SettingsProvider;

+ QtTreeWidget(UIEventStream* eventStream, SettingsProvider* settings, QWidget* parent = 0);

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

+ SettingsProvider* settings_;

+ "QtScaledAvatarCache.cpp",

+ "QtFormResultItemModel.cpp",

+ "QtUISettingConstants.cpp"