+/*

+ * 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 <boost/smart_ptr/make_shared.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::make_shared<OutgoingAdHocCommandSession>(adHocEvent->getCommand().getJID(), adHocEvent->getCommand().getNode(), 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;

+ };

+}

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

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

+#include <Swiften/Chat/ChatStateNotifier.h>

+#include <Swiften/Chat/ChatStateTracker.h>

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

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

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

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

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

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

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider) {

+ handleBareJIDCapsChanged(toJID_);

+void ChatController::handleBareJIDCapsChanged(const JID& /*jid*/) {

+ DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_);

+ if (disco) {

+ if (disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

+ chatWindow_->setCorrectionEnabled(ChatWindow::Yes);

+ } else {

+ chatWindow_->setCorrectionEnabled(ChatWindow::No);

+ }

+ } else {

+ chatWindow_->setCorrectionEnabled(ChatWindow::Maybe);

+ }

+}

+

+ handleBareJIDCapsChanged(toJID_);

+ chatStateNotifier_->receivedMessageFromContact(message->getPayload<ChatState>());

+ boost::shared_ptr<Replace> replace = sentStanza->getPayload<Replace>();

+ if (replace) {

+ eraseIf(unackedStanzas_, PairSecondEquals<boost::shared_ptr<Stanza>, std::string>(myLastMessageUIID_));

+ chatWindow_->replaceMessage(body, myLastMessageUIID_, boost::posix_time::microsec_clock::universal_time());

+ } else {

+ myLastMessageUIID_ = addMessage(body, QT_TRANSLATE_NOOP("", "me"), true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel().getLabel() : boost::shared_ptr<SecurityLabel>(), std::string(avatarManager_->getAvatarPath(selfJID_).string()), boost::posix_time::microsec_clock::universal_time());

+ }

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

+ chatWindow_->setAckState(myLastMessageUIID_, ChatWindow::Pending);

+ unackedStanzas_[sentStanza] = myLastMessageUIID_;

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

+ for ( ; it != unackedStanzas_.end(); ++it) {

+ void handleBareJIDCapsChanged(const JID& jid);

+ std::string myLastMessageUIID_;

+ * Copyright (c) 2010-2011 Kevin Smith

+#include <map>

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

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider) {

+ chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

+ entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));

+void ChatControllerBase::handleCapsChanged(const JID& jid) {

+ if (jid.compare(toJID_, JID::WithoutResource) == 0) {

+ handleBareJIDCapsChanged(jid);

+ }

+}

+

+ onUnreadCountChanged();

+}

+

+int ChatControllerBase::getUnreadCount() {

+ return unreadMessages_.size();

+void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool isCorrectionMessage) {

+ if (isCorrectionMessage) {

+ message->addPayload(boost::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

+ }

+ message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

+ onActivity(message->getBody());

+ std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

+ if (!delayPayloads[i]->getFrom()) {

+ onActivity(body);

+ boost::shared_ptr<Replace> replace = message->getPayload<Replace>();

+ if (replace) {

+ std::string body = message->getBody();

+ // Should check if the user has a previous message

+ std::map<JID, std::string>::iterator lastMessage;

+ lastMessage = lastMessagesUIID_.find(from);

+ if (lastMessage != lastMessagesUIID_.end()) {

+ chatWindow_->replaceMessage(body, lastMessagesUIID_[from], timeStamp);

+ }

+ }

+ else {

+ lastMessagesUIID_[from] = addMessage(body, senderDisplayNameFromMessage(from), isIncomingMessageFromMe(message), label, std::string(avatarManager_->getAvatarPath(from).string()), timeStamp);

+ }

+ onUnreadCountChanged();

+#pragma once

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

+ class EntityCapsProvider;

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

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

+ boost::signal<void ()> onUnreadCountChanged;

+ int getUnreadCount();

+ const JID& getToJID() {return toJID_;}

+ void handleCapsChanged(const JID& jid);

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider);

+ virtual void handleBareJIDCapsChanged(const JID& jid) = 0;

+ IDGenerator idGenerator_;

+ std::string lastSentMessageStanzaID_;

+ void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);

+ std::map<JID, std::string> lastMessagesUIID_;

+ EntityCapsProvider* entityCapsProvider_;

+ * Copyright (c) 2010-2011 Kevin Smith

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

+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+#define RECENT_CHATS "recent_chats"

+

+ ProfileSettingsProvider* settings) :

+ profileSettings_ = settings;

+

+ chatListWindow_->onMUCBookmarkActivated.connect(boost::bind(&ChatsManager::handleMUCBookmarkActivated, this, _1));

+ chatListWindow_->onRecentActivated.connect(boost::bind(&ChatsManager::handleRecentActivated, this, _1));

+

+ loadRecents();

+void ChatsManager::saveRecents() {

+ std::string recents;

+ int i = 1;

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

+ if (i++ > 25) {

+ break;

+ }

+ }

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

+ StatusShow::Type type = StatusShow::None;

+ boost::filesystem::path path;

+ if (isMUC) {

+ if (mucControllers_.find(jid.toBare()) != mucControllers_.end()) {

+ type = StatusShow::Online;

+ }

+ } else {

+ if (avatarManager_) {

+ path = avatarManager_->getAvatarPath(jid);

+ }

+ Presence::ref presence = presenceOracle_->getHighestPriorityPresence(jid.toBare());

+ type = presence ? presence->getShow() : StatusShow::None;

+ }

+

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

+ prependRecent(chat);

+ }

+ handleUnreadCountChanged(NULL);

+}

+

+ chatListWindow_->clearBookmarks();

+ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity) {

+ int unreadCount = 0;

+ if (mucRegistry_->isMUC(jid)) {

+ MUCController* controller = mucControllers_[jid.toBare()];

+ StatusShow::Type type = StatusShow::None;

+ std::string nick = "";

+ if (controller) {

+ unreadCount = controller->getUnreadCount();

+ if (controller->isJoined()) {

+ type = StatusShow::Online;

+ }

+ nick = controller->getNick();

+ }

+ return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick);

+

+ } else {

+ ChatController* controller = getChatControllerIfExists(jid, false);

+ if (controller) {

+ unreadCount = controller->getUnreadCount();

+ }

+ JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

+ Presence::ref presence = presenceOracle_->getHighestPriorityPresence(bareishJID);

+ StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

+ boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

+ return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false);

+ }

+}

+

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

