#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include "Swiften/Avatars/AvatarManager.h"

#include "Swiften/Chat/ChatStateNotifier.h"

#include "Swiften/Chat/ChatStateTracker.h"

setToJID(from);

}

}

chatStateTracker_->handleMessageReceived(message);

}

void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

}

void ChatController::postSendMessage(const std::string& body, boost::shared_ptr<Stanza> sentStanza) {

}

lastWasPresence_ = false;

chatStateNotifier_->userSentMessage();

}

void ChatController::handleStanzaAcked(boost::shared_ptr<Stanza> stanza) {

}

}

void ChatController::setOnline(bool online) {

NickResolver* nickResolver_;

ChatStateNotifier* chatStateNotifier_;

ChatStateTracker* chatStateTracker_;

bool isInMUC_;

bool lastWasPresence_;

std::string lastStatusChangeString_;

/*

* Licensed under the GNU General Public License v3.

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

*/

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

chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

createDayChangeTimer();

}

ChatControllerBase::~ChatControllerBase() {

chatWindow_->setUnreadMessageCount(0);

}

if (!stanzaChannel_->isAvailable() || body.empty()) {

return;

}

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

message->addPayload(boost::shared_ptr<Delay>(new Delay(now, selfJID_)));

}

stanzaChannel_->sendMessage(message);

postSendMessage(message->getBody(), boost::dynamic_pointer_cast<Stanza>(message));

}

void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {

JID from = message->getFrom();

std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

continue;

}

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

if (messageTimeStamp) {

timeStamp = *messageTimeStamp;

}

}

chatWindow_->show();

chatWindow_->setUnreadMessageCount(unreadMessages_.size());

#include "Swiften/Elements/ErrorPayload.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Queries/IQRouter.h"

namespace Swift {

class IQRouter;

virtual void setOnline(bool online);

virtual void setEnabled(bool enabled);

virtual void setToJID(const JID& jid) {toJID_ = jid;};

protected:

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

virtual void dayTicked() {};

private:

void createDayChangeTimer();

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);

ChatWindow* chatWindow_;

JID toJID_;

bool labelsEnabled_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

bool useDelayForLatency_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/Controllers/Chat/ChatsManager.h"

#include <boost/bind.hpp>

#include "Swift/Controllers/Chat/ChatController.h"

#include "Swift/Controllers/Chat/MUCSearchController.h"

#include "Swift/Controllers/XMPPEvents/EventController.h"

#include "Swiften/MUC/MUCManager.h"

#include "Swiften/Elements/ChatState.h"

#include "Swiften/MUC/MUCBookmarkManager.h"

namespace Swift {

typedef std::pair<JID, ChatController*> JIDChatControllerPair;

typedef std::pair<JID, MUCController*> JIDMUCControllerPair;

ChatsManager::ChatsManager(

JID jid, StanzaChannel* stanzaChannel,

IQRouter* iqRouter,

EntityCapsProvider* entityCapsProvider,

MUCManager* mucManager,

MUCSearchWindowFactory* mucSearchWindowFactory,

jid_(jid),

joinMUCWindowFactory_(joinMUCWindowFactory),

useDelayForLatency_(useDelayForLatency),

presenceSender_ = presenceSender;

uiEventStream_ = uiEventStream;

mucBookmarkManager_ = NULL;

presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));

uiEventConnection_ = uiEventStream_->onUIEvent.connect(boost::bind(&ChatsManager::handleUIEvent, this, _1));

chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);

mucSearchController_ = new MUCSearchController(jid_, mucSearchWindowFactory, iqRouter, settings);

mucSearchController_->onMUCSelected.connect(boost::bind(&ChatsManager::handleMUCSelectedAfterSearch, this, _1));

setupBookmarks();

}

ChatsManager::~ChatsManager() {

delete mucSearchController_;

}

void ChatsManager::setupBookmarks() {

if (!mucBookmarkManager_) {

mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(false);

}

}

}

chatListWindow_->removeMUCBookmark(bookmark);

}

void ChatsManager::handleUserLeftMUC(MUCController* mucController) {

std::map<JID, MUCController*>::iterator it;

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

else if (JoinMUCUIEvent::ref joinEvent = boost::dynamic_pointer_cast<JoinMUCUIEvent>(event)) {

handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getNick(), false);

}

