+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

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

+

+#include <boost/bind.hpp>

+

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

+

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

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

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

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

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

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

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

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

+

+namespace Swift {

+

+BlockListController::BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController) : blockListManager_(blockListManager), blockListEditorWidgetFactory_(blockListEditorWidgetFactory), blockListEditorWidget_(0), eventController_(eventController), remainingRequests_(0) {

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

+ blockListManager_->getBlockList()->onItemAdded.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ blockListManager_->getBlockList()->onItemRemoved.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

+}

+

+BlockListController::~BlockListController() {

+ blockListManager_->getBlockList()->onItemAdded.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ blockListManager_->getBlockList()->onItemRemoved.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

+}

+

+void BlockListController::blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID> &jidsToUnblock, std::vector<JID> &jidsToBlock) const {

+ foreach (const JID& jid, blockListBeforeEdit) {

+ if (std::find(newBlockList.begin(), newBlockList.end(), jid) == newBlockList.end()) {

+ jidsToUnblock.push_back(jid);

+ }

+ }

+

+ foreach (const JID& jid, newBlockList) {

+ if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

+ jidsToBlock.push_back(jid);

+ }

+ }

+}

+

+void BlockListController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

+ // handle UI dialog

+ boost::shared_ptr<RequestBlockListDialogUIEvent> requestDialogEvent = boost::dynamic_pointer_cast<RequestBlockListDialogUIEvent>(rawEvent);

+ if (requestDialogEvent != NULL) {

+ if (blockListEditorWidget_ == NULL) {

+ blockListEditorWidget_ = blockListEditorWidgetFactory_->createBlockListEditorWidget();

+ blockListEditorWidget_->onSetNewBlockList.connect(boost::bind(&BlockListController::handleSetNewBlockList, this, _1));

+ }

+ blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

+ blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

+ blockListEditorWidget_->show();

+ return;

+ }

+

+ // handle block state change

+ boost::shared_ptr<RequestChangeBlockStateUIEvent> changeStateEvent = boost::dynamic_pointer_cast<RequestChangeBlockStateUIEvent>(rawEvent);

+ if (changeStateEvent != NULL) {

+ if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Blocked) {

+ GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDRequest(changeStateEvent->getContact());

+ blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

+ blockRequest->send();

+ } else if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Unblocked) {

+ GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDRequest(changeStateEvent->getContact());

+ unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

+ unblockRequest->send();

+ }

+ return;

+ }

+}

+

+void BlockListController::handleBlockResponse(GenericRequest<BlockPayload>::ref request, boost::shared_ptr<BlockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor) {

+ if (error) {

+ std::string errorMessage;

+ // FIXME: Handle reporting of list of JIDs in a translatable way.

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Failed to block %1%.")) % jids.at(0).toString());

+ if (!error->getText().empty()) {

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "%1%: %2%.")) % errorMessage % error->getText());

+ }

+ eventController_->handleIncomingEvent(boost::make_shared<ErrorEvent>(request->getReceiver(), errorMessage));

+ }

+ if (originEditor) {

+ remainingRequests_--;

+ if (blockListEditorWidget_ && (remainingRequests_ == 0)) {

+ blockListEditorWidget_->setBusy(false);

+ }

+ }

+}

+

+void BlockListController::handleUnblockResponse(GenericRequest<UnblockPayload>::ref request, boost::shared_ptr<UnblockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor) {

+ if (error) {

+ std::string errorMessage;

+ // FIXME: Handle reporting of list of JIDs in a translatable way.

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Failed to unblock %1%.")) % jids.at(0).toString());

+ if (!error->getText().empty()) {

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "%1%: %2%.")) % errorMessage % error->getText());

+ }

+ eventController_->handleIncomingEvent(boost::make_shared<ErrorEvent>(request->getReceiver(), errorMessage));

+ }

+ if (originEditor) {

+ remainingRequests_--;

+ if (blockListEditorWidget_ && (remainingRequests_ == 0)) {

+ blockListEditorWidget_->setBusy(false);

+ }

+ }

+}

+

+void BlockListController::handleSetNewBlockList(const std::vector<JID> &newBlockList) {

+ std::vector<JID> jidsToBlock;

+ std::vector<JID> jidsToUnblock;

+

+ blockListDifferences(newBlockList, jidsToUnblock, jidsToBlock);

+

+ if (!jidsToBlock.empty()) {

+ remainingRequests_++;

+ GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDsRequest(jidsToBlock);

+ blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, jidsToBlock, true));

+ blockRequest->send();

+ }

+ if (!jidsToUnblock.empty()) {

+ remainingRequests_++;

+ GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDsRequest(jidsToUnblock);

+ unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, jidsToUnblock, true));

+ unblockRequest->send();

+ }

+ if (!jidsToBlock.empty() || jidsToUnblock.empty()) {

+ assert(blockListEditorWidget_);

+ blockListEditorWidget_->setBusy(true);

+ }

+}

+

+void BlockListController::handleBlockListChanged() {

+ if (blockListEditorWidget_) {

+ std::vector<JID> jidsToBlock;

+ std::vector<JID> jidsToUnblock;

+

+ blockListDifferences(blockListEditorWidget_->getCurrentBlockList(), jidsToUnblock, jidsToBlock);

+ blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

+

+ foreach (const JID& jid, jidsToBlock) {

+ blockListBeforeEdit.push_back(jid);

+ }

+

+ foreach (const JID& jid, jidsToUnblock) {

+ blockListBeforeEdit.erase(std::remove(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid), blockListBeforeEdit.end());;

+ }

+

+ blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

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

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

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

+

+namespace Swift {

+

+class BlockPayload;

+class UnblockPayload;

+class ClientBlockListManager;

+class EventController;

+

+class BlockListController {

+public:

+ BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController);

+ ~BlockListController();

+

+private:

+ void blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID>& jidsToUnblock, std::vector<JID>& jidsToBlock) const;

+

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

+

+ void handleBlockResponse(GenericRequest<BlockPayload>::ref, boost::shared_ptr<BlockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor);

+ void handleUnblockResponse(GenericRequest<UnblockPayload>::ref, boost::shared_ptr<UnblockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor);

+

+ void handleSetNewBlockList(const std::vector<JID>& newBlockList);

+

+ void handleBlockListChanged();

+

+private:

+ ClientBlockListManager* blockListManager_;

+ BlockListEditorWidgetFactory* blockListEditorWidgetFactory_;

+ BlockListEditorWidget* blockListEditorWidget_;

+ EventController* eventController_;

+ std::vector<JID> blockListBeforeEdit;

+ int remainingRequests_;

+};

+

+}

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

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

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