+ if (mucRegistry_->isMUC(jid.toBare()) && !isMUC) {

+ /* Don't include PMs in MUC rooms.*/

+ return;

+ }

+ ChatListWindow::Chat chat = createChatListChatItem(jid, activity);

+ /* FIXME: handle nick changes */

+ appendRecent(chat);

+ handleUnreadCountChanged(NULL);

+ saveRecents();

+}

+

+void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {

+ int unreadTotal = 0;

+ bool controllerIsMUC = dynamic_cast<MUCController*>(controller);

+ bool isPM = controller && !controllerIsMUC && mucRegistry_->isMUC(controller->getToJID().toBare());

+ foreach (ChatListWindow::Chat& chatItem, recentChats_) {

+ bool match = false;

+ if (controller) {

+ /* Matching MUC item */

+ match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

+ /* Matching PM */

+ match |= isPM && chatItem.jid == controller->getToJID();

+ /* Matching non-PM */

+ match |= !isPM && !controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

+ }

+ if (match) {

+ chatItem.setUnreadCount(controller->getUnreadCount());

+ }

+ unreadTotal += chatItem.unreadCount;

+ }

+ chatListWindow_->setRecents(recentChats_);

+ chatListWindow_->setUnreadCount(unreadTotal);

+}

+

+void ChatsManager::appendRecent(const ChatListWindow::Chat& chat) {

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

+ recentChats_.push_front(chat);

+}

+

+void ChatsManager::prependRecent(const ChatListWindow::Chat& chat) {

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

+ recentChats_.push_back(chat);

+}

+

+ for (it = mucControllers_.begin(); it != mucControllers_.end(); ++it) {

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

+ if (chat.isMUC && chat.jid == (*it).first) {

+ chat.statusType = StatusShow::None;

+ chatListWindow_->setRecents(recentChats_);

+ break;

+ }

+ }

+ handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getNick(), joinEvent->getShouldJoinAutomatically());

+ mucControllers_[joinEvent->getJID()]->activateChatWindow();

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

+ joinMUCWindow_ = joinMUCWindowFactory_->createJoinMUCWindow(uiEventStream_);

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

+

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

+ if (newPresence->getFrom().toBare() == chat.jid.toBare() && !chat.isMUC) {

+ Presence::ref presence = presenceOracle_->getHighestPriorityPresence(chat.jid.toBare());

+ chat.setStatusType(presence ? presence->getShow() : StatusShow::None);

+ chatListWindow_->setRecents(recentChats_);

+ break;

+ }

+ }

+

+ if (avatarManager_) {

+ avatarManager_->onAvatarChanged.disconnect(boost::bind(&ChatsManager::handleAvatarChanged, this, _1));

+ }

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

+ if (!chat.isMUC) {

+ chat.setAvatarPath(avatarManager_->getAvatarPath(chat.jid));

+ }

+ }

+ avatarManager_->onAvatarChanged.connect(boost::bind(&ChatsManager::handleAvatarChanged, this, _1));

+}

+

+void ChatsManager::handleAvatarChanged(const JID& jid) {

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

+ if (!chat.isMUC && jid.toBare() == chat.jid.toBare()) {

+ chat.setAvatarPath(avatarManager_->getAvatarPath(jid));

+ break;

+ }

+ }

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

+ controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

+ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {

+ if (rebindIfNeeded) {

+ rebindControllerJID(pair.first, contact);

+ return chatControllers_[contact];

+ } else {

+ return pair.second;

+ }

+

+void ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& nickMaybe, bool addAutoJoin) {

+ if (addAutoJoin) {

+ MUCController* controller = new MUCController(jid_, muc, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_);

+ controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));

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

+ controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

+ handleChatActivity(mucJID.toBare(), "", true);

+

+ mucControllers_[mucJID]->showChatWindow();

+void ChatsManager::handleMUCBookmarkActivated(const MUCBookmark& mucBookmark) {

+ uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(mucBookmark.getRoom(), mucBookmark.getNick()));

+}

+

+void ChatsManager::handleRecentActivated(const ChatListWindow::Chat& chat) {

+ if (chat.isMUC) {

+ uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, chat.nick));

+ }

+ else {

+ uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(chat.jid));

+ }

+}

+

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

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

+

+ ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity);

+ void handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& nick, bool addAutoJoin);

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

+ void appendRecent(const ChatListWindow::Chat& chat);

+ void prependRecent(const ChatListWindow::Chat& chat);

+ void loadRecents();

+ void saveRecents();

+ void handleChatMadeRecent();

+ void handleMUCBookmarkActivated(const MUCBookmark&);

+ void handleRecentActivated(const ChatListWindow::Chat&);

+ void handleUnreadCountChanged(ChatControllerBase* controller);

+ void handleAvatarChanged(const JID& jid);

+

+ ChatController* getChatControllerIfExists(const JID &contact, bool rebindIfNeeded = true);

+

+ private:

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

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

+ EventController* eventController,

+ EntityCapsProvider* entityCapsProvider) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider), muc_(muc), nick_(nick), desiredNick_(nick) {

+ handleBareJIDCapsChanged(muc->getJID());

+void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

+ ChatWindow::Tristate support = ChatWindow::Yes;

+ bool any = false;

+ foreach (const std::string& nick, currentOccupants_) {

+ DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

+ if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

+ any = true;

+ } else {

+ support = ChatWindow::Maybe;

+ }

+ }

+ if (!any) {

+ support = ChatWindow::No;

+ }

+ chatWindow_->setCorrectionEnabled(support);

+}

+

+bool MUCController::isJoined() {

+ return joined_;

+}

+

+const std::string& MUCController::getNick() {

+ return nick_;

+}

+

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't join room: %1%.")) % errorMessage);

+ onUserJoined();

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

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

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

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

+}

+

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

+ roster_->addContact(jid, realJID, nick, group, avatarManager_->getAvatarPath(jid).string());

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

+ for (; it != joinParts.end(); ++it) {

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

+#include <set>

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

+ MUCController(const JID& self, MUC::ref muc, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider);

+ boost::signal<void ()> onUserJoined;

+ bool isJoined();

+ const std::string& getNick();

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

+ void handleBareJIDCapsChanged(const JID& jid);

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

+ void setUp() {

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

+ delete mocks_;

+ ProfileSettingsProvider* profileSettings_;

+ ChatListWindow* chatListWindow_;

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

+ entityCapsProvider_ = new DummyEntityCapsProvider();

+ controller_ = new MUCController (self_, muc_, nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_);

+ delete entityCapsProvider_;

+ DummyEntityCapsProvider* entityCapsProvider_;

+/*

+ * 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 setUnreadCount(int /*unread*/) {}

+ void clearBookmarks() {}

+ };