if (!joinMUCWindow_) {

joinMUCWindow_ = joinMUCWindowFactory_->createJoinMUCWindow();

joinMUCWindow_->onJoinMUC.connect(boost::bind(&ChatsManager::handleJoinMUCRequest, this, _1, _2, _3));

joinMUCWindow_->onSearchMUC.connect(boost::bind(&ChatsManager::handleSearchMUCRequest, this));

}

joinMUCWindow_->setNick(nickResolver_->jidToNick(jid_));

joinMUCWindow_->show();

}

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

chatControllers_[contact] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

return controller;

}

controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

}

mucControllers_[mucJID]->activateChatWindow();

}

void ChatsManager::handleSearchMUCRequest() {

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/shared_ptr.hpp>

#include <string>

namespace Swift {

class EventController;

class IQRouter;

class PresenceSender;

class MUCBookmarkManager;

class ChatListWindowFactory;

class TimerFactory;

class EntityCapsProvider;

class DirectedPresenceSender;

class MUCSearchWindowFactory;

class MUCSearchController;

class ChatsManager {

public:

virtual ~ChatsManager();

void setAvatarManager(AvatarManager* avatarManager);

void setOnline(bool enabled);

void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

void handleUserLeftMUC(MUCController* mucController);

void handleBookmarksReady();

void setupBookmarks();

ChatController* getChatControllerOrFindAnother(const JID &contact);

ChatController* createNewChatController(const JID &contact);

ChatController* getChatControllerOrCreate(const JID &contact);

EntityCapsProvider* entityCapsProvider_;

MUCManager* mucManager;

MUCSearchController* mucSearchController_;

};

}

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

*/

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#define MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS 60000

currentOccupants_.insert(occupant.getNick());

NickJoinPart event(occupant.getNick(), Join);

appendToJoinParts(joinParts_, event);

if (joined_) {

std::string joinString;

MUCOccupant::Role role = occupant.getRole();

return "";

}

JID MUCController::nickToJID(const std::string& nick) {

return JID(toJID_.getNode(), toJID_.getDomain(), nick);

}

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

chatWindow_->addSystemMessage(str(format(QT_TRANSLATE_NOOP("", "%1% is now a %2%")) % nick % roleToFriendlyName(occupant.getRole())));

}

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/signals/connection.hpp>

#include <string>