+void ChatController::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

+ ChatControllerBase::setAvailableServerFeatures(info);

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

+ boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+

+ blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+ blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingItemAdded, this, _1));

+ blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingItemRemoved, this, _1));

+

+ handleBlockingStateChanged();

+ }

+}

+

+void ChatController::handleBlockingStateChanged() {

+ boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+ if (blockList->getState() == BlockList::Available) {

+ if (blockList->isBlocked(toJID_.toBare())) {

+ chatWindow_->setAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));

+ chatWindow_->setInputEnabled(false);

+ chatWindow_->setBlockingState(ChatWindow::IsBlocked);

+ } else {

+ chatWindow_->setBlockingState(ChatWindow::IsUnblocked);

+ }

+ }

+}

+

+void ChatController::handleBlockingItemAdded(const JID& jid) {

+ if (jid == toJID_.toBare()) {

+ chatWindow_->setAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));

+ chatWindow_->setInputEnabled(false);

+ chatWindow_->setBlockingState(ChatWindow::IsBlocked);

+ }

+}

+

+void ChatController::handleBlockingItemRemoved(const JID& jid) {

+ if (jid == toJID_.toBare()) {

+ // FIXME: Support for different types of alerts.

+ chatWindow_->cancelAlert();

+ chatWindow_->setInputEnabled(true);

+ chatWindow_->setBlockingState(ChatWindow::IsUnblocked);

+ }

+}

+

+ class ClientBlockListManager;

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

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

+ void handleBlockingStateChanged();

+ void handleBlockingItemAdded(const JID&);

+ void handleBlockingItemRemoved(const JID&);

+

+

+ ClientBlockListManager* clientBlockListManager_;

+ boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemAddedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;

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

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

+ HighlightManager* highlightManager,

+ ClientBlockListManager* clientBlockListManager) :

+ highlightManager_(highlightManager),

+ clientBlockListManager_(clientBlockListManager) {

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

+ class ClientBlockListManager;

+ 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* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager);

+ ClientBlockListManager* clientBlockListManager_;

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

+

+#include <Swift/Controllers/Chat/UnitTest/MockChatListWindow.h>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+#include <Swiften/VCards/VCardManager.h>

+#include <Swiften/VCards/VCardMemoryStorage.h>

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

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

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

+#include <Swift/Controllers/UnitTest/MockChatWindow.h>

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

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

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

+#include <Swiften/Jingle/JingleSessionManager.h>

+#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

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

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

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

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

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

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

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

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

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

+ delete clientBlockListManager_;

+ ClientBlockListManager* clientBlockListManager_;

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

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

+ blockListController_ = NULL;

+ rosterController_ = new RosterController(jid_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), ftOverview_, client_->getClientBlockListManager());

+ blockListController_ = new BlockListController(client_->getClientBlockListManager(), uiEventStream_, uiFactory_, eventController_);

+

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

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

+ if (info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

+ rosterController_->getWindow()->setBlockingCommandAvailable(true);

+ rosterController_->initBlockingCommand();

+ }

+ class BlockListController;

+ BlockListController* blockListController_;

+ContactRosterItem::ContactRosterItem(const JID& jid, const JID& displayJID, const std::string& name, GroupRosterItem* parent) : RosterItem(name, parent), jid_(jid), displayJID_(displayJID), blockState_(BlockingNotSupported) {

+void ContactRosterItem::setBlockState(BlockState state) {

+ blockState_ = state;

+}

+

+ContactRosterItem::BlockState ContactRosterItem::blockState() const {

+ return blockState_;

+}

+

+

+ enum BlockState {

+ BlockingNotSupported,

+ IsBlocked,

+ IsUnblocked

+ };

+ void setBlockState(BlockState state);

+ BlockState blockState() const;

+

+ BlockState blockState_;

+Roster::Roster(bool sortByStatus, bool fullJIDMapping) : blockingSupported_(false) {

+void Roster::setBlockedState(const std::vector<JID> &jids, ContactRosterItem::BlockState state) {

+ if (!blockingSupported_ ) {

+ foreach(ItemMap::value_type i, itemMap_) {

+ foreach(ContactRosterItem* item, i.second) {

+ item->setBlockState(ContactRosterItem::IsUnblocked);

+ }

+ }

+ }

+

+ foreach(const JID& jid, jids) {

+ ItemMap::const_iterator i = itemMap_.find(fullJIDMapping_ ? jid : jid.toBare());

+ if (i == itemMap_.end()) {

+ continue;

+ }

+ foreach(ContactRosterItem* item, i->second) {

+ item->setBlockState(state);

+ }

+ }

+

+ blockingSupported_ = true;

+}

+

+ if (blockingSupported_) {

+ item->setBlockState(ContactRosterItem::IsUnblocked);

+ }

+ void setBlockedState(const std::vector<JID>& jids, ContactRosterItem::BlockState state);

+ bool blockingSupported_;

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

+RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, FileTransferOverview* fileTransferOverview, ClientBlockListManager* clientBlockListManager)

+ : myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), nickManager_(nickManager), nickResolver_(nickResolver), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview), clientBlockListManager_(clientBlockListManager) {

+void RosterController::handleBlockingStateChanged() {

+ if (clientBlockListManager_->getBlockList()->getState() == BlockList::Available) {

+ roster_->setBlockedState(clientBlockListManager_->getBlockList()->getItems(), ContactRosterItem::IsBlocked);

+ }

+}

+

+void RosterController::handleBlockingItemAdded(const JID& jid) {

+ roster_->setBlockedState(std::vector<JID>(1, jid), ContactRosterItem::IsBlocked);

+}

+

+void RosterController::handleBlockingItemRemoved(const JID& jid) {

+ roster_->setBlockedState(std::vector<JID>(1, jid), ContactRosterItem::IsUnblocked);

+}

+

+void RosterController::initBlockingCommand() {

+ boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+

+ blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&RosterController::handleBlockingStateChanged, this));

+ blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&RosterController::handleBlockingItemAdded, this, _1));

+ blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&RosterController::handleBlockingItemRemoved, this, _1));

+

+ if (blockList->getState() == BlockList::Available) {

+ roster_->setBlockedState(blockList->getItems(), ContactRosterItem::IsBlocked);

+ }

+}

+

+ class ClientBlockListManager;

+

+ RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, FileTransferOverview* fileTransferOverview, ClientBlockListManager* clientBlockListManager);

+ void initBlockingCommand();

+

+ void handleBlockingStateChanged();

+ void handleBlockingItemAdded(const JID& jid);

+ void handleBlockingItemRemoved(const JID& jid);

+

+ ClientBlockListManager* clientBlockListManager_;

+ boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemAddedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;

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

+ clientBlockListManager_ = new ClientBlockListManager(router_);

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, ftOverview_, clientBlockListManager_);

+ delete clientBlockListManager_;

+ ClientBlockListManager* clientBlockListManager_;

+ "BlockListController.cpp",

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+

+class RequestBlockListDialogUIEvent : public UIEvent {

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

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

+

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

+

+namespace Swift {

+

+class RequestChangeBlockStateUIEvent : public UIEvent {

+ public:

+ enum BlockState {

+ Blocked,

+ Unblocked

+ };

+

+ public:

+ RequestChangeBlockStateUIEvent(BlockState newState, const JID& contact) : state_(newState), contact_(contact) {}

+

+ BlockState getBlockState() const {

+ return state_;

+ }

+

+ JID getContact() const {

+ return contact_;

+ }

+ private:

+ BlockState state_;

+ JID contact_;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+

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

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

+

+namespace Swift {

+

+ class ClientBlockListManager;

+

+ class BlockListEditorWidget {

+ public:

+ virtual ~BlockListEditorWidget() {}

+

+ virtual void show() = 0;

+

+ virtual void setCurrentBlockList(const std::vector<JID>& blockedJIDs) = 0;

+ virtual void setBusy(bool isBusy) = 0;

+

+ virtual std::vector<JID> getCurrentBlockList() const = 0;

+

+ boost::signal<void (const std::vector<JID>& /* blockedJID */)> onSetNewBlockList;

+ };

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+

+ class BlockListEditorWidget;

+

+ class BlockListEditorWidgetFactory {

+ public:

+ virtual ~BlockListEditorWidgetFactory() {}

+

+ virtual BlockListEditorWidget* createBlockListEditorWidget() = 0;

+ };

+

+}

+ enum BlockingState {BlockingUnsupported, IsBlocked, IsUnblocked};

+ virtual void setBlockingState(BlockingState state) = 0;

+ virtual void setBlockingCommandAvailable(bool isAvailable) = 0;

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

+ public HighlightEditorWidgetFactory,

+ public BlockListEditorWidgetFactory {

+ virtual void setBlockingState(BlockingState) {}

+

+ virtual void setBlockingCommandAvailable(bool /*isAvailable*/) {}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <QtBlockListEditorWindow.h>

+#include <ui_QtBlockListEditorWindow.h>

+

+#include <boost/bind.hpp>

+

+#include <QLineEdit>

+#include <QMovie>

+#include <QShortcut>

+#include <QStyledItemDelegate>

+#include <QValidator>

+

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

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

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

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

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

+

+namespace Swift {

+

+class QtJIDValidator : public QValidator {

+ public:

+ QtJIDValidator(QObject* parent) : QValidator(parent) {}

+ virtual ~QtJIDValidator() {}

+ virtual QValidator::State validate(QString& input, int&) const {

+ return JID(Q2PSTRING(input)).isValid() ? Acceptable : Intermediate;

+ }

+};

+

+class QtJIDValidatedItemDelegate : public QItemDelegate {

+ public:

+ QtJIDValidatedItemDelegate(QObject* parent) : QItemDelegate(parent) {}

+ virtual ~QtJIDValidatedItemDelegate() {}

+

+ virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem&, const QModelIndex&) const {

+ QLineEdit *editor = new QLineEdit(parent);

+ editor->setValidator(new QtJIDValidator(editor));

+ return editor;

+ }

+

+ void setEditorData(QWidget *editor, const QModelIndex &index) const {

+ QString value = index.model()->data(index, Qt::EditRole).toString();

+

+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);

+ lineEdit->setText(value);

+ }

+

+ void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const {

+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);

+ QString currentValue = lineEdit->text();

+ int pos = 0;

+ if (lineEdit->validator()->validate(currentValue, pos) == QValidator::Acceptable) {

+ model->setData(index, lineEdit->text(), Qt::EditRole);

+ } else {

+ model->setData(index, QString(), Qt::EditRole);

+ }

+ }

+

+ void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &/* index */) const {

+ editor->setGeometry(option.rect);

+ }

+};

+

+QtBlockListEditorWindow::QtBlockListEditorWindow() : QWidget(), ui(new Ui::QtBlockListEditorWindow) {

+ ui->setupUi(this);

+ new QShortcut(QKeySequence::Close, this, SLOT(close()));

+ ui->throbberLabel->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));

+

+ itemDelegate = new QtRemovableItemDelegate(style());

+

+ connect(ui->savePushButton, SIGNAL(clicked()), SLOT(applyChanges()));

+

+ ui->blockListTreeWidget->setColumnCount(2);

+ ui->blockListTreeWidget->header()->setStretchLastSection(false);

+ int closeIconWidth = ui->blockListTreeWidget->fontMetrics().height();

+ ui->blockListTreeWidget->header()->resizeSection(1, closeIconWidth);

+

+#if QT_VERSION >= 0x050000

+ ui->blockListTreeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);