+

+}

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

+ //bool isUserDirectory = false;

+ //isUserDirectory = true;

+/*

+ * 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.empty()) {

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

+ if (servicesBeingSearched_.empty()) {

+ boost::shared_ptr<MessageEvent> message = boost::dynamic_pointer_cast<MessageEvent>(event);

+ if (!(message && message->isReadable())) {

+ event->onConclusion.connect(boost::bind(&EventWindowController::handleEventConcluded, this, event));

+ window_->addEvent(event, true);

+ }

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

+#include <SwifTools/Idle/IdleDetector.h>

+ URIHandler* uriHandler,

+ IdleDetector* idleDetector,

+ bool useDelayForLatency,

+ bool eagleMode) :

+ uriHandler_(uriHandler),

+ idleDetector_(idleDetector),

+ useDelayForLatency_(useDelayForLatency),

+ eagleMode_(eagleMode) {

+ xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

+

+ if (!eagleMode_) {

+ foreach (std::string profile, settings->getAvailableProfiles()) {

+ ProfileSettingsProvider profileSettings(profile, settings);

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

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

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

+ loginWindow_->addAvailableAccount(jid, password, certificate);

+ if (jid == selectedLoginJID) {

+ cachedPassword = password;

+ cachedCertificate = certificate;

+ }

+ loginWindow_->selectUser(selectedLoginJID);

+ loginWindow_->setLoginAutomatically(loginAutomatically);

+ } else {

+ loginWindow_->setRememberingAllowed(false);

+

+

+ idleDetector_->setIdleTimeSeconds(600);

+ idleDetector_->onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

+ idleDetector_->onIdleChanged.disconnect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

+

+ purgeCachedCredentials();

+ delete xmppURIController_;

+void MainController::purgeCachedCredentials() {

+ safeClear(password_);

+}

+

+ purgeCachedCredentials();

+

+ if (eagleMode_) {

+ purgeCachedCredentials();

+ }

+

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

+ discoInfo.addFeature(DiscoInfo::MessageCorrectionFeature);

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

+ loginWindow_->setIsLoggingIn(false);

+

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

+ if (!eagleMode_) {

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

+ }

+ if (eagleMode_ && password_.empty()) {

+ /* Then we can't try to login again. */

+ return;

+ }

+ client_ = boost::make_shared<Swift::Client>(clientJID, createSafeByteArray(password_.c_str()), networkFactories_, storages_);

+ ClientOptions clientOptions;

+ clientOptions.forgetPassword = eagleMode_;

+ client_->connect(clientOptions);

+ if (eagleMode_) {

+ purgeCachedCredentials();

+ }

+ loginWindow_->setIsLoggingIn(false);

+ if (eagleMode_) {

+ message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%. To reconnect, Sign Out and provide your password again.")) % jid_.getDomain() % message);

+ setReconnectTimer();

+ if (lastDisconnectError_) {

+ message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % boost::lexical_cast<std::string>(timeBeforeNextReconnect_));

+ lastDisconnectError_->conclude();

+ } else {

+ message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%.")) % jid_.getDomain() % message);

+ }

+ lastDisconnectError_ = boost::shared_ptr<ErrorEvent>(new ErrorEvent(JID(jid_.getDomain()), message));

+ eventController_->handleIncomingEvent(lastDisconnectError_);

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

+ loginWindow_->setIsLoggingIn(false);

+ }

+ if (eagleMode_) {

+ purgeCachedCredentials();

+ }

+ if (eagleMode_) {

+ purgeCachedCredentials();

+ }

+ adHocManager_->setServerDiscoInfo(info);

+ if (!jid.equals(jid_, JID::WithoutResource) || !vCard || vCard->getPhoto().empty()) {

+ * Copyright (c) 2010-2011 Kevin Smith

+ class IdleDetector;

+ class URIHandler;

+ class XMPPURIController;

+ class AdHocManager;

+ class AdHocCommandWindowFactory;

+ URIHandler* uriHandler,

+ IdleDetector* idleDetector,

+ bool useDelayForLatency,

+ bool eagleMode);

+ void purgeCachedCredentials();

+ URIHandler* uriHandler_;

+ IdleDetector* idleDetector_;

+ AdHocManager* adHocManager_;

+ XMPPURIController* xmppURIController_;

+ bool eagleMode_;

+ if (suggestions.empty()) {

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

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

+

+ if (presences_.empty()) {

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

+ onChildrenChanged();

+ onDataChanged();

+ }

+}

+

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

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

+}

+

+ ++it;

+ ++it;

+ ++it;

+

