* controllers' dtor, which are deleted in ChatManager's dtor. The adapters

* are also deleted there.*/

chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;

}

mucControllers_[mucJID] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

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

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

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

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

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

}

mucControllers_[mucJID]->showChatWindow();

return muc;

}

void ChatsManager::handleSearchMUCRequest() {

mucSearchController_->openSearchWindow();

}

void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {

JID jid = message->getFrom();

boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

bool isInvite = !!message->getPayload<MUCInvitationPayload>();

bool isMediatedInvite = (message->getPayload<MUCUserPayload>() && message->getPayload<MUCUserPayload>()->getInvite());

if (isMediatedInvite) {

jid = (*message->getPayload<MUCUserPayload>()->getInvite()).from;

}

if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !isMediatedInvite && !message->hasSubject()) {

MUC::ref handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& password, const boost::optional<std::string>& nick, bool addAutoJoin, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = 0);

void handleSearchMUCRequest();

void handleMUCSelectedAfterSearch(const JID&);

void rebindControllerJID(const JID& from, const JID& to);

void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

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

void handleMUCBookmarkAdded(const MUCBookmark& bookmark);

void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

void handleUserLeftMUC(MUCController* mucController);

void handleBookmarksReady();

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

void handleChatClosed(const JID& jid);

void handleNewFileTransferController(FileTransferController*);

void handleWhiteboardSessionRequest(const JID& contact, bool senderIsSelf);

void handleWhiteboardStateChange(const JID& contact, const ChatWindow::WhiteboardSessionState state);

boost::optional<ChatListWindow::Chat> removeExistingChat(const ChatListWindow::Chat& chat);

void cleanupPrivateMessageRecents();

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

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

highlighter_->setMode(isImpromptu_ ? Highlighter::ChatMode : Highlighter::MUCMode);

highlighter_->setNick(nick_);

if (timerFactory) {

case MUCOccupant::Participant: return "2";

case MUCOccupant::Visitor: return "3";

case MUCOccupant::NoRole: return "4";

}

assert(false);

return "5";

}

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

}

bool MUCController::messageTargetsMe(boost::shared_ptr<Message> message) {

std::string stringRegexp(".*\\b" + boost::to_lower_copy(nick_) + "\\b.*");

boost::regex myRegexp(stringRegexp);

return boost::regex_match(boost::to_lower_copy(message->getBody()), myRegexp);

}

void MUCController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

if (clearAfter) {

clearPresenceQueue();

}

if (isImpromptu_) {

setImpromptuWindowTitle();

}

}

void MUCController::handleOccupantPresenceChange(boost::shared_ptr<Presence> presence) {

receivedActivity();

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

}

bool MUCController::isIncomingMessageFromMe(boost::shared_ptr<Message> message) {

JID from = message->getFrom();

return nick_ == from.getResource();

}

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

result += eventStrings[populatedEvents[i]];

}

return result;

}

void MUCController::handleChangeSubjectRequest(const std::string& subject) {

muc_->changeSubject(subject);

}

void MUCController::handleBookmarkRequest() {

const JID jid = muc_->getJID();

MUCBookmark bookmark(jid, jid.toBare().toString());

bookmark.setPassword(password_);

bookmark.setNick(nick_);

};

class MUCController : public ChatControllerBase {

public:

MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager);

virtual ~MUCController();

boost::signal<void ()> onUserLeft;

boost::signal<void ()> onUserJoined;

boost::signal<void ()> onImpromptuConfigCompleted;

virtual void setOnline(bool online);

void rejoin();

static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);

static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu);

static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);

bool isJoined();

const std::string& getNick();

const boost::optional<std::string> getPassword() const;

bool isImpromptu() const;

std::map<std::string, JID> getParticipantJIDs() const;

void sendInvites(const std::vector<JID>& jids, const std::string& reason) const;

protected:

void preSendMessageRequest(boost::shared_ptr<Message> message);

private:

void setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role);

void clearPresenceQueue();

void addPresenceMessage(const std::string& message);

void handleWindowOccupantSelectionChanged(ContactRosterItem* item);

void handleActionRequestedOnOccupant(ChatWindow::OccupantAction, ContactRosterItem* item);

void handleWindowClosed();

void handleAvatarChanged(const JID& jid);

void handleOccupantJoined(const MUCOccupant& occupant);

void handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason);

void handleOccupantPresenceChange(boost::shared_ptr<Presence> presence);

void handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant,const MUCOccupant::Role& oldRole);

void handleOccupantAffiliationChanged(const std::string& nick, const MUCOccupant::Affiliation& affiliation,const MUCOccupant::Affiliation& oldAffiliation);

void handleJoinComplete(const std::string& nick);

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

void handleJoinTimeoutTick();

void handleChangeSubjectRequest(const std::string&);

void handleBookmarkRequest();

* @return Invalid if the original is invalid.