namespace Swift {

class StanzaChannel;

void handleJoinFailed(boost::shared_ptr<ErrorPayload> error);

void handleJoinTimeoutTick();

std::string roleToGroupName(MUCOccupant::Role role);

JID nickToJID(const std::string& nick);

std::string roleToFriendlyName(MUCOccupant::Role role);

void receivedActivity();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

static const std::string SEARCHED_SERVICES = "searchedServices";

itemsInProgress_ = 0;

loadSavedServices();

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swiften/JID/JID.h"

#include "Swift/Controllers/UIEvents/UIEvent.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/DiscoItems.h"

#include "Swiften/Elements/ErrorPayload.h"

class MUCSearchController {

public:

~MUCSearchController();

void openSearchWindow();

JID jid_;

MUCSearchWindowFactory* factory_;

IQRouter* iqRouter_;

MUCSearchWindow* window_;

DiscoServiceWalker* walker_;

std::list<JID> services_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/Controllers/Chat/ChatsManager.h"

#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

#include "Swift/Controllers/Settings/DummySettingsProvider.h"

#include "Swift/Controllers/UIInterfaces/ChatWindowFactory.h"

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

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

using namespace Swift;

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

avatarManager_ = new NullAvatarManager();

manager_->setAvatarManager(avatarManager_);

void tearDown() {

//delete chatListWindowFactory_;

delete settings_;

delete mocks_;

delete avatarManager_;

delete manager_;

delete xmppRoster_;

delete entityCapsManager_;

delete capsProvider_;

}

void testFirstOpenWindowIncoming() {

CapsProvider* capsProvider_;

MUCManager* mucManager_;

DummySettingsProvider* settings_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ChatsManagerTest);

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swift/Controllers/DiscoServiceWalker.h>

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

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

#include <Swift/Controllers/DiscoServiceWalker.h>

#include <Swiften/Base/Log.h>

#include <boost/bind.hpp>

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swift/Controllers/UIInterfaces/UIFactory.h>

#include "Swiften/Network/TimerFactory.h"

#include "Swift/Controllers/BuildVersion.h"

#include "Swiften/Client/Storages.h"

#include "Swiften/VCards/VCardManager.h"

#include "Swift/Controllers/Chat/UserSearchController.h"

#include "Swift/Controllers/Chat/ChatsManager.h"

#include "Swift/Controllers/XMPPEvents/EventController.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/PresenceNotifier.h"

#include "Swift/Controllers/EventNotifier.h"

#include "SwifTools/Dock/Dock.h"

#include "SwifTools/Notifier/TogglableNotifier.h"

#include "Swiften/Base/foreach.h"

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

#include "Swift/Controllers/UIEvents/ToggleNotificationsUIEvent.h"

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swiften/Network/NetworkFactories.h"

#include <Swift/Controllers/ProfileController.h>

#include <Swift/Controllers/ContactEditController.h>

namespace Swift {

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

bool useDelayForLatency) :

eventLoop_(eventLoop),

networkFactories_(networkFactories),

storagesFactory_(storagesFactory),

certificateStorageFactory_(certificateStorageFactory),

settings_(settings),

loginWindow_(NULL) ,

useDelayForLatency_(useDelayForLatency) {

storages_ = NULL;

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings, uiEventStream_);

std::string selectedLoginJID = settings_->getStringSetting("lastLoginJID");

bool loginAutomatically = settings_->getBoolSetting("loginAutomatically", false);

std::string cachedPassword;

resetClient();

delete xmlConsoleController_;

delete soundEventController_;

delete systemTrayController_;

delete eventController_;

contactEditController_ = new ContactEditController(rosterController_, uiFactory_, uiEventStream_);

client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

chatsManager_->setAvatarManager(client_->getAvatarManager());

client_->getDiscoManager()->setCapsNode(CLIENT_NODE);

client_->getDiscoManager()->setDiscoInfo(discoInfo);

userSearchControllerChat_ = new UserSearchController(UserSearchController::StartChat, jid_, uiEventStream_, uiFactory_, client_->getIQRouter(), rosterController_);

userSearchControllerAdd_ = new UserSearchController(UserSearchController::AddContact, jid_, uiEventStream_, uiFactory_, client_->getIQRouter(), rosterController_);

}

client_->requestRoster();

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

}

void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificateFile, bool remember, bool loginAutomatically) {

jid_ = JID(username);

}

void MainController::handlePurgeSavedLoginRequest(const std::string& username) {

certificateStorage_ = certificateStorageFactory_->createCertificateStorage(jid_.toBare());

certificateTrustChecker_ = new CertificateStorageTrustChecker(certificateStorage_);

clientInitialized_ = true;

client_->setCertificateTrustChecker(certificateTrustChecker_);

client_->onDataRead.connect(boost::bind(&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

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

signOut();

loginWindow_->setMessage(message);

} else {

logout();

setReconnectTimer();

eventController_->handleIncomingEvent(lastDisconnectError_);

}

}

}

void MainController::setReconnectTimer() {

void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, ErrorPayload::ref error) {

if (!error) {

chatsManager_->setServerDiscoInfo(info);

}

}

void MainController::handleVCardReceived(const JID& jid, VCard::ref vCard) {

return;

}

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

/*

* Licensed under the GNU General Public License v3.

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

*/

class Storages;

class StoragesFactory;

class NetworkFactories;

class MainController {

public:

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

bool useDelayForLatency);

~MainController();

SettingsProvider *settings_;

ProfileSettingsProvider* profileSettings_;

Dock* dock_;

TogglableNotifier* notifier_;

PresenceNotifier* presenceNotifier_;

EventNotifier* eventNotifier_;

RosterController* rosterController_;

EventController* eventController_;

EventWindowController* eventWindowController_;

LoginWindow* loginWindow_;

UIEventStream* uiEventStream_;

XMLConsoleController* xmlConsoleController_;

JID boundJID_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

std::string vCardPhotoHash_;

std::string password_;

std::string certificateFile_;

#pragma once