+ if (oldSize != getDisplayedChildren().size() || sortDisplayed()) {

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

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

+ bool manualSort_;

+ std::string manualSortValue_;

+/*

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

+

+namespace Swift {

+ using std::equal_to;

+

+ namespace Detail {

+ template<typename XIt, typename YIt, typename Length, typename Predicate>

+ void computeLeastCommonSubsequenceMatrix(XIt xBegin, XIt xEnd, YIt yBegin, YIt yEnd, std::vector<Length>& result) {

+ size_t width = std::distance(xBegin, xEnd) + 1;

+ size_t height = std::distance(yBegin, yEnd) + 1;

+ result.resize(width * height);

+

+ // Initialize first row & column

+ for (size_t i = 0; i < width; ++i) {

+ result[i] = 0;

+ }

+ for (size_t j = 0; j < height; ++j) {

+ result[j*width] = 0;

+ }

+

+ // Compute the LCS lengths for subsets

+ Predicate predicate;

+ for (size_t i = 1; i < width; ++i) {

+ for (size_t j = 1; j < height; ++j) {

+ result[i + j*width] = (predicate(*(xBegin + i-1), *(yBegin + j-1)) ? result[(i-1) + (j-1)*width] + 1 : std::max(result[i + (j-1)*width], result[i-1 + (j*width)]));

+ }

+ }

+ }

+ }

+

+ template<typename X, typename InsertRemovePredicate, typename UpdatePredicate>

+ void computeIndexDiff(const std::vector<X>& x, const std::vector<X>& y, std::vector<size_t>& updates, std::vector<size_t>& postUpdates, std::vector<size_t>& removes, std::vector<size_t>& inserts) {

+ InsertRemovePredicate insertRemovePredicate;

+ UpdatePredicate updatePredicate;

+

+ // Find & handle common prefix (Optimization to reduce LCS matrix size)

+ typename std::vector<X>::const_iterator xBegin = x.begin();

+ typename std::vector<X>::const_iterator yBegin = y.begin();

+ while (xBegin < x.end() && yBegin < y.end() && insertRemovePredicate(*xBegin, *yBegin)) {

+ if (updatePredicate(*xBegin, *yBegin)) {

+ updates.push_back(std::distance(x.begin(), xBegin));

+ postUpdates.push_back(std::distance(y.begin(), yBegin));

+ }

+ ++xBegin;

+ ++yBegin;

+ }

+ size_t prefixLength = std::distance(x.begin(), xBegin);

+

+ // Find & handle common suffix (Optimization to reduce LCS matrix size)

+ typename std::vector<X>::const_reverse_iterator xEnd = x.rbegin();

+ typename std::vector<X>::const_reverse_iterator yEnd = y.rbegin();

+ while (xEnd.base() > xBegin && yEnd.base() > yBegin && insertRemovePredicate(*xEnd, *yEnd)) {

+ if (updatePredicate(*xEnd, *yEnd)) {

+ updates.push_back(std::distance(x.begin(), xEnd.base()) - 1);

+ postUpdates.push_back(std::distance(y.begin(), yEnd.base()) - 1);

+ }

+ ++xEnd;

+ ++yEnd;

+ }

+

+ // Compute lengths

+ size_t xLength = std::distance(xBegin, xEnd.base());

+ size_t yLength = std::distance(yBegin, yEnd.base());

+

+ // Compute LCS matrix

+ std::vector<unsigned int> lcs;

+ Detail::computeLeastCommonSubsequenceMatrix<typename std::vector<X>::const_iterator, typename std::vector<X>::const_iterator, unsigned int, InsertRemovePredicate>(xBegin, xEnd.base(), yBegin, yEnd.base(), lcs);

+

+ // Process LCS matrix

+ size_t i = xLength;

+ size_t j = yLength;

+ const size_t width = xLength + 1;

+ while (true) {

+ if (i > 0 && j > 0 && insertRemovePredicate(x[prefixLength + i-1], y[prefixLength + j-1])) {

+ // x[i-1] same

+ if (updatePredicate(x[prefixLength + i - 1], y[prefixLength + j - 1])) {

+ updates.push_back(prefixLength + i-1);

+ postUpdates.push_back(prefixLength + j-1);

+ }

+ i -= 1;

+ j -= 1;

+ }

+ else if (j > 0 && (i == 0 || lcs[i + (j-1)*width] >= lcs[i-1 + j*width])) {

+ // y[j-1] added

+ inserts.push_back(prefixLength + j-1);

+ j -= 1;

+ }

+ else if (i > 0 && (j == 0 || lcs[i + (j-1)*width] < lcs[i-1 + j*width])) {

+ // x[i-1] removed

+ removes.push_back(prefixLength + i-1);

+ i -= 1;

+ }

+ else {

+ break;

+ }

+ }

+ }

+}

+ if (items->empty()) {

+ ++it;

+ group->setDisplayed(contact, filters_.empty() || !hide);

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

+/*

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

+

+#include <boost/cast.hpp>

+#include <cassert>

+#include <algorithm>

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

+

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

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

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

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

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

+

+namespace Swift {

+ struct SectionNameEquals {

+ bool operator()(const TableRoster::Section& s1, const TableRoster::Section& s2) const {

+ return s1.name == s2.name;

+ }

+ };

+

+ template<typename T>

+ struct True {

+ bool operator()(const T&, const T&) const {

+ return true;

+ }

+ };

+

+ struct ItemEquals {

+ bool operator()(const TableRoster::Item& i1, const TableRoster::Item& i2) const {

+ return i1.jid == i2.jid;

+ }

+ };

+

+

+ struct ItemNeedsUpdate {

+ bool operator()(const TableRoster::Item& i1, const TableRoster::Item& i2) const {

+ return i1.status != i2.status || i1.description != i2.description || i1.name != i2.name || i1.avatarPath.empty() != i2.avatarPath.empty();

+ }

+ };

+

+ struct CreateIndexForSection {

+ CreateIndexForSection(size_t section) : section(section) {

+ }

+

+ TableRoster::Index operator()(size_t row) const {

+ return TableRoster::Index(section, row);

+ }

+

+ size_t section;

+ };

+}

+

+using namespace Swift;

+

+TableRoster::TableRoster(Roster* model, TimerFactory* timerFactory, int updateDelay) : model(model), updatePending(false) {

+ updateTimer = timerFactory->createTimer(updateDelay);

+ updateTimer->onTick.connect(boost::bind(&TableRoster::handleUpdateTimerTick, this));

+ if (model) {

+ model->onChildrenChanged.connect(boost::bind(&TableRoster::scheduleUpdate, this));

+ model->onGroupAdded.connect(boost::bind(&TableRoster::scheduleUpdate, this));

+ model->onDataChanged.connect(boost::bind(&TableRoster::scheduleUpdate, this));

+ }

+}

+

+TableRoster::~TableRoster() {

+ updateTimer->stop();

+ updateTimer->onTick.disconnect(boost::bind(&TableRoster::handleUpdateTimerTick, this));

+ if (model) {

+ model->onDataChanged.disconnect(boost::bind(&TableRoster::scheduleUpdate, this));

+ model->onGroupAdded.disconnect(boost::bind(&TableRoster::scheduleUpdate, this));

+ model->onChildrenChanged.disconnect(boost::bind(&TableRoster::scheduleUpdate, this));

+ }

+}

+

+size_t TableRoster::getNumberOfSections() const {

+ return sections.size();

+}

+

+const std::string& TableRoster::getSectionTitle(size_t section) {

+ return sections[section].name;

+}

+

+size_t TableRoster::getNumberOfRowsInSection(size_t section) const {

+ return sections[section].items.size();

+}

+

+const TableRoster::Item& TableRoster::getItem(const Index& index) const {

+ return sections[index.section].items[index.row];

+}

+

+void TableRoster::handleUpdateTimerTick() {

+ updateTimer->stop();

+ updatePending = false;

+

+ // Get a model for the new roster

+ std::vector<Section> newSections;

+ if (model) {

+ foreach(RosterItem* item, model->getRoot()->getDisplayedChildren()) {

+ if (GroupRosterItem* groupItem = boost::polymorphic_downcast<GroupRosterItem*>(item)) {

+ //std::cerr << "* " << groupItem->getDisplayName() << std::endl;

+ Section section(groupItem->getDisplayName());

+ foreach(RosterItem* groupChildItem, groupItem->getDisplayedChildren()) {

+ if (ContactRosterItem* contact = boost::polymorphic_downcast<ContactRosterItem*>(groupChildItem)) {

+ //std::cerr << " - " << contact->getDisplayJID() << std::endl;

+ section.items.push_back(Item(contact->getDisplayName(), contact->getStatusText(), contact->getDisplayJID(), contact->getStatusShow(), contact->getAvatarPath()));

+ }

+ }

+ newSections.push_back(section);

+ }

+ }

+ }

+

+ // Do a diff with the previous roster

+ Update update;

+ std::vector<size_t> sectionUpdates;

+ std::vector<size_t> sectionPostUpdates;

+ computeIndexDiff<Section,SectionNameEquals,True<Section> >(sections, newSections, sectionUpdates, sectionPostUpdates, update.deletedSections, update.insertedSections);

+ assert(sectionUpdates.size() == sectionPostUpdates.size());

+ for (size_t i = 0; i < sectionUpdates.size(); ++i) {

+ assert(sectionUpdates[i] < sections.size());

+ assert(sectionPostUpdates[i] < newSections.size());

+ std::vector<size_t> itemUpdates;

+ std::vector<size_t> itemPostUpdates;

+ std::vector<size_t> itemRemoves;

+ std::vector<size_t> itemInserts;

+ computeIndexDiff<Item, ItemEquals, ItemNeedsUpdate >(sections[sectionUpdates[i]].items, newSections[sectionPostUpdates[i]].items, itemUpdates, itemPostUpdates, itemRemoves, itemInserts);

+ size_t end = update.insertedRows.size();

+ update.insertedRows.resize(update.insertedRows.size() + itemInserts.size());

+ std::transform(itemInserts.begin(), itemInserts.end(), update.insertedRows.begin() + end, CreateIndexForSection(sectionPostUpdates[i]));

+ end = update.deletedRows.size();

+ update.deletedRows.resize(update.deletedRows.size() + itemRemoves.size());

+ std::transform(itemRemoves.begin(), itemRemoves.end(), update.deletedRows.begin() + end, CreateIndexForSection(sectionUpdates[i]));

+ end = update.updatedRows.size();

+ update.updatedRows.resize(update.updatedRows.size() + itemUpdates.size());

+ std::transform(itemUpdates.begin(), itemUpdates.end(), update.updatedRows.begin() + end, CreateIndexForSection(sectionPostUpdates[i]));

+ }

+

+ // Switch the old model with the new

+ sections.swap(newSections);

+

+ /*

+ std::cerr << "-S: ";

+ for (size_t i = 0; i < update.deletedSections.size(); ++i) {

+ std::cerr << update.deletedSections[i] << " ";

+ }

+ std::cerr << std::endl;

+ std::cerr << "+S: ";

+ for (size_t i = 0; i < update.insertedSections.size(); ++i) {

+ std::cerr << update.insertedSections[i] << " ";

+ }

+ std::cerr << std::endl;

+ std::cerr << "-R: ";

+ for (size_t i = 0; i < update.deletedRows.size(); ++i) {

+ std::cerr << update.deletedRows[i].section << "," << update.deletedRows[i].row << " ";

+ }

+ std::cerr << std::endl;

+ std::cerr << "*R: ";

+ for (size_t i = 0; i < update.updatedRows.size(); ++i) {

+ std::cerr << update.updatedRows[i].section << "," << update.updatedRows[i].row << " ";

+ }

+ std::cerr << std::endl;

+ std::cerr << "+R: ";

+ for (size_t i = 0; i < update.insertedRows.size(); ++i) {

+ std::cerr << update.insertedRows[i].section << "," << update.insertedRows[i].row << " ";

+ }

+ std::cerr << std::endl;

+ */

+

+ // Emit the update

+ onUpdate(update);

+}

