+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+#include <boost/shared_ptr.hpp>

+

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

+#include <Swiften/Queries/IQRouter.h>

+#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

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

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

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

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

+

+namespace Swift {

+

+AdHocManager::AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow) : jid_(jid) {

+ iqRouter_ = iqRouter;

+ uiEventStream_ = uiEventStream;

+ mainWindow_ = mainWindow;

+ factory_ = factory;

+

+ uiEventStream_->onUIEvent.connect(boost::bind(&AdHocManager::handleUIEvent, this, _1));

+}

+

+AdHocManager::~AdHocManager() {

+ uiEventStream_->onUIEvent.disconnect(boost::bind(&AdHocManager::handleUIEvent, this, _1));

+}

+

+void AdHocManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {

+ if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::CommandsFeature)) {

+ if (discoItemsRequest_) {

+ discoItemsRequest_->onResponse.disconnect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

+ discoItemsRequest_.reset();

+ }

+ discoItemsRequest_ = GetDiscoItemsRequest::create(JID(jid_.getDomain()), DiscoInfo::CommandsFeature, iqRouter_);

+ discoItemsRequest_->onResponse.connect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

+ discoItemsRequest_->send();

+ } else {

+ mainWindow_->setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

+ }

+

+}

+

+void AdHocManager::handleServerDiscoItemsResponse(boost::shared_ptr<DiscoItems> items, ErrorPayload::ref error) {

+ std::vector<DiscoItems::Item> commands;

+ if (!error) {

+ foreach (DiscoItems::Item item, items->getItems()) {

+ if (item.getNode() != "http://isode.com/xmpp/commands#test") {

+ commands.push_back(item);

+ }

+ }

+ }

+ mainWindow_->setAvailableAdHocCommands(commands);

+}

+

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

+ boost::shared_ptr<RequestAdHocUIEvent> adHocEvent = boost::dynamic_pointer_cast<RequestAdHocUIEvent>(event);

+ if (adHocEvent) {

+ factory_->createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession>(new OutgoingAdHocCommandSession(adHocEvent->getCommand(), factory_, iqRouter_)));

+ }

+}

+

+}

+/*

+ * 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 <boost/shared_ptr.hpp>

+#include <vector>

+

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

+#include <Swiften/JID/JID.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Elements/DiscoItems.h>

+#include <Swiften/Elements/ErrorPayload.h>

+#include <Swiften/Disco/GetDiscoItemsRequest.h>

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

+

+namespace Swift {

+ class IQRouter;

+ class MainWindow;

+ class UIEventStream;

+ class AdHocCommandWindowFactory;

+ class AdHocManager {

+ public:

+ AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow);

+ ~AdHocManager();

+ void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

+ private:

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

+ void handleServerDiscoItemsResponse(boost::shared_ptr<DiscoItems>, ErrorPayload::ref error);

+ JID jid_;

+ IQRouter* iqRouter_;

+ UIEventStream* uiEventStream_;

+ MainWindow* mainWindow_;

+ AdHocCommandWindowFactory* factory_;

+ GetDiscoItemsRequest::ref discoItemsRequest_;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <Swift/Controllers/Storages/CertificateStorageFactory.h>

+#include <Swift/Controllers/Storages/CertificateMemoryStorage.h>

+

+namespace Swift {

+ class CertificateFactory;

+

+ class CertificateMemoryStorageFactory : public CertificateStorageFactory {

+ public:

+ CertificateMemoryStorageFactory() {

+ }

+

+ virtual CertificateStorage* createCertificateStorage(const JID&) const {

+ return new CertificateMemoryStorage();

+ }

+

+ private:

+ boost::filesystem::path basePath;

+ CertificateFactory* certificateFactory;

+ };

+}

+ if (stanzaChannel_->getStreamManagementEnabled() && !id.empty()) {

+ std::map<boost::shared_ptr<Stanza>, std::string>::iterator unackedStanza = unackedStanzas_.find(stanza);

+ if (unackedStanza != unackedStanzas_.end()) {

+ chatWindow_->setAckState(unackedStanza->second, ChatWindow::Received);

+ unackedStanzas_.erase(unackedStanza);

+ * Copyright (c) 2010-2011 Kevin Smith

+ onActivity(message->getBody());

+ onActivity(body);

+ /** Used for determining when something is recent.*/

+ boost::signal<void (const std::string& /*activity*/)> onActivity;

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

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

+#define RECENT_CHATS "recent_chats"

+

+ ProfileSettingsProvider* settings) :

+ profileSettings_ = settings;

+ loadRecents();

+void ChatsManager::saveRecents() {

+ std::string recents;

+ foreach (ChatListWindow::Chat chat, recentChats_) {

+ std::vector<std::string> activity;

+ boost::split(activity, chat.activity, boost::is_any_of("\t\n"));

+ std::string recent = chat.jid.toString() + "\t" + activity[0] + "\t" + (chat.isMUC ? "true" : "false") + "\t" + chat.nick;

+ recents += recent + "\n";

+ }

+ profileSettings_->storeString(RECENT_CHATS, recents);

+}

