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

void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);

void addMessage(const String& message, const String& senderName, bool senderIsSelf, const boost::optional<SecurityLabel>& label, const String& avatarPath, const boost::posix_time::ptime& time);

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);

}

}

void ChatsManager::setEnabled(bool enabled) {

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

controllerPair.second->setEnabled(enabled);

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

controllerPair.second->setEnabled(enabled);

}

}

void ChatsManager::handleJoinMUCRequest(const JID &muc, const boost::optional<String>& nickMaybe) {

std::map<JID, MUCController*>::iterator it = mucControllers_.find(muc);

if (it != mucControllers_.end()) {

} else {

MUCController* controller = new MUCController(jid_, muc, nick, stanzaChannel_, presenceSender_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_);

mucControllers_[muc] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

bool useDelayForLatency,

TimerFactory* timerFactory,

EventController* eventController) :

events_ = uiEventStream;

roster_ = new Roster(true);

loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

loginCheckTimer_->start();

}

chatWindow_->convertToMUC();

chatWindow_->addSystemMessage("Trying to join room " + toJID_.toString());

if (avatarManager_ != NULL) {

avatarChangedConnection_ = (avatarManager_->onAvatarChanged.connect(boost::bind(&MUCController::handleAvatarChanged, this, _1, _2)));

}

delete completer_;

}

void MUCController::handleJoinTimeoutTick() {

receivedActivity();

chatWindow_->addSystemMessage("Room " + toJID_.toString() + " is not responding. This operation may never complete");

chatWindow_->addErrorMessage(errorMessage);

if (!rejoinNick.isEmpty()) {

nick_ = rejoinNick;

}

}

String joinMessage = "You have joined room " + toJID_.toString() + " as " + nick;

nick_ = nick;

chatWindow_->addSystemMessage(joinMessage);

}

void MUCController::handleAvatarChanged(const JID& jid, const String&) {

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

boost::shared_ptr<Message> message = messageEvent->getStanza();

eventController_->handleIncomingEvent(messageEvent);

}

String nick = message->getFrom().getResource();

return result;

}

void MUCController::handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType, const String& reason) {

completer_->removeWord(occupant.getNick());

if (!reason.isEmpty()) {

partMessage += " (" + reason + ")";

}

partMessage += ".";

chatWindow_->addSystemMessage(partMessage);

}

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

MUCController(const JID& self, const JID &muc, const String &nick, StanzaChannel* stanzaChannel, PresenceSender* presenceSender, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController);

~MUCController();

boost::signal<void ()> onUserLeft;

protected:

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

/* Recursive check that it's ok to create such an item

Assuming there are more contacts in a group than groups in a

group, this could save a decent chunk of search time at startup.*/

return QModelIndex();

}

for (size_t i = 0; i < parent->getDisplayedChildren().size(); i++) {

presenceSender->removeDirectedPresenceReceiver(ownMUCJID);

}

void MUC::handleIncomingPresence(boost::shared_ptr<Presence> presence) {

if (!isFromMUC(presence->getFrom())) {

return;

//170 is room logging to http

//TODO: Nick changes

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

}

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

MUCOccupant occupant(nick, role, affiliation);

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

class MUC {

public:

enum JoinResult { JoinSucceeded, JoinFailed };

public:

MUC(StanzaChannel* stanzaChannel, PresenceSender* presenceSender, const JID &muc);

String getCurrentNick();

void part();

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

public:

boost::signal<void (const String& /*nick*/)> onJoinComplete;

}

/**

* Returns the removed item - but only if it's the only one, otherwise

* the return result is undefined.

*/

const std::vector<RosterItem*>& getDisplayedChildren() const;

void addChild(RosterItem* item);

ContactRosterItem* removeChild(const JID& jid);

void setDisplayed(RosterItem* item, bool displayed);

boost::signal<void ()> onChildrenChanged;

static bool itemLessThan(const RosterItem* left, const RosterItem* right);

JID jid;

};

void Roster::removeContact(const JID& jid) {

std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()];

items->erase(std::remove_if(items->begin(), items->end(), JIDEqualsTo(jid)), items->end());

void addContact(const JID& jid, const JID& displayJID, const String& name, const String& group);

void removeContact(const JID& jid);

void removeContactFromGroup(const JID& jid, const String& group);

void applyOnItems(const RosterItemOperation& operation);

void applyOnAllItems(const RosterItemOperation& operation);

void applyOnItem(const RosterItemOperation& operation, const JID& jid);