*/

JID toBare() const {

JID result(*this);

result.hasResource_ = false;

result.resource_ = "";

return result;

}

std::string toString() const;

bool equals(const JID& o, CompareType compareType) const {

return compare(o, compareType) == 0;

}

int compare(const JID& o, CompareType compareType) const;

operator std::string() const {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swiften/JID/JID.h>

#include <Swiften/Base/API.h>

#include <string>

*/

virtual bool isUnlocked() const = 0;

virtual void joinAs(const std::string &nick) = 0;

virtual void joinWithContextSince(const std::string &nick, const boost::posix_time::ptime& since) = 0;

/*virtual void queryRoomInfo(); */

/*virtual void queryRoomItems(); */

/*virtual std::string getCurrentNick() = 0; */

virtual std::map<std::string, MUCOccupant> getOccupants() const = 0;

virtual void part() = 0;

/*virtual void handleIncomingMessage(Message::ref message) = 0; */

/** Expose public so it can be called when e.g. user goes offline */

virtual void handleUserLeft(LeavingType) = 0;

/** Get occupant information*/

virtual const MUCOccupant& getOccupant(const std::string& nick) = 0;

virtual bool hasOccupant(const std::string& nick) = 0;

virtual void kickOccupant(const JID& jid) = 0;

virtual void changeOccupantRole(const JID& jid, MUCOccupant::Role role) = 0;

boost::signal<void (ErrorPayload::ref)> onJoinFailed;

boost::signal<void (ErrorPayload::ref, const JID&, MUCOccupant::Role)> onRoleChangeFailed;

boost::signal<void (ErrorPayload::ref, const JID&, MUCOccupant::Affiliation)> onAffiliationChangeFailed;

boost::signal<void (ErrorPayload::ref)> onConfigurationFailed;

boost::signal<void (ErrorPayload::ref)> onAffiliationListFailed;

boost::signal<void (Presence::ref)> onOccupantPresenceChange;

boost::signal<void (const std::string&, const MUCOccupant& /*now*/, const MUCOccupant::Role& /*old*/)> onOccupantRoleChanged;

boost::signal<void (const std::string&, const MUCOccupant::Affiliation& /*new*/, const MUCOccupant::Affiliation& /*old*/)> onOccupantAffiliationChanged;

boost::signal<void (const MUCOccupant&)> onOccupantJoined;

boost::signal<void (const MUCOccupant&, LeavingType, const std::string& /*reason*/)> onOccupantLeft;

boost::signal<void (Form::ref)> onConfigurationFormReceived;

boost::signal<void (MUCOccupant::Affiliation, const std::vector<JID>&)> onAffiliationListReceived;

boost::signal<void ()> onUnlocked;

/* boost::signal<void (const MUCInfo&)> onInfoResult; */

/* boost::signal<void (const blah&)> onItemsResult; */

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/MUC/MUCImpl.h>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

}

if (password) {

mucPayload->setPassword(*password);

}

joinPresence->addPayload(mucPayload);

presenceSender->sendPresence(joinPresence);

}

void MUCImpl::part() {

presenceSender->removeDirectedPresenceReceiver(ownMUCJID, DirectedPresenceSender::AndSendPresence);

mucRegistry->removeMUC(getJID());

}

void MUCImpl::handleUserLeft(LeavingType type) {

std::map<std::string,MUCOccupant>::iterator i = occupants.find(ownMUCJID.getResource());

if (i != occupants.end()) {

MUCOccupant me = i->second;

realJID = mucPayload->getItems()[0].realJID;

}

//100 is non-anonymous

//TODO: 100 may also be specified in a <message/>

//170 is room logging to http

//TODO: Nick changes

if (presence->getType() == Presence::Unavailable) {

LeavingType type = LeavePart;

if (mucPayload) {

if (boost::dynamic_pointer_cast<MUCDestroyPayload>(mucPayload->getPayload())) {

type = LeaveDestroy;

}

else foreach (MUCUserPayload::StatusCode status, mucPayload->getStatusCodes()) {

if (status.code == 307) {

type = LeaveKick;

}

else if (status.code == 301) {

type = LeaveBan;

}

else if (status.code == 321) {

type = LeaveNotMember;

}

}

}

std::map<std::string,MUCOccupant>::iterator i = occupants.find(nick);

if (i != occupants.end()) {

MUCOccupant occupant = i->second;

occupants.erase(i);

}

}

}