+

+void ChatsManager::loadRecents() {

+ std::string recentsString(profileSettings_->getStringSetting(RECENT_CHATS));

+ std::vector<std::string> recents;

+ boost::split(recents, recentsString, boost::is_any_of("\n"));

+ int i = 0;

+ foreach (std::string recentString, recents) {

+ if (i++ > 30) {

+ break;

+ }

+ std::vector<std::string> recent;

+ boost::split(recent, recentString, boost::is_any_of("\t"));

+ if (recent.size() < 4) {

+ continue;

+ }

+ JID jid(recent[0]);

+ if (!jid.isValid()) {

+ continue;

+ }

+ std::string activity(recent[1]);

+ bool isMUC = recent[2] == "true";

+ std::string nick(recent[3]);

+ ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, isMUC, nick);

+ recentChats_.push_back(chat);

+ chatListWindow_->setRecents(recentChats_);

+ }

+}

+

+ chatListWindow_->clearBookmarks();

+void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity) {

+ /* FIXME: MUC use requires changes here. */

+ ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, false);

+ /* FIXME: handle nick changes */

+ recentChats_.erase(std::remove(recentChats_.begin(), recentChats_.end(), chat), recentChats_.end());

+ recentChats_.push_front(chat);

+ chatListWindow_->setRecents(recentChats_);

+ saveRecents();

+}

+

+ else if (boost::shared_ptr<RequestJoinMUCUIEvent> joinEvent = boost::dynamic_pointer_cast<RequestJoinMUCUIEvent>(event)) {

+ joinMUCWindow_->setMUC(joinEvent->getRoom());

+ controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, contact, _1));

+ /* FIXME: handleChatActivity connection for recents, and changes to that method.*/

+ * Copyright (c) 2010-2011 Kevin Smith

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Elements/Message.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/MUC/MUCRegistry.h>

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

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

+#include <Swiften/MUC/MUCBookmark.h>

+ class ProfileSettingsProvider;

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

+ void handleChatActivity(const JID& jid, const std::string& activity);

+ void loadRecents();

+ void saveRecents();

+ void handleChatMadeRecent();

+ std::list<ChatListWindow::Chat> recentChats_;

+ ProfileSettingsProvider* profileSettings_;

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

+#include <Swiften/Network/Timer.h>

+#include <Swiften/Network/TimerFactory.h>

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

+#include <SwifTools/TabComplete.h>

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

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

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

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

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

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

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

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swiften/Elements/Delay.h>

+#include <Swiften/MUC/MUC.h>

+#include <Swiften/Client/StanzaChannel.h>

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

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

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

+ std::string groupName(roleToGroupName(occupant.getRole()));

+ roster_->addContact(jid, realJID, occupant.getNick(), groupName, avatarManager_->getAvatarPath(jid).string());

+ if (addedRosterGroups_.count(groupName) == 0) {

+ roster_->getGroup(groupName)->setManualSort(roleToSortName(occupant.getRole()));

+ addedRosterGroups_.insert(groupName);

+ }

+std::string MUCController::roleToSortName(MUCOccupant::Role role) {

+ switch (role) {

+ case MUCOccupant::Moderator: return "1";

+ case MUCOccupant::Participant: return "2";

+ case MUCOccupant::Visitor: return "3";

+ case MUCOccupant::NoRole: return "4";

+ }

+ return "5";

+}

+

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

+#include <Swiften/Network/Timer.h>

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

+#include <Swiften/Elements/Message.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/MUC/MUC.h>

+#include <Swiften/Elements/MUCOccupant.h>

+ std::string roleToSortName(MUCOccupant::Role role);

+ std::set<std::string> addedRosterGroups_;

+ * Copyright (c) 2010-2011 Kevin Smith

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

+MUCSearchController::MUCSearchController(const JID& jid, MUCSearchWindowFactory* factory, IQRouter* iqRouter, ProfileSettingsProvider* settings) : jid_(jid), factory_(factory), iqRouter_(iqRouter), settings_(settings), window_(NULL), walker_(NULL) {

+ * Copyright (c) 2010-2011 Kevin Smith

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

+ MUCSearchController(const JID& jid, MUCSearchWindowFactory* mucSearchWindowFactory, IQRouter* iqRouter, ProfileSettingsProvider* settings);

+ ProfileSettingsProvider* settings_;

+ * Copyright (c) 2010-2011 Kevin Smith

+#include "Swift/Controllers/Chat/UnitTest/MockChatListWindow.h"

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

+ profileSettings_ = new ProfileSettingsProvider("a", settings_);

+ chatListWindow_ = new MockChatListWindow();

+ mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);

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

+ delete profileSettings_;

+ delete chatListWindow_;

+ ProfileSettingsProvider* profileSettings_;

+ ChatListWindow* chatListWindow_;