+#else

+ ui->blockListTreeWidget->header()->setResizeMode(0, QHeaderView::Stretch);

+#endif

+

+ ui->blockListTreeWidget->setHeaderHidden(true);

+ ui->blockListTreeWidget->setRootIsDecorated(false);

+ ui->blockListTreeWidget->setEditTriggers(QAbstractItemView::DoubleClicked);

+ ui->blockListTreeWidget->setItemDelegateForColumn(0, new QtJIDValidatedItemDelegate(this));

+ ui->blockListTreeWidget->setItemDelegateForColumn(1, itemDelegate);

+ connect(ui->blockListTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)), SLOT(handleItemChanged(QTreeWidgetItem*,int)));

+

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ ui->blockListTreeWidget->addTopLevelItem(item);

+}

+

+QtBlockListEditorWindow::~QtBlockListEditorWindow() {

+}

+

+void QtBlockListEditorWindow::show() {

+ QWidget::show();

+ QWidget::activateWindow();

+}

+

+void QtBlockListEditorWindow::handleItemChanged(QTreeWidgetItem *, int) {

+ bool hasEmptyRow = false;

+ QList<QTreeWidgetItem*> rows = ui->blockListTreeWidget->findItems("", Qt::MatchFixedString);

+ foreach(QTreeWidgetItem* row, rows) {

+ if (row->text(0).isEmpty()) {

+ hasEmptyRow = true;

+ }

+ }

+

+ if (!hasEmptyRow) {

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList("") << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ ui->blockListTreeWidget->addTopLevelItem(item);

+ }

+}

+

+void QtBlockListEditorWindow::applyChanges() {

+ onSetNewBlockList(getCurrentBlockList());

+}

+

+void Swift::QtBlockListEditorWindow::setCurrentBlockList(const std::vector<JID> &blockedJIDs) {

+ ui->blockListTreeWidget->clear();

+

+ foreach(const JID& jid, blockedJIDs) {

+ QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(P2QSTRING(jid.toString())) << "");

+ item->setFlags(item->flags() | Qt::ItemIsEditable);

+ ui->blockListTreeWidget->addTopLevelItem(item);

+ }

+ handleItemChanged(0,0);

+}

+

+void Swift::QtBlockListEditorWindow::setBusy(bool isBusy) {

+ if (isBusy) {

+ ui->throbberLabel->movie()->start();

+ ui->throbberLabel->show();

+ } else {

+ ui->throbberLabel->movie()->stop();

+ ui->throbberLabel->hide();

+ }

+}

+

+std::vector<JID> Swift::QtBlockListEditorWindow::getCurrentBlockList() const {

+ std::vector<JID> futureBlockedJIDs;

+

+ for(int i=0; i < ui->blockListTreeWidget->topLevelItemCount(); ++i) {

+ QTreeWidgetItem* row = ui->blockListTreeWidget->topLevelItem(i);

+ if (!row->text(0).isEmpty()) {

+ futureBlockedJIDs.push_back(JID(Q2PSTRING(row->text(0))));

+ }

+ }

+ return futureBlockedJIDs;

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

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

+#include <Swift/QtUI/QtVCardWidget/QtRemovableItemDelegate.h>

+

+#include <QWidget>

+#include <QTreeWidgetItem>

+

+namespace Ui {

+ class QtBlockListEditorWindow;

+}

+

+namespace Swift {

+

+class QtBlockListEditorWindow : public QWidget, public BlockListEditorWidget {

+ Q_OBJECT

+

+ public:

+ QtBlockListEditorWindow();

+ virtual ~QtBlockListEditorWindow();

+

+ virtual void show();

+ virtual void setCurrentBlockList(const std::vector<JID>& blockedJIDs);

+ virtual void setBusy(bool isBusy);

+ virtual std::vector<JID> getCurrentBlockList() const;

+

+ private slots:

+ void handleItemChanged(QTreeWidgetItem*, int);

+ void applyChanges();

+

+ private:

+ Ui::QtBlockListEditorWindow* ui;

+ QtRemovableItemDelegate* itemDelegate;

+};

+

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtBlockListEditorWindow</class>

+ <widget class="QWidget" name="QtBlockListEditorWindow">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>348</width>

+ <height>262</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Edit Block List</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <property name="spacing">

+ <number>5</number>

+ </property>

+ <property name="margin">

+ <number>5</number>

+ </property>

+ <item>

+ <widget class="QTreeWidget" name="blockListTreeWidget">

+ <attribute name="headerVisible">

+ <bool>false</bool>

+ </attribute>

+ <column>

+ <property name="text">

+ <string notr="true">1</string>

+ </property>

+ </column>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <property name="sizeConstraint">

+ <enum>QLayout::SetDefaultConstraint</enum>

+ </property>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QLabel" name="errorLabel">

+ <property name="text">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLabel" name="throbberLabel">

+ <property name="text">

+ <string/>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignCenter</set>

+ </property>

+ <property name="textInteractionFlags">

+ <set>Qt::NoTextInteraction</set>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="savePushButton">

+ <property name="text">

+ <string>Save</string>

+ </property>

+ <property name="default">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

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

+#include <QToolButton>

+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings, QMap<QString, QString> emoticons) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageKind_(PreviosuMessageWasNone), eventStream_(eventStream), emoticons_(emoticons), blockingState_(BlockingUnsupported) {

+ subjectLayout_ = new QBoxLayout(QBoxLayout::LeftToRight);

+ subjectLayout_->addWidget(subject_);

+ QPushButton* actionButton_ = new QPushButton(this);

+ layout->addLayout(subjectLayout_);

+

+ // using an extra layout to work around Qt margin glitches on OS X

+ QHBoxLayout* actionLayout = new QHBoxLayout();

+ actionLayout->addWidget(actionButton_);

+

+ inputBarLayout->addLayout(actionLayout);

+QString QtChatWindow::getHighlightSpanStart(const HighlightAction& highlight) {

+ QAction* block = NULL;

+ QAction* unblock = NULL;

+

+ if (availableRoomActions_.empty()) {

+ if (blockingState_ == IsBlocked) {

+ unblock = contextMenu.addAction(tr("Unblock"));

+ } else if (blockingState_ == IsUnblocked) {

+ block = contextMenu.addAction(tr("Block"));

+ }

+ } else {

+ foreach(ChatWindow::RoomAction availableAction, availableRoomActions_)

+ switch(availableAction)

+ {

+ case ChatWindow::ChangeSubject: changeSubject = contextMenu.addAction(tr("Change subject…")); break;

+ case ChatWindow::Configure: configure = contextMenu.addAction(tr("Configure room…")); break;

+ case ChatWindow::Affiliations: affiliations = contextMenu.addAction(tr("Edit affiliations…")); break;

+ case ChatWindow::Destroy: destroy = contextMenu.addAction(tr("Destroy room")); break;

+ case ChatWindow::Invite: invite = contextMenu.addAction(tr("Invite person to this room…")); break;

+ }

+ else if (result == block) {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, JID(Q2PSTRING(contact_))));

+ }

+ else if (result == unblock) {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, JID(Q2PSTRING(contact_))));

+ }

