+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+#include <boost/shared_ptr.hpp>

+

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

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

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

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

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

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

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

+

+namespace Swift {

+

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

+ iqRouter_ = iqRouter;

+ uiEventStream_ = uiEventStream;

+ mainWindow_ = mainWindow;

+ factory_ = factory;

+

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

+}

+

+AdHocManager::~AdHocManager() {

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

+}

+

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

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

+ if (discoItemsRequest_) {

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

+ discoItemsRequest_.reset();

+ }

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

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

+ discoItemsRequest_->send();

+ } else {

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

+ }

+

+}

+

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

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

+ if (!error) {

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

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

+ commands.push_back(item);

+ }

+ }

+ }

+ mainWindow_->setAvailableAdHocCommands(commands);

+}

+

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

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

+ if (adHocEvent) {

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

+ }

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <vector>

+

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

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

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

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

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

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

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

+

+namespace Swift {

+ class IQRouter;

+ class MainWindow;

+ class UIEventStream;

+ class AdHocCommandWindowFactory;

+ class AdHocManager {

+ public:

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

+ ~AdHocManager();

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

+ private:

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

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

+ JID jid_;

+ IQRouter* iqRouter_;

+ UIEventStream* uiEventStream_;

+ MainWindow* mainWindow_;

+ AdHocCommandWindowFactory* factory_;

+ GetDiscoItemsRequest::ref discoItemsRequest_;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

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

+

+namespace Swift {

+ class CertificateFactory;

+

+ class CertificateMemoryStorageFactory : public CertificateStorageFactory {

+ public:

+ CertificateMemoryStorageFactory() {

+ }

+

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

+ return new CertificateMemoryStorage();

+ }

+

+ private:

+ boost::filesystem::path basePath;

+ CertificateFactory* certificateFactory;

+ };

+}

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

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

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

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

+ unackedStanzas_.erase(unackedStanza);

+ * Copyright (c) 2010-2011 Kevin Smith

+ onActivity(message->getBody());

+ onActivity(body);

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

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

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

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

+#define RECENT_CHATS "recent_chats"

+

+ ProfileSettingsProvider* settings) :

+ profileSettings_ = settings;

+ loadRecents();

+void ChatsManager::saveRecents() {

+ std::string recents;

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

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

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

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

+ recents += recent + "\n";

+ }

+ profileSettings_->storeString(RECENT_CHATS, recents);

+}

+

+void ChatsManager::loadRecents() {

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

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

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

+ int i = 0;

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

+ if (i++ > 30) {

+ break;

+ }

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

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

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

+ continue;

+ }

+ JID jid(recent[0]);

+ if (!jid.isValid()) {

+ continue;

+ }

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

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

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

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

+ recentChats_.push_back(chat);

+ chatListWindow_->setRecents(recentChats_);

+ }

+}

+

+ chatListWindow_->clearBookmarks();

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

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

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

+ /* FIXME: handle nick changes */

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

+ recentChats_.push_front(chat);

+ chatListWindow_->setRecents(recentChats_);

+ saveRecents();

+}

+

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

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

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

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

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

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

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

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

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

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

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

+ class ProfileSettingsProvider;

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

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

+ void loadRecents();

+ void saveRecents();

+ void handleChatMadeRecent();

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

+ ProfileSettingsProvider* profileSettings_;

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

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

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

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

+#include <SwifTools/TabComplete.h>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ addedRosterGroups_.insert(groupName);

+ }

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

+ switch (role) {

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

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

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

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

+ }

+ return "5";

+}

+

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

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

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

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

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

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

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

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

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

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

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

+ ProfileSettingsProvider* settings_;

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

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

+ chatListWindow_ = new MockChatListWindow();

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

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

+ delete profileSettings_;

+ delete chatListWindow_;

+ ProfileSettingsProvider* profileSettings_;

+ ChatListWindow* chatListWindow_;

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include "Swift/Controllers/UIInterfaces/ChatListWindow.h"

+

+namespace Swift {

+

+ class MockChatListWindow : public ChatListWindow {

+ public:

+ MockChatListWindow() {};

+ virtual ~MockChatListWindow() {};

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

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

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

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

+ void clearBookmarks() {}

+ };

+

+}

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

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

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

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

+

+using namespace Swift;

+using namespace std;

+

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

+ vector<UnreadPair> others;

+ int currentUnread = 0;

+ int otherCount = 0;

+ foreach (UnreadPair unread, unreads) {

+ if (unread.first == current) {

+ currentUnread += unread.second;

+ } else {

+ if (unread.second > 0) {

+ otherCount += unread.second;

+ others.push_back(unread);

+ }

+ }

+ }

+ string myString(current);

+

+ if (currentUnread > 0) {

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

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

+ }

+

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

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

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

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

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

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

+ }

+ return myString;

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <vector>

+#include <utility>

+#include <string>

+

+namespace Swift {

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

+

+ class ChatMessageSummarizer {

+ public:

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

+ };

+}

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

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

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

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

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

+ URIHandler* uriHandler,

+ uriHandler_(uriHandler),

+ xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

+

+ delete xmppURIController_;

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_);

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

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

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

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

+ loginWindow_->setIsLoggingIn(false);

+ } else {

+ loginWindow_->setMessage("");

+ loginWindow_->setIsLoggingIn(true);

+ profileSettings_ = new ProfileSettingsProvider(username, settings_);

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

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

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

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

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

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

+

+ password_ = password;

+ certificateFile_ = certificateFile;

+ performLoginFromCachedCredentials();

+ }

+ loginWindow_->setIsLoggingIn(false);

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

+ loginWindow_->setIsLoggingIn(false);

+ }

+ adHocManager_->setServerDiscoInfo(info);

+ * Copyright (c) 2010-2011 Kevin Smith

+ class URIHandler;

+ class XMPPURIController;

+ class AdHocManager;

+ class AdHocCommandWindowFactory;

+ URIHandler* uriHandler,

+ URIHandler* uriHandler_;

+ AdHocManager* adHocManager_;

+ XMPPURIController* xmppURIController_;

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

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

+

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

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

+ manualSort_ = true;

+ bool changed = manualSortValue_ != manualSortValue;

+ manualSortValue_ = manualSortValue;

+ if (changed) {

+ onDataChanged();

+ }

+}

+

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

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

+}

+

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

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

+ bool manualSort_;

+ std::string manualSortValue_;

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

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

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

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

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

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

+ "AdHocManager.cpp",

+ "Storages/CertificateStorageFactory.cpp",

+ "Storages/CertificateStorage.cpp",

+ "Storages/CertificateFileStorage.cpp",

+ "Storages/CertificateMemoryStorage.cpp",

+ "Storages/AvatarFileStorage.cpp",

+ "Storages/FileStorages.cpp",

+ "Storages/RosterFileStorage.cpp",

+ "Storages/CapsFileStorage.cpp",