+

+void TableRoster::scheduleUpdate() {

+ if (!updatePending) {

+ updatePending = true;

+ updateTimer->start();

+ }

+}

+/*

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

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

+

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

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

+

+namespace Swift {

+ class Roster;

+ class TimerFactory;

+ class Timer;

+

+ class TableRoster {

+ public:

+ struct Item {

+ Item(const std::string& name, const std::string& description, const JID& jid, StatusShow::Type status, const std::string& avatarPath) : name(name), description(description), jid(jid), status(status), avatarPath(avatarPath) {

+ }

+ std::string name;

+ std::string description;

+ JID jid;

+ StatusShow::Type status;

+ std::string avatarPath;

+ };

+

+ struct Index {

+ Index(size_t section = 0, size_t row = 0) : section(section), row(row) {

+ }

+ size_t section;

+ size_t row;

+

+ bool operator==(const Index& o) const {

+ return o.section == section && o.row == row;

+ }

+ };

+

+ struct Update {

+ std::vector<Index> updatedRows;

+ std::vector<Index> insertedRows;

+ std::vector<Index> deletedRows;

+ std::vector<size_t> insertedSections;

+ std::vector<size_t> deletedSections;

+ };

+

+ TableRoster(Roster* model, TimerFactory* timerFactory, int updateDelay);

+ ~TableRoster();

+

+ size_t getNumberOfSections() const;

+ size_t getNumberOfRowsInSection(size_t section) const;

+

+ const std::string& getSectionTitle(size_t);

+

+ const Item& getItem(const Index&) const;

+

+ boost::signal<void (const Update&)> onUpdate;

+

+ private:

+ void handleUpdateTimerTick();

+ void scheduleUpdate();

+

+ private:

+ friend class SectionNameEquals;

+ struct Section {

+ Section(const std::string& name) : name(name) {

+ }

+

+ std::string name;

+ std::vector<Item> items;

+ };

+

+ Roster* model;

+ std::vector<Section> sections;

+ bool updatePending;

+ boost::shared_ptr<Timer> updateTimer;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

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

+#include <functional>

+

+#include <QA/Checker/IO.h>

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

+

+using namespace Swift;

+

+struct IsBOrC {

+ bool operator()(char c, char c2) const {

+ CPPUNIT_ASSERT_EQUAL(c, c2);

+ return c == 'b' || c == 'c';

+ }

+};

+

+struct IsXOrY {

+ bool operator()(char c, char c2) const {

+ CPPUNIT_ASSERT_EQUAL(c, c2);

+ return c == 'x' || c == 'y';

+ }

+};

+

+struct IsArizonaOrNewJersey {

+ bool operator()(const std::string& s, const std::string& s2) const {

+ CPPUNIT_ASSERT_EQUAL(s, s2);

+ return s == "Arizona" || s == "New Jersey";

+ }

+};

+

+class LeastCommonSubsequenceTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(LeastCommonSubsequenceTest);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_1);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_2);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_Sequence1Empty);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_Sequence2Empty);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_BothSequencesEmpty);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_NoCommonSequence);

+ CPPUNIT_TEST(testComputeLeastCommonSubsequenceMatrix_SameSequences);

+ CPPUNIT_TEST(testComputeIndexDiff_1);

+ CPPUNIT_TEST(testComputeIndexDiff_2);

+ CPPUNIT_TEST(testComputeIndexDiff_Sequence1Empty);

+ CPPUNIT_TEST(testComputeIndexDiff_Sequence2Empty);

+ CPPUNIT_TEST(testComputeIndexDiff_BothSequencesEmpty);

+ CPPUNIT_TEST(testComputeIndexDiff_NoCommonSequence);

+ CPPUNIT_TEST(testComputeIndexDiff_SameSequences);

+ CPPUNIT_TEST(testComputeIndexDiff_CommonPrefixAndSuffix);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testComputeLeastCommonSubsequenceMatrix_1() {

+ std::vector<char> x = boost::assign::list_of('x')('m')('j')('y')('a')('u')('z');

+ std::vector<char> y = boost::assign::list_of('m')('z')('j')('a')('w')('x')('u');

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of

+ (0)(0)(0)(0)(0)(0)(0)(0)

+ (0)(0)(1)(1)(1)(1)(1)(1)

+ (0)(0)(1)(1)(1)(1)(1)(2)

+ (0)(0)(1)(2)(2)(2)(2)(2)

+ (0)(0)(1)(2)(2)(3)(3)(3)

+ (0)(0)(1)(2)(2)(3)(3)(3)

+ (0)(1)(1)(2)(2)(3)(3)(3)

+ (0)(1)(1)(2)(2)(3)(4)(4);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeLeastCommonSubsequenceMatrix_2() {

+ std::vector<char> x = boost::assign::list_of('x')('x')('x')('m')('j')('y')('a')('u')('z');

+ std::vector<char> y = boost::assign::list_of('m')('z')('j')('a')('w')('x')('u');

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of

+ (0)(0)(0)(0)(0)(0)(0)(0)(0)(0)

+ (0)(0)(0)(0)(1)(1)(1)(1)(1)(1)

+ (0)(0)(0)(0)(1)(1)(1)(1)(1)(2)

+ (0)(0)(0)(0)(1)(2)(2)(2)(2)(2)

+ (0)(0)(0)(0)(1)(2)(2)(3)(3)(3)

+ (0)(0)(0)(0)(1)(2)(2)(3)(3)(3)

+ (0)(1)(1)(1)(1)(2)(2)(3)(3)(3)

+ (0)(1)(1)(1)(1)(2)(2)(3)(4)(4);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeLeastCommonSubsequenceMatrix_Sequence1Empty() {

+ std::vector<char> x;

+ std::vector<char> y = boost::assign::list_of('a')('b')('c');

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of

+ (0)

+ (0)

+ (0)

+ (0);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeLeastCommonSubsequenceMatrix_Sequence2Empty() {

+ std::vector<char> x = boost::assign::list_of('a')('b')('c');

+ std::vector<char> y;

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of

+ (0)(0)(0)(0);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeLeastCommonSubsequenceMatrix_BothSequencesEmpty() {

+ std::vector<char> x;

+ std::vector<char> y;

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of(0);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeLeastCommonSubsequenceMatrix_NoCommonSequence() {

+ std::vector<char> x = boost::assign::list_of('a')('b')('c');

+ std::vector<char> y = boost::assign::list_of('d')('e')('f')('g');

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of

+ (0)(0)(0)(0)

+ (0)(0)(0)(0)

+ (0)(0)(0)(0)

+ (0)(0)(0)(0)

+ (0)(0)(0)(0);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeLeastCommonSubsequenceMatrix_SameSequences() {

+ std::vector<char> x = boost::assign::list_of('a')('b')('c');

+ std::vector<char> y = boost::assign::list_of('a')('b')('c');

+

+ std::vector<int> result;

+ Detail::computeLeastCommonSubsequenceMatrix<std::vector<char>::const_iterator, std::vector<char>::const_iterator, int, std::equal_to<char> >(x.begin(), x.end(), y.begin(), y.end(), result);

+

+ std::vector<int> expected = boost::assign::list_of

+ (0)(0)(0)(0)

+ (0)(1)(1)(1)

+ (0)(1)(2)(2)

+ (0)(1)(2)(3);

+ CPPUNIT_ASSERT_EQUAL(expected, result);

+ }

+

+ void testComputeIndexDiff_1() {

+ std::vector<std::string> x = boost::assign::list_of("Arizona")("California")("Delaware")("New Jersey")("Washington");

+ std::vector<std::string> y = boost::assign::list_of("Alaska")("Arizona")("California")("Georgia")("New Jersey")("Virginia");

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<std::string, std::equal_to<std::string>, IsArizonaOrNewJersey >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedUpdates = boost::assign::list_of(3)(0);

+ std::vector<size_t> expectedPostUpdates = boost::assign::list_of(4)(1);

+ std::vector<size_t> expectedRemoves = boost::assign::list_of(4)(2);

+ std::vector<size_t> expectedInserts = boost::assign::list_of(5)(3)(0);

+ CPPUNIT_ASSERT_EQUAL(expectedUpdates, updates);

+ CPPUNIT_ASSERT_EQUAL(expectedPostUpdates, postUpdates);

+ CPPUNIT_ASSERT_EQUAL(expectedRemoves, removes);

+ CPPUNIT_ASSERT_EQUAL(expectedInserts, inserts);

+ }

+

+ void testComputeIndexDiff_2() {

+ std::vector<char> x = boost::assign::list_of('x')('y');

+ std::vector<char> y = boost::assign::list_of('x');

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsBOrC >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedRemoves = boost::assign::list_of(1);

+ CPPUNIT_ASSERT(updates.empty());

+ CPPUNIT_ASSERT(postUpdates.empty());

+ CPPUNIT_ASSERT(inserts.empty());

+ CPPUNIT_ASSERT_EQUAL(expectedRemoves, removes);

+ }

+

+ void testComputeIndexDiff_Sequence1Empty() {

+ std::vector<char> x;

+ std::vector<char> y = boost::assign::list_of('a')('b')('c');

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsBOrC >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedInserts = boost::assign::list_of(2)(1)(0);

+ CPPUNIT_ASSERT(updates.empty());

+ CPPUNIT_ASSERT(postUpdates.empty());

+ CPPUNIT_ASSERT(removes.empty());

+ CPPUNIT_ASSERT_EQUAL(expectedInserts, inserts);

+ }

+

+ void testComputeIndexDiff_Sequence2Empty() {

+ std::vector<char> x = boost::assign::list_of('a')('b')('c');

+ std::vector<char> y;

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsBOrC >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedRemoves = boost::assign::list_of(2)(1)(0);

+ CPPUNIT_ASSERT(updates.empty());

+ CPPUNIT_ASSERT(postUpdates.empty());

+ CPPUNIT_ASSERT_EQUAL(expectedRemoves, removes);

+ CPPUNIT_ASSERT(inserts.empty());

+ }

+

+ void testComputeIndexDiff_BothSequencesEmpty() {

+ std::vector<char> x;

+ std::vector<char> y;

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsBOrC >(x, y, updates, postUpdates, removes, inserts);

+

+ CPPUNIT_ASSERT(updates.empty());

+ CPPUNIT_ASSERT(postUpdates.empty());

+ CPPUNIT_ASSERT(removes.empty());

+ CPPUNIT_ASSERT(inserts.empty());

+ }

+

+ void testComputeIndexDiff_NoCommonSequence() {

+ std::vector<char> x = boost::assign::list_of('a')('b')('c');

+ std::vector<char> y = boost::assign::list_of('d')('e')('f')('g');

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsBOrC >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedRemoves = boost::assign::list_of(2)(1)(0);

+ std::vector<size_t> expectedInserts = boost::assign::list_of(3)(2)(1)(0);

+ CPPUNIT_ASSERT(updates.empty());

+ CPPUNIT_ASSERT(postUpdates.empty());

+ CPPUNIT_ASSERT_EQUAL(expectedRemoves, removes);

+ CPPUNIT_ASSERT_EQUAL(expectedInserts, inserts);

+ }

+

+ void testComputeIndexDiff_SameSequences() {

+ std::vector<char> x = boost::assign::list_of('a')('b')('c');

+ std::vector<char> y = boost::assign::list_of('a')('b')('c');

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsBOrC >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedUpdates = boost::assign::list_of(1)(2);

+ CPPUNIT_ASSERT_EQUAL(expectedUpdates, updates);

+ CPPUNIT_ASSERT_EQUAL(expectedUpdates, postUpdates);

+ CPPUNIT_ASSERT(removes.empty());

+ CPPUNIT_ASSERT(inserts.empty());

+ }

+

+ void testComputeIndexDiff_CommonPrefixAndSuffix() {

+ std::vector<char> x = boost::assign::list_of('x')('x')('x')('x')('a')('b')('c')('d')('e')('y')('y')('y');

+ std::vector<char> y = boost::assign::list_of('x')('x')('x')('x')('e')('a')('b')('f')('d')('g')('y')('y')('y');

+

+ std::vector<size_t> updates;

+ std::vector<size_t> postUpdates;

+ std::vector<size_t> removes;

+ std::vector<size_t> inserts;

+ computeIndexDiff<char, std::equal_to<char>, IsXOrY >(x, y, updates, postUpdates, removes, inserts);

+

+ std::vector<size_t> expectedUpdates = boost::assign::list_of(0)(1)(2)(3)(11)(10)(9);

+ std::vector<size_t> expectedPostUpdates = boost::assign::list_of(0)(1)(2)(3)(12)(11)(10);

+ std::vector<size_t> expectedRemoves = boost::assign::list_of(8)(6);

+ std::vector<size_t> expectedInserts = boost::assign::list_of(9)(7)(4);

+ CPPUNIT_ASSERT_EQUAL(expectedUpdates, updates);

+ CPPUNIT_ASSERT_EQUAL(expectedPostUpdates, postUpdates);

+ CPPUNIT_ASSERT_EQUAL(expectedRemoves, removes);

+ CPPUNIT_ASSERT_EQUAL(expectedInserts, inserts);

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(LeastCommonSubsequenceTest);

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

+ CPPUNIT_TEST(testReSortLikeMUC);

+ void testReSortLikeMUC() {

+ JID jid4a("a@b/c");

+ JID jid4b("a@b/d");

+ JID jid4c("a@b/e");

+ roster_->addContact(jid4a, JID(), "Bird", "group1", "");

+ roster_->addContact(jid4b, JID(), "Cookie", "group2", "");

+ roster_->addContact(jid4b, JID(), "Ernie", "group1", "");

+ roster_->getGroup("group1")->setManualSort("2");

+ roster_->getGroup("group2")->setManualSort("1");

+ GroupRosterItem* root = roster_->getRoot();

+ const std::vector<RosterItem*> kids = root->getDisplayedChildren();

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), kids.size());

+ CPPUNIT_ASSERT_EQUAL(std::string("group2"), kids[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(std::string("group1"), kids[1]->getDisplayName());

+ }

+

+/*

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

+

+std::ostream& operator<<(std::ostream& os, const Swift::TableRoster::Index& i) {

+ os << "(" << i.section << ", " << i.row << ")";

+ return os;

+}

+

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

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

+#include <boost/shared_ptr.hpp>

+#include <boost/variant.hpp>

+

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

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

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

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

+

+using namespace Swift;

+

+class TableRosterTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(TableRosterTest);

+ CPPUNIT_TEST(testAddContact_EmptyRoster);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ timerFactory = new DummyTimerFactory();

+ roster = new Roster();

+ jid1 = JID("jid1@example.com");

+ jid2 = JID("jid2@example.com");

+ }

+

+ void tearDown() {

+ delete roster;

+ delete timerFactory;

+ }

+

+ void testAddContact_EmptyRoster() {

+ /*

+ boost::shared_ptr<TableRoster> tableRoster(createTestling());

+

+ addContact(jid1, "1", "group1");

+

+ CPPUNIT_ASSERT_EQUAL(4, static_cast<int>(events.size()));

+ CPPUNIT_ASSERT(boost::get<BeginUpdatesEvent>(&events[0]));

+ CPPUNIT_ASSERT(boost::get<SectionsInsertedEvent>(&events[1]));

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(boost::get<SectionsInsertedEvent>(events[1]).sections.size()));

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(boost::get<SectionsInsertedEvent>(events[1]).sections[0]));

+ CPPUNIT_ASSERT(boost::get<RowsInsertedEvent>(&events[2]));

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(boost::get<RowsInsertedEvent>(events[2]).rows.size()));

+ CPPUNIT_ASSERT_EQUAL(TableRoster::Index(0, 0), boost::get<RowsInsertedEvent>(events[2]).rows[0]);

+ CPPUNIT_ASSERT(boost::get<EndUpdatesEvent>(&events[3]));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(tableRoster->getNumberOfSections()));

+ CPPUNIT_ASSERT_EQUAL(std::string("group1"), tableRoster->getSectionTitle(0));

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(tableRoster->getNumberOfRowsInSection(0)));

+ CPPUNIT_ASSERT_EQUAL(jid1, tableRoster->getItem(TableRoster::Index(0, 0)).jid);

+ */