else if (presence->getType() == Presence::Available) {

std::map<std::string, MUCOccupant>::iterator it = occupants.find(nick);

MUCOccupant occupant(nick, role, affiliation);

bool isJoin = true;

if (realJID) {

occupant.setRealJID(realJID.get());

return isUnlocked_;

}

virtual void joinAs(const std::string &nick);

virtual void joinWithContextSince(const std::string &nick, const boost::posix_time::ptime& since);

/*virtual void queryRoomInfo(); */

/*virtual void queryRoomItems(); */

/*virtual std::string getCurrentNick(); */

virtual std::map<std::string, MUCOccupant> getOccupants() const;

virtual void part();

/*virtual void handleIncomingMessage(Message::ref message); */

/** Expose public so it can be called when e.g. user goes offline */

virtual void handleUserLeft(LeavingType);

/** Get occupant information*/

virtual const MUCOccupant& getOccupant(const std::string& nick);

virtual bool hasOccupant(const std::string& nick);

virtual void kickOccupant(const JID& jid);

virtual void changeOccupantRole(const JID& jid, MUCOccupant::Role role);

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/bind.hpp>

using namespace Swift;

class MUCTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(MUCTest);

CPPUNIT_TEST(testJoin);

CPPUNIT_TEST(testJoin_ChangePresenceDuringJoinDoesNotSendPresenceBeforeJoinSuccess);

CPPUNIT_TEST(testJoin_ChangePresenceDuringJoinResendsPresenceAfterJoinSuccess);

CPPUNIT_TEST(testCreateInstant);

CPPUNIT_TEST(testReplicateBug);

/*CPPUNIT_TEST(testJoin_Success);

CPPUNIT_TEST(testJoin_Fail);*/

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

channel = new DummyStanzaChannel();

router = new IQRouter(channel);

mucRegistry = new MUCRegistry();

stanzaChannelPresenceSender = new StanzaChannelPresenceSender(channel);

presenceSender = new DirectedPresenceSender(stanzaChannelPresenceSender);

}

void tearDown() {

delete presenceSender;

delete stanzaChannelPresenceSender;

delete mucRegistry;

delete router;

delete channel;

}

channel->onPresenceReceived(serverRespondsLocked);

CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(channel->sentStanzas.size()));

IQ::ref iq = channel->getStanzaAtIndex<IQ>(2);

CPPUNIT_ASSERT(iq);

CPPUNIT_ASSERT(iq->getPayload<MUCOwnerPayload>());

CPPUNIT_ASSERT(iq->getPayload<MUCOwnerPayload>()->getForm());

CPPUNIT_ASSERT_EQUAL(Form::SubmitType, iq->getPayload<MUCOwnerPayload>()->getForm()->getType());

}

/*void testJoin_Success() {

MUC::ref testling = createMUC(JID("foo@bar.com"));

testling->onJoinFinished.connect(boost::bind(&MUCTest::handleJoinFinished, this, _1, _2));

testling->joinAs("Alice");

receivePresence(JID("foo@bar.com/Rabbit"), "Here");

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(joinResults.size()));

CPPUNIT_ASSERT_EQUAL(std::string("Alice"), joinResults[0].nick);

CPPUNIT_ASSERT(joinResults[0].error);

}

void testJoin_Fail() {

//CPPUNIT_ASSERT(!mucRegistry->isMUC(JID("foo@bar.com")));

}*/

private:

MUC::ref createMUC(const JID& jid) {

}

void handleJoinFinished(const std::string& nick, ErrorPayload::ref error) {

JoinResult r;

r.nick = nick;

r.error = error;

joinResults.push_back(r);

}

void receivePresence(const JID& jid, const std::string& status) {

Presence::ref p = Presence::create(status);

p->setFrom(jid);

//MUCUserPayload::ref mucUserPayload = boost::make_shared<MUCUserPayload>();

//mucUserPayload->addItem(item);

//p->addPayload(mucUserPayload);

channel->onPresenceReceived(p);

}

private:

DummyStanzaChannel* channel;

IQRouter* router;

MUCRegistry* mucRegistry;

StanzaChannelPresenceSender* stanzaChannelPresenceSender;

DirectedPresenceSender* presenceSender;

struct JoinResult {

std::string nick;

ErrorPayload::ref error;

};

std::vector<JoinResult> joinResults;

};

CPPUNIT_TEST_SUITE_REGISTRATION(MUCTest);

*/

virtual bool isUnlocked() const { return true; }

virtual void joinAs(const std::string&) {}

virtual void joinWithContextSince(const std::string&, const boost::posix_time::ptime&) {}

/*virtual void queryRoomInfo(); */

/*virtual void queryRoomItems(); */

/*virtual std::string getCurrentNick() = 0; */

virtual std::map<std::string, MUCOccupant> getOccupants() const { return occupants_; }

virtual void part() {}

/*virtual void handleIncomingMessage(Message::ref message) = 0; */

/** Expose public so it can be called when e.g. user goes offline */

virtual void handleUserLeft(LeavingType) {}

/** Get occupant information*/

virtual const MUCOccupant& getOccupant(const std::string&);

virtual bool hasOccupant(const std::string&);

virtual void kickOccupant(const JID&) {}

virtual void changeOccupantRole(const JID&, MUCOccupant::Role);