+ "Storages/VCardFileStorage.cpp",

+ "XMPPURIController.cpp",

+ "ChatMessageSummarizer.cpp",

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

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <iostream>

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

+#include <boost/filesystem.hpp>

+

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

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

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

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

+

+namespace Swift {

+

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

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

+ try {

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

+ std::string line;

+ if (file.is_open()) {

+ while (!file.eof()) {

+ getline(file, line);

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

+ JID jid(r.second);

+ if (jid.isValid()) {

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

+ }

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

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

+ }

+ }

+ }

+ }

+ catch (...) {

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

+ }

+ }

+}

+

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

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

+}

+

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

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

+

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

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

+ try {

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

+ }

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

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

+ }

+ }

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

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

+ file.close();

+}

+

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

+ return avatarsDir / hash;

+}

+

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

+ ByteArray data;

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

+ return data;

+}

+

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

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

+ if (r.second) {

+ saveJIDAvatars();

+ }

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

+ r.first->second = hash;

+ saveJIDAvatars();

+ }

+}

+

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

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

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

+}

+

+void AvatarFileStorage::saveJIDAvatars() {

+ try {

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

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

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

+ }

+ file.close();

+ }

+ catch (...) {

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

+ }

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <map>

+#include <string>

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

+

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

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

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

+

+namespace Swift {

+ class AvatarFileStorage : public AvatarStorage {

+ public:

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

+

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

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

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

+

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

+

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

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

+

+ private:

+ void saveJIDAvatars();

+

+ private:

+ boost::filesystem::path avatarsDir;

+ boost::filesystem::path avatarsFile;

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

+ JIDAvatarMap jidAvatars;

+ };

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

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

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

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

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

+

+using namespace Swift;

+

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

+

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

+}

+

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

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

+}

+

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

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

+ bareDiscoInfo->setNode("");

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

+}

+

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

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

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+

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

+#include <string>

+

+namespace Swift {

+ class CapsFileStorage : public CapsStorage {

+ public:

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

+

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

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

+

+ private:

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

+

+ private:

+ boost::filesystem::path path;

+ };

+}

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

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

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

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

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

+

+using namespace Swift;

+

+CertificateMemoryStorage::CertificateMemoryStorage() {

+}

+

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

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

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

+ return true;

+ }

+ }

+ return false;

+}

+

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

+ certificates.push_back(certificate);

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <vector>

+

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

+

+namespace Swift {

+ class CertificateMemoryStorage : public CertificateStorage {

+ public:

+ CertificateMemoryStorage();

+

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

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

+

+ private:

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

+ };

+

+}

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

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

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

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

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

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

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

+

+namespace Swift {

+

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

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

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

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

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

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

+}

+

+FileStorages::~FileStorages() {

+ delete rosterStorage;

+ delete avatarStorage;

+ delete capsStorage;

+ delete vcardStorage;

+}

+

+VCardStorage* FileStorages::getVCardStorage() const {

+ return vcardStorage;

+}

+

+CapsStorage* FileStorages::getCapsStorage() const {

+ return capsStorage;

+}

+

+AvatarStorage* FileStorages::getAvatarStorage() const {

+ return avatarStorage;

+}

+

+RosterStorage* FileStorages::getRosterStorage() const {

+ return rosterStorage;

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+

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

+

+namespace Swift {

+ class VCardFileStorage;

+ class AvatarFileStorage;

+ class CapsFileStorage;

+ class RosterFileStorage;

+ class JID;

+

+ /**

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

+ */

+ class FileStorages : public Storages {

+ public:

+ /**

+ * Creates the storages interface.

+ *

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

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

+ * The data is stored in the following places:

+ * - Avatars: <basedir>/avatars

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

+ * - Entity capabilities: <basedir>/caps

+ *

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

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

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

+ */

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

+ ~FileStorages();

+

+ virtual VCardStorage* getVCardStorage() const;

+ virtual AvatarStorage* getAvatarStorage() const;

+ virtual CapsStorage* getCapsStorage() const;

+ virtual RosterStorage* getRosterStorage() const;

+

+ private:

+ VCardFileStorage* vcardStorage;

+ AvatarFileStorage* avatarStorage;

+ CapsFileStorage* capsStorage;

+ RosterFileStorage* rosterStorage;

+ };

+}

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

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

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

+ class JID;

+

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

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

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

+

+using namespace Swift;

+

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

+

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

+}

+

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

+ return RosterPersister().loadPayloadGeneric(path);

+}

+

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

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

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+

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

+

+namespace Swift {

+ class RosterFileStorage : public RosterStorage {

+ public:

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

+

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

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

+

+ private:

+ boost::filesystem::path path;

+ };

+}

+ class JID;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

+#include <boost/filesystem.hpp>

+#include <iostream>

+

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

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

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

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

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

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

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

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

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

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

+

+using namespace Swift;

+

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

+

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

+ cacheFile = vcardsPath / "phashes";

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

+ try {

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

+ std::string line;

+ if (file.is_open()) {

+ while (!file.eof()) {

+ getline(file, line);

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

+ JID jid(r.second);

+ if (jid.isValid()) {

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

+ }

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

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

+ }

+ }

+ }

+ }

+ catch (...) {

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

+ }

+ }

+}

+

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

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

+}

+

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

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

+ getAndUpdatePhotoHash(jid, v);

+}

+

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

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

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

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

+}

+

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

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

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

+ return i->second;

+ }

+ else {

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

+ return getAndUpdatePhotoHash(jid, vCard);

+ }

+}

+

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

+ std::string hash;

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

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

+ }

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

+ if (r.second) {

+ savePhotoHashes();

+ }

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

+ r.first->second = hash;

+ savePhotoHashes();

+ }

+ return hash;

+}

+

+void VCardFileStorage::savePhotoHashes() const {

+ try {

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

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

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

+ }

+ file.close();

+ }

+ catch (...) {

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

+ }

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

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

+#include <string>

+#include <map>

+

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

+

+namespace Swift {

+ class VCardFileStorage : public VCardStorage {

+ public:

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

+

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

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

+

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

+

+ private:

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

+

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

+ void savePhotoHashes() const;

+

+ private:

+ boost::filesystem::path vcardsPath;

+ boost::filesystem::path cacheFile;

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

+ mutable PhotoHashMap photoHashes;

+ };

+}

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+

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

+

+namespace Swift {

+ class RequestAdHocUIEvent : public UIEvent {

+ public:

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

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

+ private:

+ DiscoItems::Item command_;

+ };

+}

+

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

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

+

+ const JID& getRoom() const {

+ return room;

+ }

+

+ private:

+ JID room;

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+namespace Swift {

+ class AdHocCommandWindow {

+ public:

+ virtual ~AdHocCommandWindow() {};

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

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

+

+namespace Swift {

+ class AdHocCommandWindowFactory {

+ public:

+ virtual ~AdHocCommandWindowFactory() {}

+ /**

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

+ * so the result isn't returned.

+ */

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

+ };

+}

+ * Copyright (c) 2010-2011 Kevin Smith

+#include <list>

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

+ class Chat {

+ public:

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

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

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

+ JID jid;

+ std::string chatName;

+ std::string activity;

+ bool isMUC;

+ std::string nick;

+ };

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

+ virtual void clearBookmarks() = 0;

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

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

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

+ public ContactEditWindowFactory,

+ public AdHocCommandWindowFactory {

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

+

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

+

+using namespace Swift;

+using namespace std;

+

+class ChatMessageSummarizerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ChatMessageSummarizerTest);

+ CPPUNIT_TEST(testEmpty);

+ CPPUNIT_TEST(testCurrentNone);

+ CPPUNIT_TEST(testCurrentCount);

+ CPPUNIT_TEST(testCurrentCountOthersNone);

+ CPPUNIT_TEST(testCurrentCountOtherCount);

+ CPPUNIT_TEST(testCurrentNoneOtherCount);

+ CPPUNIT_TEST(testCurrentCountOthersCount);

+ CPPUNIT_TEST(testCurrentNoneOthersCount);

+ CPPUNIT_TEST(testCurrentCountSomeOthersCount);

+ CPPUNIT_TEST_SUITE_END();

+

+public:

+ ChatMessageSummarizerTest() {};

+

+ void setUp() {

+

+ }

+

+ void testEmpty() {

+ string current("");

+ vector<UnreadPair> unreads;

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentNone() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentCountOthersNone() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

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

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentCountOtherCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

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

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentNoneOtherCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

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

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentNoneOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

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

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentCountOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

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

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

+ ChatMessageSummarizer summary;

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

+ }

+

+ void testCurrentCountSomeOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

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

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

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

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

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

+ ChatMessageSummarizer summary;

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

+ }

+

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ChatMessageSummarizerTest);

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

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

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

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

+

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

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

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

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

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

+

+using namespace Swift;

+

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

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

+}

+

+XMPPURIController::~XMPPURIController() {

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

+}

+

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

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

+ if (!uri.isNull()) {

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

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

+ }

+ else {

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

+ }

+ }

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

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

+

+namespace Swift {

+ class URIHandler;

+ class JID;

+ class UIEventStream;

+

+ class XMPPURIController {

+ public:

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

+ ~XMPPURIController();

+

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

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

+

+ private:

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

+

+ private:

+ URIHandler* uriHandler;

+ UIEventStream* uiEventStream;

+ };

+}

+swift-open-uri

+ * Copyright (c) 2010-2011 Kevin Smith

+#include "Swift/QtUI/ChatList/ChatListRecentItem.h"

+ }

+ else if (item && dynamic_cast<ChatListRecentItem*>(item)) {

+ return recentSizeHint(option, index);

+ }

+ else if (item && dynamic_cast<ChatListGroupItem*>(item)) {

+QSize ChatListDelegate::recentSizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const {

+ return mucSizeHint(option, index);

+}

+

+ }

+ else if (item && dynamic_cast<ChatListRecentItem*>(item)) {

+ paintRecent(painter, option, dynamic_cast<ChatListRecentItem*>(item));

+ }

+ else if (item && dynamic_cast<ChatListGroupItem*>(item)) {

+ }