+ }

+

+ private:

+ void addContact(const JID& jid, const std::string& name, const std::string& group) {

+ roster->addContact(jid, JID(), name, group, "");

+ }

+

+ TableRoster* createTestling() {

+ TableRoster* result = new TableRoster(roster, timerFactory, 10);

+ result->onUpdate.connect(boost::bind(&TableRosterTest::handleUpdate, this, _1));

+ return result;

+ }

+

+ void handleUpdate(const TableRoster::Update& update) {

+ updates.push_back(update);

+ }

+

+ private:

+ DummyTimerFactory* timerFactory;

+ Roster* roster;

+ JID jid1;

+ JID jid2;

+ std::vector<TableRoster::Update> updates;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(TableRosterTest);

+

+ "Roster/TableRoster.cpp",

+ "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("Roster/UnitTest/LeastCommonSubsequenceTest.cpp"),

+ File("Roster/UnitTest/TableRosterTest.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*>(vecptr(avatar)), static_cast<std::streamsize>(avatar.size()));

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

+ readByteArrayFromFile(data, 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>

+ readByteArrayFromFile(data, certificatePath.string());

+ file.write(reinterpret_cast<const char*>(vecptr(data)), data.size());

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

+ boost::shared_ptr<VCard> result = VCardPersister().loadPayloadGeneric(getVCardPath(jid));

+ getAndUpdatePhotoHash(jid, result);

+ return result;

+}

+

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

+ try {

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

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

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

+ }

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

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

+ return boost::filesystem::path();

+ }