+void QtChatWindow::setAvailableRoomActions(const std::vector<RoomAction>& actions) {

+void QtChatWindow::setBlockingState(BlockingState state) {

+ blockingState_ = state;

+}

+

+ void setAvailableRoomActions(const std::vector<RoomAction>& actions);

+ void setBlockingState(BlockingState state);

+ QBoxLayout* subjectLayout_;

+ BlockingState blockingState_;

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

+ openBlockingListEditor_ = new QAction(tr("Edit &Blocking List…"), this);

+ connect(openBlockingListEditor_, SIGNAL(triggered()), SLOT(handleEditBlockingList()));

+ actionsMenu->addAction(openBlockingListEditor_);

+ openBlockingListEditor_->setVisible(false);

+void QtMainWindow::handleEditBlockingList() {

+ uiEventStream_->send(boost::make_shared<RequestBlockListDialogUIEvent>());

+}

+

+void QtMainWindow::setBlockingCommandAvailable(bool isAvailable) {

+ openBlockingListEditor_->setVisible(isAvailable);

+}

+

+ void setBlockingCommandAvailable(bool isAvailable);

+ void handleEditBlockingList();

+ QAction* openBlockingListEditor_;

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

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

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

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

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

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

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

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

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

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

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

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

+#include <Swift/QtUI/MUCSearch/QtMUCSearchWindow.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchWindow.h>

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

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

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

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

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

+#include <Swift/QtUI/Whiteboard/QtWhiteboardWindow.h>

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

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

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

+BlockListEditorWidget *QtUIFactory::createBlockListEditorWidget() {

+ return new QtBlockListEditorWindow();

+}

+

+ virtual BlockListEditorWidget* createBlockListEditorWidget();

+#include <Swift/QtUI/Roster/QtRosterWidget.h>

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

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

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

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

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

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

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

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

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

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

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

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

+

+ QAction* unblockContact = NULL;

+ if (contact->blockState() == ContactRosterItem::IsBlocked) {

+ unblockContact = contextMenu.addAction(tr("Unblock"));

+ }

+

+ QAction* blockContact = NULL;

+ if (contact->blockState() == ContactRosterItem::IsUnblocked) {

+ blockContact = contextMenu.addAction(tr("Block"));

+ }

+

+

+ else if (unblockContact && result == unblockContact) {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, contact->getJID()));

+ }

+ else if (blockContact && result == blockContact) {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, contact->getJID()));

+ }

+ if (contact->blockState() == ContactRosterItem::IsBlocked) {

+ return QIcon(":/icons/stop.png");

+ }

+

+ "QtBlockListEditorWindow.cpp",

+myenv.Uic4("QtBlockListEditorWindow.ui")

+ <file alias="icons/stop.png">../resources/icons/stop.png</file>

+<?xml version="1.0" encoding="UTF-8" standalone="no"?>

+<svg

+ xmlns:dc="http://purl.org/dc/elements/1.1/"

+ xmlns:cc="http://creativecommons.org/ns#"

+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

+ xmlns:svg="http://www.w3.org/2000/svg"

+ xmlns="http://www.w3.org/2000/svg"

+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

+ width="601"

+ id="svg2"

+ version="1.1"

+ inkscape:version="0.48.2 r9819"

+ height="601"

+ sodipodi:docname="Blank_stop_sign_octagon.svg"

+ inkscape:export-filename="/Users/tobias/Downloads/Blank_stop_sign_octagon.png"

+ inkscape:export-xdpi="3.29"

+ inkscape:export-ydpi="3.29">

+ <metadata

+ id="metadata12">

+ <rdf:RDF>

+ <cc:Work

+ rdf:about="">

+ <dc:format>image/svg+xml</dc:format>

+ <dc:type

+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

+ <dc:title></dc:title>

+ </cc:Work>

+ </rdf:RDF>

+ </metadata>

+ <defs

+ id="defs10" />

+ <sodipodi:namedview

+ pagecolor="#ffffff"

+ bordercolor="#666666"

+ borderopacity="1"

+ objecttolerance="10"

+ gridtolerance="10"

+ guidetolerance="10"

+ inkscape:pageopacity="0"

+ inkscape:pageshadow="2"

+ inkscape:window-width="1440"

+ inkscape:window-height="852"

+ id="namedview8"

+ showgrid="false"

+ fit-margin-top="0"

+ fit-margin-left="0"

+ fit-margin-right="0"

+ fit-margin-bottom="0"

+ inkscape:zoom="0.63429569"

+ inkscape:cx="102.64275"

+ inkscape:cy="390.12926"

+ inkscape:window-x="0"

+ inkscape:window-y="0"

+ inkscape:window-maximized="1"

+ inkscape:current-layer="svg2" />

+ <path

+ d="m 0.5,424.5 v -248 l 176,-176 h 248 l 176,176 v 248 l -176,176 h -248 z"

+ id="path4"

+ inkscape:connector-curvature="0"

+ style="fill:#ffffff;stroke:#000000" />

+ <path