#include "Swift/Controllers/Settings/SettingsProvider.h"

namespace Swift {

#include "Swift/Controllers/Roster/ContactRosterItem.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

namespace Swift {

namespace Swift {

expanded_ = true;

}

}

bool GroupRosterItem::isExpanded() const {

return expanded_;

}

} else {

displayedChildren_.erase(std::remove(displayedChildren_.begin(), displayedChildren_.end(), group), displayedChildren_.end());

}

onChildrenChanged();

onDataChanged();

}

void setExpanded(bool expanded);

bool isExpanded() const;

boost::signal<void (bool)> onExpandedChanged;

private:

void handleChildrenChanged(GroupRosterItem* group);

void handleDataChanged(RosterItem* item);

std::vector<RosterItem*> children_;

std::vector<RosterItem*> displayedChildren_;

bool sortByStatus_;

};

}

#include <boost/bind.hpp>

#include <vector>

#include "Swiften/Base/String.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

onDataChanged();

}

return name_;

}

return sortableDisplayName_;

}

boost::signal<void ()> onDataChanged;

GroupRosterItem* getParent() const;

void setDisplayName(const std::string& name);

private:

std::string name_;

std::string sortableDisplayName_;

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "Swift/Controllers/Roster/RosterController.h"

#include "Swift/Controllers/UnitTest/MockMainWindowFactory.h"

// #include "Swiften/Elements/Payload.h"

CPPUNIT_TEST(testRemoveSecondContact);

CPPUNIT_TEST(testRemoveSecondContactSameBare);

CPPUNIT_TEST(testApplyPresenceLikeMUC);

CPPUNIT_TEST_SUITE_END();

public:

}

private:

Roster *roster_;

JID jid1_;

"StatusTracker.cpp",

"PresenceNotifier.cpp",

"EventNotifier.cpp",

"XMPPEvents/EventController.cpp",

"UIEvents/UIEvent.cpp",

"UIInterfaces/XMLConsoleWidget.cpp",

"UIInterfaces/ChatListWindow.cpp",

"PreviousStatusStore.cpp",

"StatusUtil.cpp",

"Translator.cpp",

])

env.Append(UNITTEST_SOURCES = [

File("Chat/UnitTest/ChatsManagerTest.cpp"),

File("Chat/UnitTest/MUCControllerTest.cpp"),

File("UnitTest/MockChatWindow.cpp"),

])

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

*/

#include <iostream>

#include <boost/filesystem/fstream.hpp>

boost::filesystem::path certificatePath = getCertificatePath(certificate);

if (boost::filesystem::exists(certificatePath)) {

ByteArray data;

Certificate::ref storedCertificate = certificateFactory->createCertificateFromDER(data);

if (storedCertificate && storedCertificate->toDER() == certificate->toDER()) {

return true;

}

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

ByteArray data = certificate->toDER();

file.close();

}

#include <boost/filesystem.hpp>