+}

+

+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().empty()) {

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

+ };

+}

+ for (EventList::iterator it = events.begin(); it != events.end(); ++it) {

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

+

+ JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& nick = boost::optional<std::string>(), bool joinAutomaticallyInFuture = false) : jid_(jid), nick_(nick), joinAutomatically_(joinAutomaticallyInFuture){};

+ bool getShouldJoinAutomatically() {return joinAutomatically_;}

+ bool joinAutomatically_;

+/*

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

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

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

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

+ class Chat {

+ public:

+ Chat(const JID& jid, const std::string& chatName, const std::string& activity, int unreadCount, StatusShow::Type statusType, const boost::filesystem::path& avatarPath, bool isMUC, const std::string& nick = "")

+ : jid(jid), chatName(chatName), activity(activity), statusType(statusType), isMUC(isMUC), nick(nick), unreadCount(unreadCount), avatarPath(avatarPath) {}

+ /** Assume that nicks and other transient features aren't important for equality */

+ bool operator==(const Chat& other) const {

+ return jid.toBare() == other.jid.toBare()

+ && isMUC == other.isMUC;

+ };

+ void setUnreadCount(int unread) {

+ unreadCount = unread;

+ }

+ void setStatusType(StatusShow::Type type) {

+ statusType = type;

+ }