+ d="M 17,417 V 182 L 183,16 H 418 L 584,182 V 417 L 418,583 H 183 z"

+ id="path6"

+ inkscape:connector-curvature="0"

+ style="fill:#ff0000" />

+ <rect

+ style="fill:#ffffff;fill-opacity:1;stroke:#ffffff;stroke-width:20;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"

+ id="rect2991"

+ width="368.91312"

+ height="96.169655"

+ x="116.04344"

+ y="249.42896" />

+</svg>

+License: Public Domain

+Source: https://commons.wikimedia.org/wiki/File:Blank_stop_sign_octagon.svg

+#include <algorithm>

+

+

+bool BlockList::isBlocked(const JID& jid) const {

+ const std::vector<JID>& items = getItems();

+ return (std::find(items.begin(), items.end(), jid.toBare()) != items.end()) ||

+ (std::find(items.begin(), items.end(), JID(jid.getDomain())) != items.end()) ||

+ (std::find(items.begin(), items.end(), jid) != items.end());

+}

+#include <vector>

+ Init,

+ virtual const std::vector<JID>& getItems() const = 0;

+

+ bool isBlocked(const JID& jid) const;

+#include <algorithm>

+

+BlockListImpl::BlockListImpl() : state(Init) {

+ foreach (const JID& jid, this->items) {

+ if (std::find(items.begin(), items.end(), jid) != items.end()) {

+ onItemRemoved(jid);

+ }

+ }

+

+ foreach (const JID& jid, items) {

+ if (std::find(this->items.begin(), this->items.end(), jid) != this->items.end()) {

+ onItemAdded(jid);

+ }

+ }

+ this->items = items;

+ if (std::find(items.begin(), items.end(), item) == items.end()) {

+ items.push_back(item);

+ size_t oldSize = items.size();

+ items.erase(std::remove(items.begin(), items.end(), item), items.end());

+ if (items.size() != oldSize) {

+ this->state = state;

+ std::vector<JID> itemsToRemove = items;

+ foreach (const JID& item, itemsToRemove) {

+ removeItems(items);

+ virtual const std::vector<JID>& getItems() const {

+ std::vector<JID> items;

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

+ blockListManager = new ClientBlockListManager(getIQRouter());

+ class ClientBlockListManager;

+

+ ClientBlockListManager* getClientBlockListManager() const {

+ return blockListManager;

+ }

+ WhiteboardSessionManager* whiteboardSessionManager;

+ ClientBlockListManager* blockListManager;

+

+ if (blockList && blockList->getState() == BlockList::Available) {

+ unblockResponder->stop();

+ blockResponder->stop();

+ }

+GenericRequest<BlockPayload>::ref ClientBlockListManager::createBlockJIDRequest(const JID& jid) {

+ return createBlockJIDsRequest(std::vector<JID>(1, jid));

+}

+

+GenericRequest<BlockPayload>::ref ClientBlockListManager::createBlockJIDsRequest(const std::vector<JID>& jids) {

+ boost::shared_ptr<BlockPayload> payload = boost::make_shared<BlockPayload>(jids);

+ return boost::make_shared< GenericRequest<BlockPayload> >(IQ::Set, JID(), payload, iqRouter);

+}

+

+GenericRequest<UnblockPayload>::ref ClientBlockListManager::createUnblockJIDRequest(const JID& jid) {

+ return createUnblockJIDsRequest(std::vector<JID>(1, jid));

+}

+

+GenericRequest<UnblockPayload>::ref ClientBlockListManager::createUnblockJIDsRequest(const std::vector<JID>& jids) {

+ boost::shared_ptr<UnblockPayload> payload = boost::make_shared<UnblockPayload>(jids);

+ return boost::make_shared< GenericRequest<UnblockPayload> >(IQ::Set, JID(), payload, iqRouter);

+}

+

+GenericRequest<UnblockPayload>::ref ClientBlockListManager::createUnblockAllRequest() {

+ return createUnblockJIDsRequest(std::vector<JID>());

+}

+

+

+ blockList->setState(BlockList::Available);

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

+ GenericRequest<BlockPayload>::ref createBlockJIDRequest(const JID& jid);

+ GenericRequest<BlockPayload>::ref createBlockJIDsRequest(const std::vector<JID>& jids);

+

+ GenericRequest<UnblockPayload>::ref createUnblockJIDRequest(const JID& jid);

+ GenericRequest<UnblockPayload>::ref createUnblockJIDsRequest(const std::vector<JID>& jids);

+ GenericRequest<UnblockPayload>::ref createUnblockAllRequest();

+

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

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

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

+

+#include <algorithm>

+

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

+

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

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

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

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

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

+

+using namespace Swift;

+

+class ClientBlockListManagerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ClientBlockListManagerTest);

+ CPPUNIT_TEST(testFetchBlockList);

+ CPPUNIT_TEST(testBlockCommand);

+ CPPUNIT_TEST(testUnblockCommand);

+ CPPUNIT_TEST(testUnblockAllCommand);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ ownJID_ = JID("kev@wonderland.lit");

+ stanzaChannel_ = new DummyStanzaChannel();

+ iqRouter_ = new IQRouter(stanzaChannel_);

+ iqRouter_->setJID(ownJID_);

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ }

+

+ void testFetchBlockList() {

+ std::vector<JID> blockJids;

+ blockJids.push_back(JID("romeo@montague.net"));

+ blockJids.push_back(JID("iago@shakespeare.lit"));

+ helperInitialBlockListFetch(blockJids);

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), clientBlockListManager_->getBlockList()->getItems().size());

+ }

+

+ void testBlockCommand() {

+ // start with an already fetched block list

+ helperInitialBlockListFetch(std::vector<JID>(1, JID("iago@shakespeare.lit")));

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), clientBlockListManager_->getBlockList()->getItems().size());

+ CPPUNIT_ASSERT_EQUAL(BlockList::Available, clientBlockListManager_->getBlockList()->getState());

+

+ GenericRequest<BlockPayload>::ref blockRequest = clientBlockListManager_->createBlockJIDRequest(JID("romeo@montague.net"));

+ blockRequest->send();