+ else {

+ DelegateCommons::drawElidedText(painter, detailRegion, item->data(ChatListMUCItem::DetailTextRole).toString());

+void ChatListDelegate::paintRecent(QPainter* painter, const QStyleOptionViewItem& option, ChatListRecentItem* item) const {

+ painter->save();

+ QRect fullRegion(option.rect);

+ if ( option.state & QStyle::State_Selected ) {

+ painter->fillRect(fullRegion, option.palette.highlight());

+ painter->setPen(option.palette.highlightedText().color());

+ } else {

+ QColor nameColor = item->data(Qt::TextColorRole).value<QColor>();

+ painter->setPen(QPen(nameColor));

+ }

+

+ QFontMetrics nameMetrics(common_.nameFont);

+ painter->setFont(common_.nameFont);

+ int extraFontWidth = nameMetrics.width("H");

+ int leftOffset = common_.horizontalMargin * 2 + extraFontWidth / 2;

+ QRect textRegion(fullRegion.adjusted(leftOffset, 0, 0, 0));

+

+ int nameHeight = nameMetrics.height() + common_.verticalMargin;

+ QRect nameRegion(textRegion.adjusted(0, common_.verticalMargin, 0, 0));

+

+ DelegateCommons::drawElidedText(painter, nameRegion, item->data(Qt::DisplayRole).toString());

+

+ painter->setFont(common_.detailFont);

+ painter->setPen(QPen(QColor(160,160,160)));

+

+ QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

+ DelegateCommons::drawElidedText(painter, detailRegion, item->data(ChatListRecentItem::DetailTextRole).toString());

+

+ painter->restore();

+}

+

+ * Copyright (c) 2010-2011 Kevin Smith

+ class ChatListRecentItem;

+ void paintRecent(QPainter* painter, const QStyleOptionViewItem& option, ChatListRecentItem* item) const;

+ QSize recentSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

+ * Copyright (c) 2010-2011 Kevin Smith

+ ChatListGroupItem(const QString& name, ChatListGroupItem* parent, bool sorted = true) : ChatListItem(parent), name_(name), sorted_(sorted) {};

+ void addItem(ChatListItem* item) {items_.push_back(item); if (sorted_) {qStableSort(items_.begin(), items_.end(), pointerItemLessThan);}};

+ bool sorted_;

+ enum MUCItemRoles {

+ DetailTextRole = Qt::UserRole/*,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2,

+ StatusShowTypeRole = Qt::UserRole + 3*/

+ };

+ * Copyright (c) 2010-2011 Kevin Smith

+#include <Swift/QtUI/ChatList/ChatListModel.h>

+#include <Swift/QtUI/ChatList/ChatListMUCItem.h>

+#include <Swift/QtUI/ChatList/ChatListRecentItem.h>

+ root_ = new ChatListGroupItem("", NULL, false);

+ recents_ = new ChatListGroupItem(tr("Recent Chats"), root_, false);

+ root_->addItem(recents_);

+void ChatListModel::clearBookmarks() {

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

+ emit layoutAboutToBeChanged();

+ recents_->clear();

+ foreach (const ChatListWindow::Chat chat, recents) {

+ recents_->addItem(new ChatListRecentItem(chat, recents_));

+ }

+ emit layoutChanged();

+}

+

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

+#include <Swift/QtUI/ChatList/ChatListGroupItem.h>

+ void clearBookmarks();

+ void setRecents(const std::list<ChatListWindow::Chat>& recents);

+ ChatListGroupItem* recents_;

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <Swift/QtUI/ChatList/ChatListRecentItem.h>

+

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

+

+namespace Swift {

+ChatListRecentItem::ChatListRecentItem(const ChatListWindow::Chat& chat, ChatListGroupItem* parent) : ChatListItem(parent), chat_(chat) {

+

+}

+

+const ChatListWindow::Chat& ChatListRecentItem::getChat() {

+ return chat_;

+}

+

+QVariant ChatListRecentItem::data(int role) const {

+ switch (role) {

+ case Qt::DisplayRole: return P2QSTRING(chat_.chatName);

+ case DetailTextRole: return P2QSTRING(chat_.activity);

+ /*case Qt::TextColorRole: return textColor_;

+ case Qt::BackgroundColorRole: return backgroundColor_;

+ case Qt::ToolTipRole: return isContact() ? toolTipString() : QVariant();

+ case StatusTextRole: return statusText_;

+ case AvatarRole: return avatar_;

+ case PresenceIconRole: return getPresenceIcon();*/

+ default: return QVariant();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <QList>

+

+#include <boost/shared_ptr.hpp>

+

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

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

+

+#include <Swift/QtUI/ChatList/ChatListItem.h>

+

+namespace Swift {

+ class ChatListRecentItem : public ChatListItem {

+ public:

+ enum RecentItemRoles {

+ DetailTextRole = Qt::UserRole/*,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2,

+ StatusShowTypeRole = Qt::UserRole + 3*/

+ };

+ ChatListRecentItem(const ChatListWindow::Chat& chat, ChatListGroupItem* parent);

+ const ChatListWindow::Chat& getChat();

+ QVariant data(int role) const;

+ private:

+ ChatListWindow::Chat chat_;

+ };

+}

+ * Copyright (c) 2010-2011 Kevin Smith

+#include "Swift/QtUI/ChatList/ChatListRecentItem.h"

+#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

+ if (bookmarksEnabled_ && mucItem) {

+ ChatListRecentItem* recentItem = dynamic_cast<ChatListRecentItem*>(item);

+ if (recentItem) {

+ boost::shared_ptr<UIEvent> event;

+ if (recentItem->getChat().isMUC) {

+ if (!bookmarksEnabled_) {

+ return;

+ }

+ return;

+ }

+ else {

+ event = boost::shared_ptr<UIEvent>(new RequestChatUIEvent(recentItem->getChat().jid));

+ }

+ eventStream_->send(event);

+ }

+void QtChatListWindow::clearBookmarks() {

+ model_->clearBookmarks();

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

+ model_->setRecents(recents);

+}

+

+ * Copyright (c) 2010-2011 Kevin Smith

+ void setRecents(const std::list<ChatListWindow::Chat>& recents);

+ void clearBookmarks();

+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+#include <QBoxLayout>

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

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

+

+namespace Swift {

+QtAdHocCommandWindow::QtAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) : command_(command) {

+

+ formWidget_ = NULL;

+

+ setAttribute(Qt::WA_DeleteOnClose);

+ command->onNextStageReceived.connect(boost::bind(&QtAdHocCommandWindow::handleNextStageReceived, this, _1));

+ command->onError.connect(boost::bind(&QtAdHocCommandWindow::handleError, this, _1));

+ command->start();

+

+ QBoxLayout* layout = new QBoxLayout(QBoxLayout::TopToBottom, this);

+ layout->setContentsMargins(0,0,0,0);

+ layout->setSpacing(2);

+ label_ = new QLabel(this);

+ layout->addWidget(label_);

+ QWidget* formContainer = new QWidget(this);

+ layout->addWidget(formContainer);

+ formLayout_ = new QBoxLayout(QBoxLayout::TopToBottom, formContainer);

+ QWidget* buttonsWidget = new QWidget(this);

+ layout->addWidget(buttonsWidget);

+

+ QBoxLayout* buttonsLayout = new QBoxLayout(QBoxLayout::LeftToRight, buttonsWidget);

+ cancelButton_ = new QPushButton(tr("Cancel"), buttonsWidget);

+ buttonsLayout->addWidget(cancelButton_);

+ connect(cancelButton_, SIGNAL(clicked()), this, SLOT(handleCancelClicked()));

+ backButton_ = new QPushButton(tr("Back"), buttonsWidget);

+ buttonsLayout->addWidget(backButton_);

+ connect(backButton_, SIGNAL(clicked()), this, SLOT(handlePrevClicked()));

+ nextButton_ = new QPushButton(tr("Next"), buttonsWidget);

+ buttonsLayout->addWidget(nextButton_);

+ connect(nextButton_, SIGNAL(clicked()), this, SLOT(handleNextClicked()));

+ completeButton_ = new QPushButton(tr("Complete"), buttonsWidget);

+ buttonsLayout->addWidget(completeButton_);

+ connect(completeButton_, SIGNAL(clicked()), this, SLOT(handleCompleteClicked()));

+ nextButton_->setEnabled(false);

+ backButton_->setEnabled(false);

+ completeButton_->setEnabled(false);

+ actions_[Command::Next] = nextButton_;

+ actions_[Command::Prev] = backButton_;

+ actions_[Command::Complete] = completeButton_;

+ actions_[Command::Cancel] = cancelButton_;

+ show();

+}

+

+QtAdHocCommandWindow::~QtAdHocCommandWindow() {

+

+}

+

+void QtAdHocCommandWindow::handleCancelClicked() {

+ command_->cancel();

+}

+

+void QtAdHocCommandWindow::handlePrevClicked() {

+ command_->goBack();

+}

+

+void QtAdHocCommandWindow::handleNextClicked() {

+ command_->goNext(formWidget_ ? formWidget_->getCompletedForm() : Form::ref());

+}

+

+void QtAdHocCommandWindow::handleCompleteClicked() {

+ command_->complete(formWidget_ ? formWidget_->getCompletedForm() : Form::ref());

+}

+

+void QtAdHocCommandWindow::handleNextStageReceived(Command::ref command) {

+ if (command->getForm()) {

+ setForm(command->getForm());

+ } else {

+ setNoForm();

+ }

+ QString notes;

+ foreach (Command::Note note, command->getNotes()) {

+ if (!notes.isEmpty()) {

+ notes += "\n";

+ QString qNote(note.note.c_str());

+ switch (note.type) {

+ case Command::Note::Error: notes += tr("Error: %1").arg(qNote); break;

+ case Command::Note::Warn: notes += tr("Warning: %1").arg(qNote); break;

+ case Command::Note::Info: notes += qNote; break;

+ }

+ }

+ }

+ label_->setText(notes);

+ setAvailableActions(command);

+}

+

+void QtAdHocCommandWindow::handleError(ErrorPayload::ref /*error*/) {

+ nextButton_->setEnabled(false);

+ backButton_->setEnabled(false);

+ completeButton_->setEnabled(false);

+ label_->setText(tr("Error executing command"));

+}

+

+void QtAdHocCommandWindow::setForm(Form::ref form) {

+ delete formWidget_;

+ formWidget_ = new QtFormWidget(form, this);

+ formLayout_->addWidget(formWidget_);

+}

+

+void QtAdHocCommandWindow::setNoForm() {

+ delete formWidget_;

+}

+

+typedef std::pair<Command::Action, QPushButton*> ActionButton;

+

+void QtAdHocCommandWindow::setAvailableActions(Command::ref /*commandResult*/) {

+ foreach (ActionButton pair, actions_) {

+ OutgoingAdHocCommandSession::ActionState state = command_->getActionState(pair.first);

+ if (state & OutgoingAdHocCommandSession::Present) {

+ pair.second->show();

+ }

+ else {

+ pair.second->hide();

+ }

+ if (state & OutgoingAdHocCommandSession::Enabled) {

+ pair.second->setEnabled(true);

+ }

+ else {

+ pair.second->setEnabled(false);

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <QWidget>

+#include <QPushButton>

+#include <QLabel>

+

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

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

+

+class QBoxLayout;

+

+namespace Swift {

+ class QtFormWidget;

+ class QtAdHocCommandWindow : public QWidget, public AdHocCommandWindow {

+ Q_OBJECT

+ public:

+ QtAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command);

+ virtual ~QtAdHocCommandWindow();

+ private:

+ void handleNextStageReceived(Command::ref command);

+ void handleError(ErrorPayload::ref error);

+ void setForm(Form::ref);

+ void setNoForm();

+ void setAvailableActions(Command::ref commandResult);

+ private slots:

+ void handleCancelClicked();

+ void handlePrevClicked();

+ void handleNextClicked();

+ void handleCompleteClicked();

+ private:

+ boost::shared_ptr<OutgoingAdHocCommandSession> command_;

+ QtFormWidget* formWidget_;

+ QBoxLayout* formLayout_;

+ Form::ref form_;

+ QLabel* label_;

+ QPushButton* backButton_;

+ QPushButton* nextButton_;

+ QPushButton* completeButton_;

+ QPushButton* cancelButton_;

+ std::map<Command::Action, QPushButton*> actions_;

+ };

+}

+#include <vector>

+

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

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

+ connect(tabs_, SIGNAL(currentChanged(int)), this, SLOT(handleTabChange(int)), Qt::UniqueConnection);

+

+

+ /* Hide previous opened QtChatWindow, so it doesn't receive further QPaint events. */

+ QWidget* old = tabs_->currentWidget();

+ if (old) {

+ old->hide();

+ }

+

+

+ std::vector<std::pair<std::string, int> > unreads;

+ unreads.push_back(std::pair<std::string, int>(Q2PSTRING(tab->windowTitle()), tab->getCount()));

+ std::string current(Q2PSTRING(qobject_cast<QtTabbable*>(tabs_->currentWidget())->windowTitle()));

+ ChatMessageSummarizer summary;

+ setWindowTitle(summary.getSummary(current, unreads).c_str());

+

+ /* hide() QtChatWindow again, so it won't receive Paint events. */

+ if (widget != tabs_->currentWidget()) {

+ widget->hide();

+ }

+void QtChatTabs::handleTabChange(int index) {

+ if (index == -1) {

+ return;

+ }

+ /* hide() old tab, show() new tab */

+ QWidget* old_tab = tabs_->currentWidget();

+ old_tab->hide();

+

+ QWidget* new_tab = tabs_->widget(index);

+ new_tab->show();

+}

+

+ void handleTabChange(int index);

+void QtChatView::addLastSeenLine() {

+ if (lineSeparator_.isNull()) {

+ lineSeparator_ = newInsertPoint_.clone();

+ lineSeparator_.setInnerXml(QString("<hr/>"));

+ newInsertPoint_.prependOutside(lineSeparator_);

+ }

+ else {

+ QWebElement lineSeparatorC = lineSeparator_.clone();

+ lineSeparatorC.removeFromDocument();

+ }

+ newInsertPoint_.prependOutside(lineSeparator_);

+}

+

+ void addLastSeenLine();

+ QWebElement lineSeparator_;

+

+

+ treeWidget_->setRosterModel(roster);

+ lastLineTracker_.setHasFocus(true);

+ else {

+ lastLineTracker_.setHasFocus(false);

+ }

+ }

+ if (lastLineTracker_.getShouldMoveLastLine()) {

+ /* should this be queued? */

+ messageLog_->addLastSeenLine();

+ /* if the line is added we should break the snippet */

+ appendToPrevious = false;

+ }

+ emit geometryChanged();

+#pragma once

+#include "SwifTools/LastLineTracker.h"

+

+ LastLineTracker lastLineTracker_;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "QtDBUSURIHandler.h"

+

+#include <QDBusAbstractAdaptor>

+#include <QDBusConnection>

+

+#include "QtSwiftUtil.h"

+

+using namespace Swift;

+

+namespace {

+ class DBUSAdaptor: public QDBusAbstractAdaptor {

+ Q_OBJECT

+ Q_CLASSINFO("D-Bus Interface", "im.swift.Swift.URIHandler");

+ public:

+ DBUSAdaptor(QtDBUSURIHandler* uriHandler) : QDBusAbstractAdaptor(uriHandler), uriHandler(uriHandler) {

+ }

+

+ public slots:

+ void openURI(const QString& uri) {

+ uriHandler->onURI(Q2PSTRING(uri));

+ }

+

+ private:

+ QtDBUSURIHandler* uriHandler;

+ };

+}

+

+QtDBUSURIHandler::QtDBUSURIHandler() {

+ new DBUSAdaptor(this);

+ QDBusConnection connection = QDBusConnection::sessionBus();

+ connection.registerService("im.swift.Swift.URIHandler");

+ connection.registerObject("/", this);

+}

+

+#include "QtDBUSURIHandler.moc"

+/*

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

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

+

+namespace Swift {

+ class QtDBUSURIHandler : public QObject, public URIHandler {

+ public:

+ QtDBUSURIHandler();

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <QGridLayout>

+#include <QLabel>

+#include <QListWidget>

+#include <QLineEdit>

+#include <QTextEdit>

+#include <QCheckBox>

+#include <QScrollArea>

+

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

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

+

+namespace Swift {

+

+QtFormWidget::QtFormWidget(Form::ref form, QWidget* parent) : QWidget(parent), form_(form) {

+ QGridLayout* thisLayout = new QGridLayout(this);

+ int row = 0;

+ if (!form->getTitle().empty()) {

+ QLabel* instructions = new QLabel(("<b>" + form->getTitle() + "</b>").c_str(), this);

+ thisLayout->addWidget(instructions, row++, 0, 1, 2);

+ }

+ if (!form->getInstructions().empty()) {

+ QLabel* instructions = new QLabel(form->getInstructions().c_str(), this);

+ thisLayout->addWidget(instructions, row++, 0, 1, 2);

+ }

+ QScrollArea* scrollArea = new QScrollArea(this);

+ thisLayout->addWidget(scrollArea);

+ QWidget* scroll = new QWidget(this);

+ QGridLayout* layout = new QGridLayout(scroll);

+ foreach (boost::shared_ptr<FormField> field, form->getFields()) {

+ QWidget* widget = createWidget(field);

+ if (widget) {

+ layout->addWidget(new QLabel(field->getLabel().c_str(), this), row, 0);

+ layout->addWidget(widget, row++, 1);

+ }

+ }

+ scrollArea->setWidget(scroll);

+ scrollArea->setWidgetResizable(true);

+}

+

+QtFormWidget::~QtFormWidget() {

+

+}

+

+QListWidget* QtFormWidget::createList(FormField::ref field) {

+ QListWidget* listWidget = new QListWidget(this);

+ listWidget->setSortingEnabled(false);

+ listWidget->setSelectionMode(boost::dynamic_pointer_cast<ListMultiFormField>(field) ? QAbstractItemView::MultiSelection : QAbstractItemView::SingleSelection);

+ foreach (FormField::Option option, field->getOptions()) {

+ listWidget->addItem(option.label.c_str());

+ }

+ boost::shared_ptr<ListMultiFormField> listMultiField = boost::dynamic_pointer_cast<ListMultiFormField>(field);

+ boost::shared_ptr<ListSingleFormField> listSingleField = boost::dynamic_pointer_cast<ListSingleFormField>(field);

+ for (int i = 0; i < listWidget->count(); i++) {

+ QListWidgetItem* item = listWidget->item(i);

+ bool selected = false;

+ if (listSingleField) {

+ selected = (item->text() == QString(listSingleField->getValue().c_str()));

+ }

+ else if (listMultiField) {

+ std::string text = Q2PSTRING(item->text());

+ selected = (std::find(listMultiField->getValue().begin(), listMultiField->getValue().end(), text) != listMultiField->getValue().end());

+ }

+ item->setSelected(selected);

+ }

+ return listWidget;

+}

+

+QWidget* QtFormWidget::createWidget(FormField::ref field) {

+ QWidget* widget = NULL;

+ boost::shared_ptr<BooleanFormField> booleanField = boost::dynamic_pointer_cast<BooleanFormField>(field);

+ if (booleanField) {

+ QCheckBox* checkWidget = new QCheckBox(this);

+ checkWidget->setCheckState(booleanField->getValue() ? Qt::Checked : Qt::Unchecked);

+ widget = checkWidget;

+ }

+ boost::shared_ptr<FixedFormField> fixedField = boost::dynamic_pointer_cast<FixedFormField>(field);

+ if (fixedField) {

+ QString value = fixedField->getValue().c_str();

+ widget = new QLabel(value, this);

+ }

+ boost::shared_ptr<ListSingleFormField> listSingleField = boost::dynamic_pointer_cast<ListSingleFormField>(field);

+ if (listSingleField) {

+ widget = createList(field);

+ }

+ boost::shared_ptr<TextMultiFormField> textMultiField = boost::dynamic_pointer_cast<TextMultiFormField>(field);

+ if (textMultiField) {

+ QString value = textMultiField->getValue().c_str();

+ widget = new QTextEdit(value, this);

+ }

+ boost::shared_ptr<TextPrivateFormField> textPrivateField = boost::dynamic_pointer_cast<TextPrivateFormField>(field);

+ if (textPrivateField) {

+ QString value = textPrivateField->getValue().c_str();

+ QLineEdit* lineWidget = new QLineEdit(value, this);

+ lineWidget->setEchoMode(QLineEdit::Password);

+ widget = lineWidget;

+ }

+ boost::shared_ptr<TextSingleFormField> textSingleField = boost::dynamic_pointer_cast<TextSingleFormField>(field);

+ if (textSingleField) {

+ QString value = textSingleField->getValue().c_str();

+ widget = new QLineEdit(value, this);

+ }

+ boost::shared_ptr<JIDSingleFormField> jidSingleField = boost::dynamic_pointer_cast<JIDSingleFormField>(field);

+ if (jidSingleField) {

+ QString value = jidSingleField->getValue().toString().c_str();

+ widget = new QLineEdit(value, this);

+ }

+ boost::shared_ptr<JIDMultiFormField> jidMultiField = boost::dynamic_pointer_cast<JIDMultiFormField>(field);

+ if (jidMultiField) {

+ QString text;

+ bool prev = false;

+ foreach (JID line, jidMultiField->getValue()) {

+ if (prev) {

+ text += "\n";

+ }

+ prev = true;

+ text += line.toString().c_str();

+ }

+ widget = new QTextEdit(text, this);

+ }

+ boost::shared_ptr<ListMultiFormField> listMultiField = boost::dynamic_pointer_cast<ListMultiFormField>(field);

+ if (listMultiField) {

+ widget = createList(field);

+ }

+ boost::shared_ptr<HiddenFormField> hiddenField = boost::dynamic_pointer_cast<HiddenFormField>(field);

+ if (hiddenField) {

+ }

+ fields_[field->getName()] = widget;

+ return widget;

+}

+

+Form::ref QtFormWidget::getCompletedForm() {

+ Form::ref result(new Form(Form::SubmitType));

+ foreach (boost::shared_ptr<FormField> field, form_->getFields()) {

+ boost::shared_ptr<FormField> resultField;

+ boost::shared_ptr<BooleanFormField> booleanField = boost::dynamic_pointer_cast<BooleanFormField>(field);

+ if (booleanField) {

+ resultField = FormField::ref(BooleanFormField::create(qobject_cast<QCheckBox*>(fields_[field->getName()])->checkState() == Qt::Checked));

+ }

+ boost::shared_ptr<FixedFormField> fixedField = boost::dynamic_pointer_cast<FixedFormField>(field);

+ if (fixedField) {

+ resultField = FormField::ref(FixedFormField::create(fixedField->getValue()));

+ }

+ boost::shared_ptr<ListSingleFormField> listSingleField = boost::dynamic_pointer_cast<ListSingleFormField>(field);

+ if (listSingleField) {

+ QListWidget* listWidget = qobject_cast<QListWidget*>(fields_[field->getName()]);

+ if (listWidget->selectedItems().size() > 0) {

+ int i = listWidget->row(listWidget->selectedItems()[0]);

+ resultField = FormField::ref(ListSingleFormField::create(field->getOptions()[i].value));

+ }

+ else {

+ resultField = FormField::ref(ListSingleFormField::create());

+ }

+ }

+ boost::shared_ptr<TextMultiFormField> textMultiField = boost::dynamic_pointer_cast<TextMultiFormField>(field);

+ if (textMultiField) {

+ QTextEdit* widget = qobject_cast<QTextEdit*>(fields_[field->getName()]);

+ QString string = widget->toPlainText();

+ if (string.isEmpty()) {

+ resultField = FormField::ref(TextMultiFormField::create());

+ }

+ else {

+ resultField = FormField::ref(TextMultiFormField::create(Q2PSTRING(string)));

+ }

+ }

+ boost::shared_ptr<TextPrivateFormField> textPrivateField = boost::dynamic_pointer_cast<TextPrivateFormField>(field);

+ if (textPrivateField) {

+ QLineEdit* widget = qobject_cast<QLineEdit*>(fields_[field->getName()]);

+ QString string = widget->text();

+ if (string.isEmpty()) {

+ resultField = FormField::ref(TextPrivateFormField::create());

+ }

+ else {

+ resultField = FormField::ref(TextPrivateFormField::create(Q2PSTRING(string)));

+ }

+ }

+ boost::shared_ptr<TextSingleFormField> textSingleField = boost::dynamic_pointer_cast<TextSingleFormField>(field);

+ if (textSingleField) {

+ QLineEdit* widget = qobject_cast<QLineEdit*>(fields_[field->getName()]);

+ QString string = widget->text();

+ if (string.isEmpty()) {

+ resultField = FormField::ref(TextSingleFormField::create());

+ }

+ else {

+ resultField = FormField::ref(TextSingleFormField::create(Q2PSTRING(string)));

+ }

+ }

+ boost::shared_ptr<JIDSingleFormField> jidSingleField = boost::dynamic_pointer_cast<JIDSingleFormField>(field);

+ if (jidSingleField) {

+ QLineEdit* widget = qobject_cast<QLineEdit*>(fields_[field->getName()]);

+ QString string = widget->text();

+ JID jid(Q2PSTRING(string));

+ if (string.isEmpty()) {

+ resultField = FormField::ref(JIDSingleFormField::create());

+ }

+ else {

+ resultField = FormField::ref(JIDSingleFormField::create(jid));

+ }

+ }

+ boost::shared_ptr<JIDMultiFormField> jidMultiField = boost::dynamic_pointer_cast<JIDMultiFormField>(field);

+ if (jidMultiField) {

+ QTextEdit* widget = qobject_cast<QTextEdit*>(fields_[field->getName()]);

+ QString string = widget->toPlainText();

+ if (string.isEmpty()) {

+ resultField = FormField::ref(JIDMultiFormField::create());

+ }

+ else {

+ QStringList lines = string.split("\n");

+ std::vector<JID> value;

+ foreach (QString line, lines) {

+ value.push_back(JID(Q2PSTRING(line)));

+ }

+ resultField = FormField::ref(JIDMultiFormField::create(value));

+ }

+ }

+ boost::shared_ptr<ListMultiFormField> listMultiField = boost::dynamic_pointer_cast<ListMultiFormField>(field);

+ if (listMultiField) {

+ QListWidget* listWidget = qobject_cast<QListWidget*>(fields_[field->getName()]);

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

+ foreach (QListWidgetItem* item, listWidget->selectedItems()) {

+ values.push_back(field->getOptions()[listWidget->row(item)].value);

+ }

+ resultField = FormField::ref(ListMultiFormField::create(values));

+ }

+ boost::shared_ptr<HiddenFormField> hiddenField = boost::dynamic_pointer_cast<HiddenFormField>(field);

+ if (hiddenField) {

+ resultField = FormField::ref(HiddenFormField::create(hiddenField->getValue()));

+ }

+ resultField->setName(field->getName());

+ result->addField(resultField);

+ }

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <QWidget>

+

+#include <map>

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

+

+class QListWidget;

+

+namespace Swift {

+

+class QtFormWidget : public QWidget {

+ Q_OBJECT

+ public:

+ QtFormWidget(Form::ref form, QWidget* parent = NULL);

+ virtual ~QtFormWidget();

+ Form::ref getCompletedForm();

+ private:

+ QWidget* createWidget(FormField::ref field);

+ QListWidget* createList(FormField::ref field);

+ std::map<std::string, QWidget*> fields_;

+ Form::ref form_;

+};

+

+}

+ * Copyright (c) 2010-2011 Kevin Smith

+ loginWidgetWrapper_ = new QWidget(this);

+ loginWidgetWrapper_->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

+ QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, loginWidgetWrapper_);

+ stack_->addWidget(loginWidgetWrapper_);

+ stack_->removeWidget(stack_->currentWidget());

+ stack_->addWidget(loginWidgetWrapper_);

+ stack_->setCurrentWidget(loginWidgetWrapper_);

+ stack_->removeWidget(loginWidgetWrapper_);

+ * Copyright (c) 2010-2011 Kevin Smith

+#pragma once

+ QWidget* loginWidgetWrapper_;

+ * Copyright (c) 2010-2011 Kevin Smith

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

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

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

+#include <Roster/QtTreeWidget.h>

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

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

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

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

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

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

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

+#define CURRENT_ROSTER_TAB "current_roster_tab"

+

+ settings_ = settings;

+ tabs_->addTab(eventWindow_, tr("&Notices"));

+

+ tabs_->setCurrentIndex(settings_->getIntSetting(CURRENT_ROSTER_TAB, 0));

+

+ connect(tabs_, SIGNAL(currentChanged(int)), this, SLOT(handleTabChanged(int)));

+ serverAdHocMenu_ = new QMenu(tr("Run Server Command"), this);

+ actionsMenu->addMenu(serverAdHocMenu_);

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

+ QAction* adHocAction = new QAction(tr("Collecting commands..."), this);

+ adHocAction->setEnabled(false);

+ serverAdHocMenu_->addAction(adHocAction);

+ serverAdHocCommandActions_.append(adHocAction);

+

+void QtMainWindow::handleTabChanged(int index) {

+ settings_->storeInt(CURRENT_ROSTER_TAB, index);

+}

+

+ int eventIndex = 2;

+void QtMainWindow::handleAdHocActionTriggered(bool /*checked*/) {

+ QAction* action = qobject_cast<QAction*>(sender());

+ assert(action);

+ DiscoItems::Item command = serverAdHocCommands_[serverAdHocCommandActions_.indexOf(action)];

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestAdHocUIEvent(command)));

+}

+

+void QtMainWindow::setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) {

+ serverAdHocCommands_ = commands;

+ foreach (QAction* action, serverAdHocCommandActions_) {

+ delete action;

+ }

+ serverAdHocMenu_->clear();

+ serverAdHocCommandActions_.clear();

+ foreach (DiscoItems::Item command, commands) {

+ QAction* action = new QAction(P2QSTRING(command.getName()), this);

+ connect(action, SIGNAL(triggered(bool)), this, SLOT(handleAdHocActionTriggered(bool)));

+ serverAdHocMenu_->addAction(action);

+ serverAdHocCommandActions_.append(action);

+ }

+ if (serverAdHocCommandActions_.isEmpty()) {

+ QAction* action = new QAction(tr("No Available Commands"), this);

+ action->setEnabled(false);

+ serverAdHocMenu_->addAction(action);

+ serverAdHocCommandActions_.append(action);

+ }

+}

+ * Copyright (c) 2010-2011 Kevin Smith

+#include <QList>

+class QMenu;

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

+ void handleAdHocActionTriggered(bool checked);

+ void handleTabChanged(int index);

+ QtSettingsProvider* settings_;

+ QMenu* serverAdHocMenu_;

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

+ QList<QAction*> serverAdHocCommandActions_;

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

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

+

+#elif defined(HAVE_GROWL)

+

+#else

+#endif

+

+#if defined(SWIFTEN_PLATFORM_MACOSX)

+#include "QtURIHandler.h"

+#elif defined(SWIFTEN_PLATFORM_WIN32)

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

+#else

+#include "QtDBUSURIHandler.h"

+#endif

+#if defined(SWIFTEN_PLATFORM_MACOSX)

+ uriHandler_ = new QtURIHandler();

+#elif defined(SWIFTEN_PLATFORM_WIN32)

+ uriHandler_ = new NullURIHandler();

+#else

+ uriHandler_ = new QtDBUSURIHandler();

+#endif

+

+ uriHandler_,

+ delete uriHandler_;

+ class URIHandler;

+ URIHandler* uriHandler_;

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

+ }

+ else if (((key == Qt::Key_PageUp || key == Qt::Key_PageDown) && modifiers == Qt::ShiftModifier)

+ }

+ else {

+#include "QtAdHocCommandWindow.h"

+void QtUIFactory::createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) {

+ new QtAdHocCommandWindow(command);

+}

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

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "QtURIHandler.h"

+

+#include <QCoreApplication>

+#include <QFileOpenEvent>

+#include <QUrl>

+

+#include "QtSwiftUtil.h"

+#ifdef Q_WS_MAC

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

+#endif

+

+using namespace Swift;

+

+QtURIHandler::QtURIHandler() {

+ qApp->installEventFilter(this);

+#ifdef Q_WS_MAC

+ registerAppAsDefaultXMPPURIHandler();

+#endif

+}

+

+bool QtURIHandler::eventFilter(QObject*, QEvent* event) {

+ if (event->type() == QEvent::FileOpen) {

+ QFileOpenEvent* fileOpenEvent = static_cast<QFileOpenEvent*>(event);

+ if (fileOpenEvent->url().scheme() == "xmpp") {

+ onURI(Q2PSTRING(fileOpenEvent->url().toString()));

+ return true;

+ }

+ }

+ return false;

+}

+/*

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

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

+

+class QUrl;

+

+namespace Swift {

+ class QtURIHandler : public QObject, public URIHandler {

+ public:

+ QtURIHandler();

+

+ private:

+ bool eventFilter(QObject* obj, QEvent* event);

+ };

+}

+ "QtURIHandler.cpp",

+ "QtAdHocCommandWindow.cpp",

+ "QtFormWidget.cpp",

+ "ChatList/ChatListRecentItem.cpp",

+ res = myenv.RES("../resources/Windows/Swift.rc")

+ # For some reason, SCons isn't picking up the dependency correctly

+ # Adding it explicitly until i figure out why

+ myenv.Depends(res, "../Controllers/BuildVersion.h")

+ sources += [

+ "FreeDesktopNotifier.cpp",

+ "QtDBUSURIHandler.cpp",

+ ]

+if env["PLATFORM"] != "darwin" and env["PLATFORM"] != "win32" :

+ openURIProgram = myenv.Program("swift-open-uri", "swift-open-uri.cpp")

+else :

+ openURIProgram = []

+

+ app = myenv.AppBundle("Swift", version = myenv["SWIFT_VERSION"], resources = commonResources, frameworks = frameworks, handlesXMPPURIs = True)

+ env.Install(os.path.join(env["SWIFT_INSTALLDIR"], "bin"), swiftProgram + openURIProgram)

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <QCoreApplication>

+#include <QDBusConnection>

+#include <QDBusMessage>

+#include <iostream>

+

+int main(int argc, char* argv[]) {

+ QCoreApplication app(argc, argv);

+

+ QDBusConnection bus = QDBusConnection::sessionBus();

+ if (!bus.isConnected()) {

+ return -1;

+ }

+ if (argc != 2) {

+ std::cerr << "Usage: " << argv[0] << " uri" << std::endl;

+ return -1;

+ }

+

+ QDBusMessage msg = QDBusMessage::createMethodCall("im.swift.Swift.URIHandler", "/", "im.swift.Swift.URIHandler", "openURI");

+ msg << argv[1];

+

+ bus.call(msg);

+

+ return 0;

+}

+ <message>

+ <source>%1% (%2%)</source>

+ <translation>%1% (%2%)</translation>

+ </message>

+ <message>

+ <source>%1% and %2% others (%3%)</source>

+ <translation>%1% en %2% anderen (%3%)</translation>

+ </message>

+ <message>

+ <source>%1%, %2% (%3%)</source>

+ <translation>%1%, %2% (%3%)</translation>

+ </message>

+ <message>

+ <source>User address invalid. User address should be of the form &apos;alice@wonderland.lit&apos;</source>

+ <translation>Gebruikersadres ongeldig. Gebruikersadres moet van de vorm &apos;alice@wonderland.lit&apos; zijn</translation>

+ </message>

+ <message>

+ <source>Recent Chats</source>

+ <translation>Recente conversaties</translation>

+ </message>

+ <name>Swift::QtAdHocCommandWindow</name>

+ <message>

+ <source>Cancel</source>

+ <translation>Annuleren</translation>

+ </message>

+ <message>

+ <source>Back</source>

+ <translation>Terug</translation>

+ </message>

+ <message>

+ <source>Next</source>

+ <translation>Volgende</translation>

+ </message>

+ <message>

+ <source>Complete</source>

+ <translation>Voltooien</translation>

+ </message>

+ <message>

+ <source>Error: %1</source>

+ <translation>Fout: %1</translation>

+ </message>

+ <message>

+ <source>Warning: %1</source>

+ <translation>Waarschuwing: %1</translation>

+ </message>

+ <message>

+ <source>Error executing command</source>

+ <translation>Fout bij het uitvoeren van de opdracht</translation>

+ </message>

+</context>

+<context>

+ <message>

+ <source>Run Server Command</source>

+ <translation>Voer opdracht op server uit</translation>

+ </message>

+ <message>

+ <source>Collecting commands...</source>

+ <translation>Opdrachten aan het verzamelen...</translation>

+ </message>

+ <message>

+ <source>No Available Commands</source>

+ <translation>Geen beschikbare opdrachten</translation>

+ </message>