+ void setAvatarPath(const boost::filesystem::path& path) {

+ avatarPath = path;

+ }

+ JID jid;

+ std::string chatName;

+ std::string activity;

+ StatusShow::Type statusType;

+ bool isMUC;

+ std::string nick;

+ int unreadCount;

+ boost::filesystem::path avatarPath;

+ };

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

+ virtual void setUnreadCount(int unread) = 0;

+ virtual void clearBookmarks() = 0;

+

+ boost::signal<void (const MUCBookmark&)> onMUCBookmarkActivated;

+ boost::signal<void (const Chat&)> onRecentActivated;

+ enum Tristate {Yes, No, Maybe};

+ virtual void replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time) = 0;

+ virtual void setCorrectionEnabled(Tristate enabled) = 0;

+ /**

+ * Set an alert on the window.

+ * @param alertText Description of alert (required).

+ * @param buttonText Button text to use (optional, no button is shown if empty).

+ */

+ virtual void setAlert(const std::string& alertText, const std::string& buttonText = "") = 0;

+ /**

+ * Removes an alert.

+ */

+ virtual void cancelAlert() = 0;

+ boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

+ boost::signal<void ()> onSendCorrectionMessageRequest;

+ boost::signal<void ()> onAlertButtonClicked;

+#include <boost/shared_ptr.hpp>

+

+ class UIEventStream;

+ virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream) = 0;

+ /** Disable any GUI elements that suggest saving of passwords. */

+ virtual void setRememberingAllowed(bool allowed) = 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 {

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

+ virtual void handleDataRead(const SafeByteArray& data) = 0;

+ virtual void handleDataWritten(const SafeByteArray& data) = 0;

+/*

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

+ MockChatWindow() : labelsEnabled_(false) {};

+ virtual void replaceMessage(const std::string&, const std::string&, const boost::posix_time::ptime&) {};

+ virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {};

+ virtual void cancelAlert() {};

+ virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

+ boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

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

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ avatarManager->avatars[user1] = createByteArray("abcdef");

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> testling = createNotifier();

+ boost::shared_ptr<PresenceNotifier> createNotifier() {

+ boost::shared_ptr<PresenceNotifier> result(new PresenceNotifier(stanzaChannel, notifier, mucRegistry, avatarManager, nickResolver, presenceOracle, timerFactory));

+void XMLConsoleController::handleDataRead(const SafeByteArray& data) {

+void XMLConsoleController::handleDataWritten(const SafeByteArray& data) {

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

+ void handleDataRead(const SafeByteArray& data);

+ void handleDataWritten(const SafeByteArray& data);

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

+ };

+}