+ IQ::ref request = stanzaChannel_->getStanzaAtIndex<IQ>(2);

+ CPPUNIT_ASSERT(request.get() != NULL);

+ boost::shared_ptr<BlockPayload> blockPayload = request->getPayload<BlockPayload>();

+ CPPUNIT_ASSERT(blockPayload.get() != NULL);

+ CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.net"), blockPayload->getItems().at(0));

+

+ IQ::ref blockRequestResponse = IQ::createResult(request->getFrom(), JID(), request->getID());

+ stanzaChannel_->sendIQ(blockRequestResponse);

+ stanzaChannel_->onIQReceived(blockRequestResponse);

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), clientBlockListManager_->getBlockList()->getItems().size());

+

+ // send block push

+ boost::shared_ptr<BlockPayload> pushPayload = boost::make_shared<BlockPayload>();

+ pushPayload->addItem(JID("romeo@montague.net"));

+ IQ::ref blockPush = IQ::createRequest(IQ::Set, ownJID_, "push1", pushPayload);

+ stanzaChannel_->sendIQ(blockPush);

+ stanzaChannel_->onIQReceived(blockPush);

+

+ std::vector<JID> blockedJIDs = clientBlockListManager_->getBlockList()->getItems();

+ CPPUNIT_ASSERT(blockedJIDs.end() != std::find(blockedJIDs.begin(), blockedJIDs.end(), JID("romeo@montague.net")));

+ }

+

+ void testUnblockCommand() {

+ // start with an already fetched block list

+ std::vector<JID> initialBlockList = std::vector<JID>(1, JID("iago@shakespeare.lit"));

+ initialBlockList.push_back(JID("romeo@montague.net"));

+ helperInitialBlockListFetch(initialBlockList);

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), clientBlockListManager_->getBlockList()->getItems().size());

+ CPPUNIT_ASSERT_EQUAL(BlockList::Available, clientBlockListManager_->getBlockList()->getState());

+

+ GenericRequest<UnblockPayload>::ref unblockRequest = clientBlockListManager_->createUnblockJIDRequest(JID("romeo@montague.net"));

+ unblockRequest->send();

+ IQ::ref request = stanzaChannel_->getStanzaAtIndex<IQ>(2);

+ CPPUNIT_ASSERT(request.get() != NULL);

+ boost::shared_ptr<UnblockPayload> unblockPayload = request->getPayload<UnblockPayload>();

+ CPPUNIT_ASSERT(unblockPayload.get() != NULL);

+ CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.net"), unblockPayload->getItems().at(0));

+

+ IQ::ref unblockRequestResponse = IQ::createResult(request->getFrom(), JID(), request->getID());

+ stanzaChannel_->sendIQ(unblockRequestResponse);

+ stanzaChannel_->onIQReceived(unblockRequestResponse);

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), clientBlockListManager_->getBlockList()->getItems().size());

+

+ // send block push

+ boost::shared_ptr<UnblockPayload> pushPayload = boost::make_shared<UnblockPayload>();

+ pushPayload->addItem(JID("romeo@montague.net"));

+ IQ::ref unblockPush = IQ::createRequest(IQ::Set, ownJID_, "push1", pushPayload);

+ stanzaChannel_->sendIQ(unblockPush);

+ stanzaChannel_->onIQReceived(unblockPush);

+

+ std::vector<JID> blockedJIDs = clientBlockListManager_->getBlockList()->getItems();

+ CPPUNIT_ASSERT(blockedJIDs.end() == std::find(blockedJIDs.begin(), blockedJIDs.end(), JID("romeo@montague.net")));

+ }

+

+ void testUnblockAllCommand() {

+ // start with an already fetched block list

+ std::vector<JID> initialBlockList = std::vector<JID>(1, JID("iago@shakespeare.lit"));

+ initialBlockList.push_back(JID("romeo@montague.net"));

+ initialBlockList.push_back(JID("benvolio@montague.net"));

+ helperInitialBlockListFetch(initialBlockList);

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), clientBlockListManager_->getBlockList()->getItems().size());

+ CPPUNIT_ASSERT_EQUAL(BlockList::Available, clientBlockListManager_->getBlockList()->getState());

+

+ GenericRequest<UnblockPayload>::ref unblockRequest = clientBlockListManager_->createUnblockAllRequest();

+ unblockRequest->send();

+ IQ::ref request = stanzaChannel_->getStanzaAtIndex<IQ>(2);

+ CPPUNIT_ASSERT(request.get() != NULL);

+ boost::shared_ptr<UnblockPayload> unblockPayload = request->getPayload<UnblockPayload>();

+ CPPUNIT_ASSERT(unblockPayload.get() != NULL);

+ CPPUNIT_ASSERT_EQUAL(true, unblockPayload->getItems().empty());

+

+ IQ::ref unblockRequestResponse = IQ::createResult(request->getFrom(), JID(), request->getID());

+ stanzaChannel_->sendIQ(unblockRequestResponse);

+ stanzaChannel_->onIQReceived(unblockRequestResponse);

+

+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), clientBlockListManager_->getBlockList()->getItems().size());

+

+ // send block push

+ boost::shared_ptr<UnblockPayload> pushPayload = boost::make_shared<UnblockPayload>();

+ IQ::ref unblockPush = IQ::createRequest(IQ::Set, ownJID_, "push1", pushPayload);

+ stanzaChannel_->sendIQ(unblockPush);

+ stanzaChannel_->onIQReceived(unblockPush);

+

+ CPPUNIT_ASSERT_EQUAL(true, clientBlockListManager_->getBlockList()->getItems().empty());

+ }

+

+ void tearDown() {

+ delete clientBlockListManager_;

+ delete iqRouter_;

+ delete stanzaChannel_;

+ }

+

+ private:

+ void helperInitialBlockListFetch(const std::vector<JID>& blockedJids) {

+ boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+ CPPUNIT_ASSERT(blockList);

+

+ // check for IQ request

+ IQ::ref request = stanzaChannel_->getStanzaAtIndex<IQ>(0);

+ CPPUNIT_ASSERT(request.get() != NULL);

+ boost::shared_ptr<BlockListPayload> requestPayload = request->getPayload<BlockListPayload>();

+ CPPUNIT_ASSERT(requestPayload.get() != NULL);

+

+ CPPUNIT_ASSERT_EQUAL(BlockList::Requesting, blockList->getState());

+ CPPUNIT_ASSERT_EQUAL(BlockList::Requesting, clientBlockListManager_->getBlockList()->getState());

+

+ // build IQ response

+ boost::shared_ptr<BlockListPayload> responsePayload = boost::make_shared<BlockListPayload>();

+ foreach(const JID& jid, blockedJids) {

+ responsePayload->addItem(jid);

+ }

+

+ IQ::ref response = IQ::createResult(ownJID_, JID(), request->getID(), responsePayload);

+ stanzaChannel_->sendIQ(response);

+ stanzaChannel_->onIQReceived(response);

+

+ CPPUNIT_ASSERT_EQUAL(BlockList::Available, clientBlockListManager_->getBlockList()->getState());

+ CPPUNIT_ASSERT(responsePayload->getItems() == clientBlockListManager_->getBlockList()->getItems());

+ }

+

+

+ private:

+ JID ownJID_;

+ IQRouter* iqRouter_;

+ DummyStanzaChannel* stanzaChannel_;

+ ClientBlockListManager* clientBlockListManager_;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ClientBlockListManagerTest);

+

+ BlockListPayload(const std::vector<JID>& items = std::vector<JID>()) : items(items) {

+ BlockPayload(const std::vector<JID>& jids = std::vector<JID>()) : items(jids) {

+const std::string DiscoInfo::BlockingCommandFeature = std::string("urn:xmpp:blocking");

+ static const std::string BlockingCommandFeature;

+ UnblockPayload(const std::vector<JID>& jids = std::vector<JID>()) : items(jids) {

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

+ BlockParser() : GenericPayloadParser<BLOCK_ELEMENT>(), level(0) {

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

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

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

+

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

+#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>

+

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

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

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

+

+using namespace Swift;

+

+class BlockParserTest : public CppUnit::TestFixture

+{

+ CPPUNIT_TEST_SUITE(BlockParserTest);

+ CPPUNIT_TEST(testExample4);

+ CPPUNIT_TEST(testExample6);

+ CPPUNIT_TEST(testExample10);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ BlockParserTest() {}

+

+ void testExample4() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse("<blocklist xmlns='urn:xmpp:blocking'>"

+ "<item jid='romeo@montague.net'/>"

+ "<item jid='iago@shakespeare.lit'/>"

+ "</blocklist>"));

+

+ BlockListPayload* payload = dynamic_cast<BlockListPayload*>(parser.getPayload().get());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT(2 == payload->getItems().size());

+ CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.net"), payload->getItems()[0]);

+ CPPUNIT_ASSERT_EQUAL(JID("iago@shakespeare.lit"), payload->getItems()[1]);

+ }

+

+ void testExample6() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse("<block xmlns='urn:xmpp:blocking'>"

+ "<item jid='romeo@montague.net'/>"

+ "</block>"));

+

+ BlockPayload* payload = dynamic_cast<BlockPayload*>(parser.getPayload().get());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT(1 == payload->getItems().size());

+ CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.net"), payload->getItems()[0]);

+ }

+

+ void testExample10() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse("<unblock xmlns='urn:xmpp:blocking'>"

+ "<item jid='romeo@montague.net'/>"

+ "</unblock>"));

+

+ UnblockPayload* payload = dynamic_cast<UnblockPayload*>(parser.getPayload().get());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT(1 == payload->getItems().size());

+ CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.net"), payload->getItems()[0]);

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(BlockParserTest);

+ typedef boost::shared_ptr<GenericRequest<PAYLOAD_TYPE> > ref;

+

+ public:

+ public:

+ File("Client/UnitTest/ClientBlockListManagerTest.cpp"),

+ File("Parser/PayloadParsers/UnitTest/BlockParserTest.cpp"),

+ File("Serializer/PayloadSerializers/UnitTest/BlockSerializerTest.cpp"),

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

+ element.addNode(item);

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

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

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

+

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

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

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

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

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

+

+using namespace Swift;

+

+class BlockSerializerTest : public CppUnit::TestFixture

+{

+ CPPUNIT_TEST_SUITE(BlockSerializerTest);

+ CPPUNIT_TEST(testExample4);

+ CPPUNIT_TEST(testExample6);

+ CPPUNIT_TEST(testExample10);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ BlockSerializerTest() {}

+

+ void testExample4() {

+ BlockSerializer<BlockListPayload> testling("blocklist");

+ boost::shared_ptr<BlockListPayload> blocklist = boost::make_shared<BlockListPayload>();

+ blocklist->addItem(JID("romeo@montague.net"));

+ blocklist->addItem(JID("iago@shakespeare.lit"));

+

+ CPPUNIT_ASSERT_EQUAL(std::string("<blocklist xmlns=\"urn:xmpp:blocking\"><item jid=\"romeo@montague.net\"/><item jid=\"iago@shakespeare.lit\"/></blocklist>"), testling.serialize(blocklist));

+ }

+

+ void testExample6() {

+ BlockSerializer<BlockPayload> testling("block");

+ boost::shared_ptr<BlockPayload> block = boost::make_shared<BlockPayload>();

+ block->addItem(JID("romeo@montague.net"));

+

+ CPPUNIT_ASSERT_EQUAL(std::string("<block xmlns=\"urn:xmpp:blocking\"><item jid=\"romeo@montague.net\"/></block>"), testling.serialize(block));

+ }

+

+ void testExample10() {

+ BlockSerializer<UnblockPayload> testling("unblock");

+ boost::shared_ptr<UnblockPayload> unblock = boost::make_shared<UnblockPayload>();

+ unblock->addItem(JID("romeo@montague.net"));

+

+ CPPUNIT_ASSERT_EQUAL(std::string("<unblock xmlns=\"urn:xmpp:blocking\"><item jid=\"romeo@montague.net\"/></unblock>"), testling.serialize(unblock));

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(BlockSerializerTest);