+/*

+ * 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/Controllers/UIInterfaces/ChatListWindow.h"

+

+namespace Swift {

+

+ class MockChatListWindow : public ChatListWindow {

+ public:

+ MockChatListWindow() {};

+ virtual ~MockChatListWindow() {};

+ void addMUCBookmark(const MUCBookmark& /*bookmark*/) {}

+ void removeMUCBookmark(const MUCBookmark& /*bookmark*/) {}

+ void setBookmarksEnabled(bool /*enabled*/) {}

+ void setRecents(const std::list<ChatListWindow::Chat>& /*recents*/) {}

+ void clearBookmarks() {}

+ };

+

+}

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

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

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

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

+

+using namespace Swift;

+using namespace std;

+

+string ChatMessageSummarizer::getSummary(const string& current, const vector<UnreadPair>& unreads) {

+ vector<UnreadPair> others;

+ int currentUnread = 0;

+ int otherCount = 0;

+ foreach (UnreadPair unread, unreads) {

+ if (unread.first == current) {

+ currentUnread += unread.second;

+ } else {

+ if (unread.second > 0) {

+ otherCount += unread.second;

+ others.push_back(unread);

+ }

+ }

+ }

+ string myString(current);

+

+ if (currentUnread > 0) {

+ string result(QT_TRANSLATE_NOOP("", "%1% (%2%)"));

+ myString = str(format(result) % current % currentUnread);

+ }

+

+ if (others.size() > 1) {

+ string result(QT_TRANSLATE_NOOP("", "%1% and %2% others (%3%)"));

+ myString = str(format(result) % myString % others.size() % otherCount);

+ } else if (others.size() > 0) {

+ string result(QT_TRANSLATE_NOOP("", "%1%, %2% (%3%)"));

+ myString = str(format(result) % myString % others[0].first % otherCount);

+ }

+ return myString;

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <vector>

+#include <utility>

+#include <string>

+

+namespace Swift {

+typedef std::pair<std::string, int> UnreadPair;

+

+ class ChatMessageSummarizer {

+ public:

+ std::string getSummary(const std::string& current, const std::vector<UnreadPair>& unreads);

+ };

+}

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

+ * Copyright (c) 2010-2011 Kevin Smith

+#include "Swift/Controllers/Storages/StoragesFactory.h"

+#include "Swift/Controllers/Storages/CertificateStorageFactory.h"

+#include "Swift/Controllers/Storages/CertificateStorageTrustChecker.h"

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

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

+ URIHandler* uriHandler,

+ uriHandler_(uriHandler),

+ xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

+

+ delete xmppURIController_;

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

+ adHocManager_ = new AdHocManager(boundJID_, uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());

+ GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(boundJID_.toBare(), client_->getIQRouter());

+ if (!jid_.isValid() || jid_.getNode().empty()) {

+ loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'alice@wonderland.lit'"));

+ loginWindow_->setIsLoggingIn(false);

+ } else {

+ loginWindow_->setMessage("");

+ loginWindow_->setIsLoggingIn(true);

+ profileSettings_ = new ProfileSettingsProvider(username, settings_);

+ profileSettings_->storeString("jid", username);

+ profileSettings_->storeString("certificate", certificateFile);

+ profileSettings_->storeString("pass", (remember || loginAutomatically) ? password : "");

+ settings_->storeString("lastLoginJID", username);

+ settings_->storeBool("loginAutomatically", loginAutomatically);

+ loginWindow_->addAvailableAccount(profileSettings_->getStringSetting("jid"), profileSettings_->getStringSetting("pass"), profileSettings_->getStringSetting("certificate"));

+

+ password_ = password;

+ certificateFile_ = certificateFile;

+ performLoginFromCachedCredentials();

+ }

+ loginWindow_->setIsLoggingIn(false);

+ else if (!rosterController_) { //hasn't been logged in yet

+ loginWindow_->setIsLoggingIn(false);

+ }

+ adHocManager_->setServerDiscoInfo(info);

+ * Copyright (c) 2010-2011 Kevin Smith

+ class URIHandler;

+ class XMPPURIController;

+ class AdHocManager;

+ class AdHocCommandWindowFactory;

+ URIHandler* uriHandler,

+ URIHandler* uriHandler_;

+ AdHocManager* adHocManager_;

+ XMPPURIController* xmppURIController_;

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

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

+

+GroupRosterItem::GroupRosterItem(const std::string& name, GroupRosterItem* parent, bool sortByStatus) : RosterItem(name, parent), sortByStatus_(sortByStatus), manualSort_(false) {

+void GroupRosterItem::setManualSort(const std::string& manualSortValue) {

+ manualSort_ = true;

+ bool changed = manualSortValue_ != manualSortValue;

+ manualSortValue_ = manualSortValue;

+ if (changed) {

+ onDataChanged();

+ }

+}

+

+const std::string& GroupRosterItem::getSortableDisplayName() const {

+ return manualSort_ ? manualSortValue_ : RosterItem::getSortableDisplayName();

+}

+

+ void setManualSort(const std::string& manualSortValue);

+ virtual const std::string& getSortableDisplayName() const;

+ bool manualSort_;

+ std::string manualSortValue_;

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

+const std::string& RosterItem::getDisplayName() const {

+const std::string& RosterItem::getSortableDisplayName() const {

+ const std::string& getDisplayName() const;

+ virtual const std::string& getSortableDisplayName() const;

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

+ "AdHocManager.cpp",

+ "Storages/CertificateStorageFactory.cpp",

+ "Storages/CertificateStorage.cpp",

+ "Storages/CertificateFileStorage.cpp",

+ "Storages/CertificateMemoryStorage.cpp",

+ "Storages/AvatarFileStorage.cpp",

+ "Storages/FileStorages.cpp",

+ "Storages/RosterFileStorage.cpp",

+ "Storages/CapsFileStorage.cpp",

+ "Storages/VCardFileStorage.cpp",

+ "XMPPURIController.cpp",

+ "ChatMessageSummarizer.cpp",

+ File("UnitTest/ChatMessageSummarizerTest.cpp"),

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swift/Controllers/Storages/AvatarFileStorage.h>

+

+#include <iostream>

+#include <boost/filesystem/fstream.hpp>

+#include <boost/filesystem.hpp>

+

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

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

+#include <Swiften/StringCodecs/SHA1.h>

+#include <Swiften/StringCodecs/Hexify.h>

+

+namespace Swift {

+

+AvatarFileStorage::AvatarFileStorage(const boost::filesystem::path& avatarsDir, const boost::filesystem::path& avatarsFile) : avatarsDir(avatarsDir), avatarsFile(avatarsFile) {

+ if (boost::filesystem::exists(avatarsFile)) {

+ try {

+ boost::filesystem::ifstream file(avatarsFile);

+ std::string line;

+ if (file.is_open()) {

+ while (!file.eof()) {

+ getline(file, line);

+ std::pair<std::string, std::string> r = String::getSplittedAtFirst(line, ' ');

+ JID jid(r.second);

+ if (jid.isValid()) {

+ jidAvatars.insert(std::make_pair(jid, r.first));

+ }

+ else if (!r.first.empty() || !r.second.empty()) {

+ std::cerr << "Invalid entry in avatars file: " << r.second << std::endl;

+ }

+ }

+ }

+ }

+ catch (...) {

+ std::cerr << "Error reading avatars file" << std::endl;

+ }

+ }

+}

+

+bool AvatarFileStorage::hasAvatar(const std::string& hash) const {

+ return boost::filesystem::exists(getAvatarPath(hash));

+}

+

+void AvatarFileStorage::addAvatar(const std::string& hash, const ByteArray& avatar) {

+ assert(Hexify::hexify(SHA1::getHash(avatar)) == hash);

+

+ boost::filesystem::path avatarPath = getAvatarPath(hash);

+ if (!boost::filesystem::exists(avatarPath.parent_path())) {

+ try {

+ boost::filesystem::create_directories(avatarPath.parent_path());

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ std::cerr << "ERROR: " << e.what() << std::endl;

+ }

+ }

+ boost::filesystem::ofstream file(avatarPath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);

+ file.write(reinterpret_cast<const char*>(avatar.getData()), static_cast<std::streamsize>(avatar.getSize()));

+ file.close();

+}

+

+boost::filesystem::path AvatarFileStorage::getAvatarPath(const std::string& hash) const {

+ return avatarsDir / hash;

+}

+

+ByteArray AvatarFileStorage::getAvatar(const std::string& hash) const {

+ ByteArray data;

+ data.readFromFile(getAvatarPath(hash).string());

+ return data;

+}

+

+void AvatarFileStorage::setAvatarForJID(const JID& jid, const std::string& hash) {

+ std::pair<JIDAvatarMap::iterator, bool> r = jidAvatars.insert(std::make_pair(jid, hash));

+ if (r.second) {

+ saveJIDAvatars();

+ }

+ else if (r.first->second != hash) {

+ r.first->second = hash;

+ saveJIDAvatars();

+ }

+}

+

+std::string AvatarFileStorage::getAvatarForJID(const JID& jid) const {

+ JIDAvatarMap::const_iterator i = jidAvatars.find(jid);

+ return i == jidAvatars.end() ? "" : i->second;

+}

+

+void AvatarFileStorage::saveJIDAvatars() {

+ try {

+ boost::filesystem::ofstream file(avatarsFile);

+ for (JIDAvatarMap::const_iterator i = jidAvatars.begin(); i != jidAvatars.end(); ++i) {

+ file << i->second << " " << i->first.toString() << std::endl;

+ }

+ file.close();

+ }

+ catch (...) {

+ std::cerr << "Error writing avatars file" << std::endl;

+ }

+}

+

+}

+/*

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

+#include <string>

+#include <boost/filesystem/path.hpp>

+

+#include <Swiften/JID/JID.h>

+#include "Swiften/Base/ByteArray.h"

+#include "Swiften/Avatars/AvatarStorage.h"

+

+namespace Swift {

+ class AvatarFileStorage : public AvatarStorage {

+ public:

+ AvatarFileStorage(const boost::filesystem::path& avatarsDir, const boost::filesystem::path& avatarsFile);

+

+ virtual bool hasAvatar(const std::string& hash) const;

+ virtual void addAvatar(const std::string& hash, const ByteArray& avatar);

+ virtual ByteArray getAvatar(const std::string& hash) const;

+

+ virtual boost::filesystem::path getAvatarPath(const std::string& hash) const;

+

+ virtual void setAvatarForJID(const JID& jid, const std::string& hash);

+ virtual std::string getAvatarForJID(const JID& jid) const;

+

+ private:

+ void saveJIDAvatars();

+

+ private:

+ boost::filesystem::path avatarsDir;

+ boost::filesystem::path avatarsFile;

+ typedef std::map<JID, std::string> JIDAvatarMap;

+ JIDAvatarMap jidAvatars;

+ };

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swift/Controllers/Storages/CapsFileStorage.h"

+

+#include <Swiften/Entity/GenericPayloadPersister.h>

+#include "Swiften/Serializer/PayloadSerializers/DiscoInfoSerializer.h"

+#include "Swiften/Parser/PayloadParsers/DiscoInfoParser.h"

+#include "Swiften/StringCodecs/Hexify.h"

+#include "Swiften/StringCodecs/Base64.h"

+

+using namespace Swift;

+

+typedef GenericPayloadPersister<DiscoInfo, DiscoInfoParser, DiscoInfoSerializer> DiscoInfoPersister;

+

+CapsFileStorage::CapsFileStorage(const boost::filesystem::path& path) : path(path) {

+}

+

+DiscoInfo::ref CapsFileStorage::getDiscoInfo(const std::string& hash) const {

+ return DiscoInfoPersister().loadPayloadGeneric(getCapsPath(hash));

+}

+

+void CapsFileStorage::setDiscoInfo(const std::string& hash, DiscoInfo::ref discoInfo) {

+ DiscoInfo::ref bareDiscoInfo(new DiscoInfo(*discoInfo.get()));

+ bareDiscoInfo->setNode("");

+ DiscoInfoPersister().savePayload(bareDiscoInfo, getCapsPath(hash));

+}

+

+boost::filesystem::path CapsFileStorage::getCapsPath(const std::string& hash) const {

+ return path / (Hexify::hexify(Base64::decode(hash)) + ".xml");

+}

+/*

+ * 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 <boost/filesystem/path.hpp>

+

+#include "Swiften/Disco/CapsStorage.h"

+#include <string>

+

+namespace Swift {

+ class CapsFileStorage : public CapsStorage {

+ public:

+ CapsFileStorage(const boost::filesystem::path& path);

+

+ virtual DiscoInfo::ref getDiscoInfo(const std::string& hash) const;

+ virtual void setDiscoInfo(const std::string& hash, DiscoInfo::ref discoInfo);

+

+ private:

+ boost::filesystem::path getCapsPath(const std::string& hash) const;

+

+ private:

+ boost::filesystem::path path;

+ };

+}

+#include <Swift/Controllers/Storages/CertificateFileStorage.h>

+#include "Swift/Controllers/Storages/CertificateStorage.h"

+#include <Swift/Controllers/Storages/CertificateStorageFactory.h>

+#include <Swift/Controllers/Storages/CertificateFileStorage.h>

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swift/Controllers/Storages/CertificateMemoryStorage.h>

+

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

+

+using namespace Swift;

+

+CertificateMemoryStorage::CertificateMemoryStorage() {

+}

+

+bool CertificateMemoryStorage::hasCertificate(Certificate::ref certificate) const {

+ foreach(Certificate::ref storedCert, certificates) {

+ if (storedCert->toDER() == certificate->toDER()) {

+ return true;

+ }

+ }

+ return false;

+}

+

+void CertificateMemoryStorage::addCertificate(Certificate::ref certificate) {

+ certificates.push_back(certificate);

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <vector>

+

+#include <Swift/Controllers/Storages/CertificateStorage.h>

+

+namespace Swift {

+ class CertificateMemoryStorage : public CertificateStorage {

+ public:

+ CertificateMemoryStorage();

+

+ virtual bool hasCertificate(Certificate::ref certificate) const;

+ virtual void addCertificate(Certificate::ref certificate);

+

+ private:

+ std::vector<Certificate::ref> certificates;

+ };

+

+}

+#include "Swift/Controllers/Storages/CertificateStorage.h"

+#include <Swift/Controllers/Storages/CertificateStorageFactory.h>

+#include <Swift/Controllers/Storages/CertificateStorage.h>

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swift/Controllers/Storages/FileStorages.h"

+#include "Swift/Controllers/Storages/VCardFileStorage.h"

+#include "Swift/Controllers/Storages/AvatarFileStorage.h"

+#include "Swift/Controllers/Storages/CapsFileStorage.h"

+#include "Swift/Controllers/Storages/RosterFileStorage.h"

+

+namespace Swift {

+

+FileStorages::FileStorages(const boost::filesystem::path& baseDir, const JID& jid) {

+ std::string profile = jid.toBare();

+ vcardStorage = new VCardFileStorage(baseDir / profile / "vcards");

+ capsStorage = new CapsFileStorage(baseDir / "caps");

+ avatarStorage = new AvatarFileStorage(baseDir / "avatars", baseDir / profile / "avatars");

+ rosterStorage = new RosterFileStorage(baseDir / profile / "roster.xml");

+}

+

+FileStorages::~FileStorages() {

+ delete rosterStorage;

+ delete avatarStorage;

+ delete capsStorage;

+ delete vcardStorage;

+}

+

+VCardStorage* FileStorages::getVCardStorage() const {

+ return vcardStorage;

+}

+

+CapsStorage* FileStorages::getCapsStorage() const {

+ return capsStorage;

+}

+

+AvatarStorage* FileStorages::getAvatarStorage() const {

+ return avatarStorage;

+}

+

+RosterStorage* FileStorages::getRosterStorage() const {

+ return rosterStorage;

+}

+

+}

+/*

+ * 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 <boost/filesystem/path.hpp>

+

+#include "Swiften/Client/Storages.h"

+

+namespace Swift {

+ class VCardFileStorage;

+ class AvatarFileStorage;

+ class CapsFileStorage;

+ class RosterFileStorage;

+ class JID;

+

+ /**

+ * A storages implementation that stores all controller data on disk.

+ */

+ class FileStorages : public Storages {

+ public:

+ /**

+ * Creates the storages interface.

+ *

+ * All data will be stored relative to a base directory, and

+ * for some controllers, in a subdirectory for the given profile.

+ * The data is stored in the following places:

+ * - Avatars: <basedir>/avatars

+ * - VCards: <basedir>/<profile>/vcards

+ * - Entity capabilities: <basedir>/caps

+ *

+ * \param baseDir the base dir to store data relative to

+ * \param jid the subdir in which profile-specific data will be stored.

+ * The bare JID will be used as the subdir name.

+ */

+ FileStorages(const boost::filesystem::path& baseDir, const JID& jid);

+ ~FileStorages();

+

+ virtual VCardStorage* getVCardStorage() const;

+ virtual AvatarStorage* getAvatarStorage() const;

+ virtual CapsStorage* getCapsStorage() const;

+ virtual RosterStorage* getRosterStorage() const;

+

+ private:

+ VCardFileStorage* vcardStorage;

+ AvatarFileStorage* avatarStorage;

+ CapsFileStorage* capsStorage;

+ RosterFileStorage* rosterStorage;

+ };

+}

+#include "Swift/Controllers/Storages/StoragesFactory.h"

+#include "Swift/Controllers/Storages/FileStorages.h"

+#include "Swift/Controllers/Storages/StoragesFactory.h"

+ class JID;

+

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swift/Controllers/Storages/RosterFileStorage.h>

+

+#include <Swiften/Entity/GenericPayloadPersister.h>

+#include <Swiften/Serializer/PayloadSerializers/RosterSerializer.h>

+#include <Swiften/Parser/PayloadParsers/RosterParser.h>

+

+using namespace Swift;

+

+typedef GenericPayloadPersister<RosterPayload, RosterParser, RosterSerializer> RosterPersister;

+

+RosterFileStorage::RosterFileStorage(const boost::filesystem::path& path) : path(path) {

+}

+

+boost::shared_ptr<RosterPayload> RosterFileStorage::getRoster() const {

+ return RosterPersister().loadPayloadGeneric(path);

+}

+

+void RosterFileStorage::setRoster(boost::shared_ptr<RosterPayload> roster) {

+ RosterPersister().savePayload(roster, path);

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/filesystem/path.hpp>

+

+#include <Swiften/Roster/RosterStorage.h>

+

+namespace Swift {

+ class RosterFileStorage : public RosterStorage {

+ public:

+ RosterFileStorage(const boost::filesystem::path& path);

+

+ virtual boost::shared_ptr<RosterPayload> getRoster() const;

+ virtual void setRoster(boost::shared_ptr<RosterPayload>);

+

+ private:

+ boost::filesystem::path path;

+ };

+}

+ class JID;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swift/Controllers/Storages/VCardFileStorage.h"

+

+#include <boost/filesystem/fstream.hpp>

+#include <boost/filesystem.hpp>

+#include <iostream>

+

+#include <Swiften/Entity/GenericPayloadPersister.h>

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

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/StringCodecs/SHA1.h>

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

+#include "Swiften/JID/JID.h"

+#include "Swiften/Elements/VCard.h"

+#include "Swiften/Serializer/PayloadSerializers/VCardSerializer.h"

+#include "Swiften/Parser/PayloadParsers/UnitTest/PayloadParserTester.h"

+#include "Swiften/Parser/PayloadParsers/VCardParser.h"

+

+using namespace Swift;

+

+typedef GenericPayloadPersister<VCard, VCardParser, VCardSerializer> VCardPersister;

+

+VCardFileStorage::VCardFileStorage(boost::filesystem::path dir) : vcardsPath(dir) {

+ cacheFile = vcardsPath / "phashes";

+ if (boost::filesystem::exists(cacheFile)) {

+ try {

+ boost::filesystem::ifstream file(cacheFile);

+ std::string line;

+ if (file.is_open()) {

+ while (!file.eof()) {

+ getline(file, line);

+ std::pair<std::string, std::string> r = String::getSplittedAtFirst(line, ' ');

+ JID jid(r.second);

+ if (jid.isValid()) {

+ photoHashes.insert(std::make_pair(jid, r.first));

+ }

+ else if (!r.first.empty() || !r.second.empty()) {

+ std::cerr << "Invalid entry in phashes file" << std::endl;

+ }

+ }

+ }

+ }

+ catch (...) {

+ std::cerr << "Error reading phashes file" << std::endl;

+ }

+ }

+}

+

+boost::shared_ptr<VCard> VCardFileStorage::getVCard(const JID& jid) const {

+ return VCardPersister().loadPayloadGeneric(getVCardPath(jid));

+}

+

+void VCardFileStorage::setVCard(const JID& jid, VCard::ref v) {

+ VCardPersister().savePayload(v, getVCardPath(jid));

+ getAndUpdatePhotoHash(jid, v);

+}

+

+boost::filesystem::path VCardFileStorage::getVCardPath(const JID& jid) const {

+ std::string file(jid.toString());

+ String::replaceAll(file, '/', "%2f");

+ return boost::filesystem::path(vcardsPath / (file + ".xml"));

+}

+

+std::string VCardFileStorage::getPhotoHash(const JID& jid) const {

+ PhotoHashMap::const_iterator i = photoHashes.find(jid);

+ if (i != photoHashes.end()) {

+ return i->second;

+ }

+ else {

+ VCard::ref vCard = getVCard(jid);

+ return getAndUpdatePhotoHash(jid, vCard);

+ }

+}

+

+std::string VCardFileStorage::getAndUpdatePhotoHash(const JID& jid, VCard::ref vCard) const {

+ std::string hash;

+ if (vCard && !vCard->getPhoto().isEmpty()) {

+ hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

+ }

+ std::pair<PhotoHashMap::iterator, bool> r = photoHashes.insert(std::make_pair(jid, hash));

+ if (r.second) {

+ savePhotoHashes();

+ }

+ else if (r.first->second != hash) {

+ r.first->second = hash;

+ savePhotoHashes();

+ }

+ return hash;

+}

+

+void VCardFileStorage::savePhotoHashes() const {

+ try {

+ boost::filesystem::ofstream file(cacheFile);

+ for (PhotoHashMap::const_iterator i = photoHashes.begin(); i != photoHashes.end(); ++i) {

+ file << i->second << " " << i->first.toString() << std::endl;

+ }

+ file.close();

+ }

+ catch (...) {

+ std::cerr << "Error writing vcards file" << std::endl;

+ }

+}

+/*

+ * 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 <boost/shared_ptr.hpp>

+#include <boost/filesystem/path.hpp>

+#include <string>

+#include <map>

+

+#include "Swiften/VCards/VCardStorage.h"

+

+namespace Swift {

+ class VCardFileStorage : public VCardStorage {

+ public:

+ VCardFileStorage(boost::filesystem::path dir);

+

+ virtual VCard::ref getVCard(const JID& jid) const;

+ virtual void setVCard(const JID& jid, VCard::ref v);

+

+ virtual std::string getPhotoHash(const JID&) const;

+

+ private:

+ boost::filesystem::path getVCardPath(const JID&) const;

+

+ std::string getAndUpdatePhotoHash(const JID& jid, VCard::ref vcard) const;

+ void savePhotoHashes() const;

+

+ private:

+ boost::filesystem::path vcardsPath;

+ boost::filesystem::path cacheFile;

+ typedef std::map<JID, std::string> PhotoHashMap;

+ mutable PhotoHashMap photoHashes;

+ };

+}

+/*

+ * 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/MainWindow.h>

+

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

+

+namespace Swift {

+ class RequestAdHocUIEvent : public UIEvent {

+ public:

+ RequestAdHocUIEvent(const DiscoItems::Item& command) : command_(command) {};

+ const DiscoItems::Item& getCommand() const {return command_;}

+ private:

+ DiscoItems::Item command_;

+ };

+}

+

+#include <Swiften/JID/JID.h>

+ RequestJoinMUCUIEvent(const JID& room = JID()) : room(room) {

+

+ const JID& getRoom() const {

+ return room;

+ }

+

+ private:

+ JID room;

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+namespace Swift {

+ class AdHocCommandWindow {

+ public:

+ virtual ~AdHocCommandWindow() {};

+ };

+}

+/*

+ * 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 <Swift/Controllers/UIInterfaces/AdHocCommandWindow.h>

+#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

+

+namespace Swift {

+ class AdHocCommandWindowFactory {

+ public:

+ virtual ~AdHocCommandWindowFactory() {}

+ /**

+ * The UI should deal with the lifetime of this window (i.e. DeleteOnClose),

+ * so the result isn't returned.

+ */

+ virtual void createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) = 0;

+ };

+}

+ * Copyright (c) 2010-2011 Kevin Smith

+#include <list>

+#include <Swiften/MUC/MUCBookmark.h>

+ class Chat {

+ public:

+ Chat(const JID& jid, const std::string& chatName, const std::string& activity, bool isMUC, const std::string& nick = "") : jid(jid), chatName(chatName), activity(activity), isMUC(isMUC), nick(nick) {}

+ /** Assume that nicks aren't important for equality */

+ bool operator==(const Chat& other) const {return jid == other.jid && isMUC == other.isMUC;};

+ JID jid;

+ std::string chatName;

+ std::string activity;

+ bool isMUC;

+ std::string nick;

+ };

+ virtual void setRecents(const std::list<Chat>& recents) = 0;

+ virtual void clearBookmarks() = 0;

+#include "Swiften/Elements/DiscoItems.h"

+ virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) = 0;

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