namespace Swift {

class CertificateFactory;

#pragma once

namespace Swift {

class CertificateFactory;

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

*/

namespace Swift {

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

*/

namespace Swift {

#pragma once

#include <Swiften/TLS/CertificateTrustChecker.h>

namespace Swift {

/**

#pragma once

namespace Swift {

class FileStoragesFactory : public StoragesFactory {

#pragma once

#include "Swiften/Client/MemoryStorages.h"

namespace Swift {

class MemoryStoragesFactory : public StoragesFactory {

public:

MemoryStoragesFactory() {}

namespace Swift {

class Storages;

class StoragesFactory {

public:

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

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

namespace Swift {

class RequestJoinMUCUIEvent : public UIEvent {

public:

typedef boost::shared_ptr<RequestJoinMUCUIEvent> ref;

}

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

namespace Swift {

class ChatListWindow {

public:

virtual ~ChatListWindow();

virtual void setBookmarksEnabled(bool enabled) = 0;

virtual void addMUCBookmark(const MUCBookmark& bookmark) = 0;

virtual void removeMUCBookmark(const MUCBookmark& bookmark) = 0;

};

}

virtual void addSystemMessage(const std::string& message) = 0;

virtual void addPresenceMessage(const std::string& message) = 0;

virtual void addErrorMessage(const std::string& message) = 0;

virtual void setContactChatState(ChatState::ChatStateType state) = 0;

virtual void setName(const std::string& name) = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

};

}

#endif

#include <string>

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/StatusShow.h"

#include "Swiften/Base/boost_bsignals.h"

#include <boost/shared_ptr.hpp>

/** Must be able to cope with NULL to clear the roster */

virtual void setRosterModel(Roster* roster) = 0;

virtual void setConnecting() = 0;

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

#include <Swift/Controllers/UIInterfaces/XMLConsoleWidgetFactory.h>

#include <Swift/Controllers/UIInterfaces/ProfileWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/ContactEditWindowFactory.h>

namespace Swift {

class UIFactory :

public UserSearchWindowFactory,

public JoinMUCWindowFactory,

public ProfileWindowFactory,

public:

virtual ~UIFactory() {}

};

virtual void setRosterModel(Roster* /*roster*/) {};

virtual void setTabComplete(TabComplete*) {};

virtual void replaceLastMessage(const std::string&) {};

void setAckState(const std::string& /*id*/, AckState /*state*/) {};

virtual void flash() {};

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

std::string name_;

std::string lastMessageBody_;

virtual void setMyAvatarPath(const std::string& /*path*/) {};

virtual void setMyStatusText(const std::string& /*status*/) {};

virtual void setMyStatusType(StatusShow::Type /*type*/) {};

virtual void setConnecting() {};

Roster* roster;

}

void testReceiveFirstPresenceCreatesAvailableNotification() {

sendPresence(user1, StatusShow::Online);

}

void testReceiveSecondPresenceCreatesStatusChangeNotification() {

sendPresence(user1, StatusShow::Away);

notifier->notifications.clear();

}

void testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification() {

sendPresence(user1, StatusShow::Away);

notifier->notifications.clear();

}

void testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification() {

sendUnavailablePresence(user1);

}

void testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification() {

sendPresence(user1, StatusShow::Away);

sendUnavailablePresence(user1);

notifier->notifications.clear();

}

void testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification() {

sendPresence(user1, StatusShow::Away);

stanzaChannel->setAvailable(false);

stanzaChannel->setAvailable(true);

}

void testReceiveAvailablePresenceFromMUCDoesNotCreateNotification() {

mucRegistry->addMUC(JID("teaparty@wonderland.lit"));

sendPresence(JID("teaparty@wonderland.lit/Alice"), StatusShow::Away);

}

void testNotificationPicture() {

sendPresence(user1, StatusShow::Online);

}

void testNotificationActivationEmitsSignal() {

sendPresence(user1, StatusShow::Online);

CPPUNIT_ASSERT(notifier->notifications[0].callback);

}

void testNotificationSubjectContainsNameForJIDInRoster() {

roster->addContact(user1.toBare(), "User 1", std::vector<std::string>(), RosterItemPayload::Both);

sendPresence(user1, StatusShow::Online);

}

void testNotificationSubjectContainsJIDForJIDNotInRoster() {

sendPresence(user1, StatusShow::Online);

}

void testNotificationSubjectContainsStatus() {

sendPresence(user1, StatusShow::Away);

}

void testNotificationMessageContainsStatusMessage() {

sendPresence(user1, StatusShow::Away);

}

void testReceiveFirstPresenceWithQuietPeriodDoesNotNotify() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceivePresenceDuringQuietPeriodDoesNotNotify() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceivePresenceDuringQuietPeriodResetsTimer() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceivePresenceAfterQuietPeriodNotifies() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

}

void testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod() {

testling->setInitialQuietPeriodMS(10);

timerFactory->setTime(11);

}

void testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify() {

testling->setInitialQuietPeriodMS(10);

sendPresence(user1, StatusShow::Online);

timerFactory->setTime(15);

private:

result->onNotificationActivated.connect(boost::bind(&PresenceNotifierTest::handleNotificationActivated, this, _1));

result->setInitialQuietPeriodMS(0);

return result;

#include <boost/bind.hpp>

#include <algorithm>

#include "Swift/Controllers/XMPPEvents/MessageEvent.h"

#include "Swift/Controllers/XMPPEvents/ErrorEvent.h"

#include "Swift/Controllers/XMPPEvents/SubscriptionRequestEvent.h"