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>