+ public ContactEditWindowFactory,

+ public AdHocCommandWindowFactory {

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

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

+

+using namespace Swift;

+using namespace std;

+

+class ChatMessageSummarizerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ChatMessageSummarizerTest);

+ CPPUNIT_TEST(testEmpty);

+ CPPUNIT_TEST(testCurrentNone);

+ CPPUNIT_TEST(testCurrentCount);

+ CPPUNIT_TEST(testCurrentCountOthersNone);

+ CPPUNIT_TEST(testCurrentCountOtherCount);

+ CPPUNIT_TEST(testCurrentNoneOtherCount);

+ CPPUNIT_TEST(testCurrentCountOthersCount);

+ CPPUNIT_TEST(testCurrentNoneOthersCount);

+ CPPUNIT_TEST(testCurrentCountSomeOthersCount);

+ CPPUNIT_TEST_SUITE_END();

+

+public:

+ ChatMessageSummarizerTest() {};

+

+ void setUp() {

+

+ }

+

+ void testEmpty() {

+ string current("");

+ vector<UnreadPair> unreads;

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));

+ }

+

+ void testCurrentNone() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bob", 0));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bob", 3));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountOthersNone() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 0));

+ unreads.push_back(UnreadPair("Bob", 3));

+ unreads.push_back(UnreadPair("Betty", 0));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountOtherCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 0));

+ unreads.push_back(UnreadPair("Bob", 3));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (3), Betty (7)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentNoneOtherCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 0));

+ unreads.push_back(UnreadPair("Bob", 0));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob, Betty (7)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentNoneOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 2));

+ unreads.push_back(UnreadPair("Bob", 0));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob and 2 others (9)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 2));

+ unreads.push_back(UnreadPair("Bob", 11));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountSomeOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 2));

+ unreads.push_back(UnreadPair("Beverly", 0));

+ unreads.push_back(UnreadPair("Bob", 11));

+ unreads.push_back(UnreadPair("Beatrice", 0));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));

+ }

+

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ChatMessageSummarizerTest);

+ virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {};

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

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <SwifTools/URIHandler/URIHandler.h>

+#include <SwifTools/URIHandler/XMPPURI.h>

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

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

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

+

+using namespace Swift;

+

+XMPPURIController::XMPPURIController(URIHandler* uriHandler, UIEventStream* uiEventStream) : uriHandler(uriHandler), uiEventStream(uiEventStream) {

+ uriHandler->onURI.connect(boost::bind(&XMPPURIController::handleURI, this, _1));

+}

+

+XMPPURIController::~XMPPURIController() {

+ uriHandler->onURI.disconnect(boost::bind(&XMPPURIController::handleURI, this, _1));

+}

+

+void XMPPURIController::handleURI(const std::string& s) {

+ XMPPURI uri = XMPPURI::fromString(s);

+ if (!uri.isNull()) {

+ if (uri.getQueryType() == "join") {

+ uiEventStream->send(boost::make_shared<RequestJoinMUCUIEvent>(uri.getPath()));

+ }

+ else {

+ uiEventStream->send(boost::make_shared<RequestChatUIEvent>(uri.getPath()));

+ }

+ }

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

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

+

+namespace Swift {

+ class URIHandler;

+ class JID;

+ class UIEventStream;

+

+ class XMPPURIController {

+ public:

+ XMPPURIController(URIHandler* uriHandler, UIEventStream* uiEventStream);

+ ~XMPPURIController();

+

+ boost::signal<void (const JID&)> onStartChat;

+ boost::signal<void (const JID&)> onJoinMUC;

+

+ private:

+ void handleURI(const std::string&);

+

+ private:

+ URIHandler* uriHandler;

+ UIEventStream* uiEventStream;

+ };

+}