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

+ muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

+ if (timerFactory) {

+ loginCheckTimer_ = boost::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

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

+ loginCheckTimer_->start();

+ }

+ if (loginCheckTimer_) {

+ loginCheckTimer_->stop();

+ }

+ receivedActivity();

+void MUCController::receivedActivity() {

+ if (loginCheckTimer_) {

+ loginCheckTimer_->stop();

+ }

+}

+

+void MUCController::handleJoinFailed(boost::shared_ptr<ErrorPayload> error) {

+ receivedActivity();

+ String errorMessage = "Unable to join this room";

+ String rejoinNick;

+ if (error) {

+ switch (error->getCondition()) {

+ case ErrorPayload::Conflict: rejoinNick = nick_ + "_"; errorMessage += " as " + nick_ + ", retrying as " + rejoinNick; break;

+ case ErrorPayload::JIDMalformed: errorMessage += ", no nickname specified";break;

+ case ErrorPayload::NotAuthorized: errorMessage += ", a password needed";break;

+ case ErrorPayload::RegistrationRequired: errorMessage += ", only members may join"; break;

+ case ErrorPayload::Forbidden: errorMessage += ", you are banned from the room"; break;

+ case ErrorPayload::ServiceUnavailable: errorMessage += ", the room is full";break;

+ case ErrorPayload::ItemNotFound: errorMessage += ", the room does not exist";break;

+

+ default: break;

+ }

+ }

+ errorMessage += ".";

+ chatWindow_->addErrorMessage(errorMessage);

+ if (!rejoinNick.isEmpty()) {

+ muc_->joinAs(rejoinNick);

+ }

+}

+

+void MUCController::handleJoinComplete(const String& nick) {

+ receivedActivity();

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

+ nick_ = nick;

+ receivedActivity();

+ JID jid(nickToJID(occupant.getNick()));

+ roster_->addContact(jid, occupant.getNick(), roleToGroupName(occupant.getRole()));

+ if (joined_) {

+ String joinString = occupant.getNick() + " has joined the room";

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

+ if (role != MUCOccupant::NoRole && role != MUCOccupant::Participant) {

+ joinString += " as a " + roleToFriendlyName(role);

+

+ }

+ joinString += ".";

+ chatWindow_->addSystemMessage(joinString);

+ }

+String MUCController::roleToFriendlyName(MUCOccupant::Role role) {

+ switch (role) {

+ case MUCOccupant::Moderator: return "moderator";

+ case MUCOccupant::Participant: return "participant";

+ case MUCOccupant::Visitor: return "visitor";

+ case MUCOccupant::NoRole: return "";

+ }

+ return "";

+}

+

+JID MUCController::nickToJID(const String& nick) {

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

+}

+

+void MUCController::preHandleIncomingMessage(boost::shared_ptr<Message>) {

+ /*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/

+ receivedActivity();

+ joined_ = true;

+}

+

+void MUCController::handleOccupantRoleChanged(const String& nick, const MUCOccupant::Role& newRole, const MUCOccupant::Role& oldRole) {

+ receivedActivity();

+ JID jid(nickToJID(nick));

+ roster_->removeContactFromGroup(jid, roleToGroupName(oldRole));

+ roster_->addContact(jid, nick, roleToGroupName(newRole));

+ chatWindow_->addSystemMessage(nick + " is now a " + roleToFriendlyName(newRole));

+}

+

+String MUCController::roleToGroupName(MUCOccupant::Role role) {

+ String result;

+ switch (role) {

+ case MUCOccupant::Moderator: result = "Moderators"; break;

+ case MUCOccupant::Participant: result = "Participants"; break;

+ case MUCOccupant::Visitor: result = "Visitors"; break;

+ case MUCOccupant::NoRole: result = "Occupants"; break;

+ default: assert(false);

+ }

+ return result;

+}

+

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

+ String partMessage = occupant.getNick() + " has left the room";

+ if (!reason.isEmpty()) {

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

+ }

+ partMessage += ".";

+ chatWindow_->addSystemMessage(partMessage);

+ receivedActivity();

+#pragma once

+ void handleOccupantRoleChanged(const String& nick, const MUCOccupant::Role& newRole, const MUCOccupant::Role& oldRole);

+ void handleJoinComplete(const String& nick);

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

+ String roleToGroupName(MUCOccupant::Role role);

+ JID nickToJID(const String& nick);

+ String roleToFriendlyName(MUCOccupant::Role role);

+ void receivedActivity();

+ void preHandleIncomingMessage(boost::shared_ptr<Message>);

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, nickResolver_, presenceOracle_, serverDiscoInfo_, presenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL);

+ * Copyright (c) 2010 Kevin Smith

+#include <boost/optional.hpp>

+

+#include "Swiften/JID/JID.h"

+#include "Swiften/Base/String.h"

+

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

+#include "Swiften/JID/JID.h"

+#include "Swiften/Base/String.h"

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

+#include "Swiften/MUC/MUCOccupant.h"

+

+namespace Swift {

+ class MUCUserPayload : public Payload {

+ public:

+ struct Item {

+ Item() : affiliation(MUCOccupant::NoAffiliation), role(MUCOccupant::NoRole) {}

+ boost::optional<JID> realJID;

+ boost::optional<String> nick;

+ MUCOccupant::Affiliation affiliation;

+ MUCOccupant::Role role;

+ };

+

+ struct StatusCode {

+ StatusCode() {}

+ int code;

+ };

+

+ // struct Password {

+

+ // }

+

+ // struct History {

+

+ // }

+

+ // struct Invite {

+

+ // }

+

+ MUCUserPayload() {

+ }

+

+ void addItem(Item item) {items_.push_back(item);}

+

+ void addStatusCode(StatusCode code) {statusCodes_.push_back(code);}

+

+ const std::vector<Item> getItems() const {return items_;}

+

+ const std::vector<StatusCode> getStatusCodes() const {return statusCodes_;}

+

+ private:

+ std::vector<Item> items_;

+ std::vector<StatusCode> statusCodes_;

+ };

+}

+ * Copyright (c) 2010 Kevin Smith

+#include <iostream>

+

+#include "Swiften/Elements/MUCUserPayload.h"

+ //TODO: password

+ //TODO: history request

+ joinComplete_ = false;

+ boost::shared_ptr<MUCUserPayload> mucPayload;

+ foreach (boost::shared_ptr<MUCUserPayload> payload, presence->getPayloads<MUCUserPayload>()) {

+ if (payload->getItems().size() > 0 || payload->getStatusCodes().size() > 0) {

+ mucPayload = payload;

+ }

+ }

+

+ if (!joinComplete_) {

+ String reason;

+ onJoinFailed(presence->getPayload<ErrorPayload>());

+ MUCOccupant::Role role(MUCOccupant::NoRole);

+ MUCOccupant::Affiliation affiliation(MUCOccupant::NoAffiliation);

+ if (mucPayload && mucPayload->getItems().size() > 0) {

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

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

+ }

+

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

+ //TODO: Nick changes

+ //TODO: part type

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

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

+ MUCOccupant oldOccupant = it->second;

+ if (oldOccupant.getRole() != role) {

+ onOccupantRoleChanged(nick, role, oldOccupant.getRole());

+ }

+ if (oldOccupant.getAffiliation() != affiliation) {

+ onOccupantAffiliationChanged(nick, affiliation, oldOccupant.getAffiliation());

+ }

+ }

+ std::pair<std::map<String, MUCOccupant>::iterator, bool> result = occupants.insert(std::make_pair(nick, MUCOccupant(nick, role, affiliation)));

+ if (mucPayload && !joinComplete_) {

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

+ if (status.code == 110) {

+ /* Simply knowing this is your presence is enough, 210 doesn't seem to be necessary. */

+ joinComplete_ = true;

+ ownMUCJID = presence->getFrom();

+ onJoinComplete(getOwnNick());

+ presenceSender->addDirectedPresenceReceiver(ownMUCJID);

+ }

+ }

+ }

+

+ * Copyright (c) 2010 Kevin Smith

+ enum LeavingType { Part };

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

+ boost::signal<void (boost::shared_ptr<ErrorPayload>)> onJoinFailed;

+ boost::signal<void (const String&, const MUCOccupant::Role& /*new*/, const MUCOccupant::Role& /*old*/)> onOccupantRoleChanged;

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

+ bool joinComplete_;

+ * Copyright (c) 2010 Kevin Smith

+MUCOccupant::MUCOccupant(const String &nick, Role role, Affiliation affiliation) : nick_(nick), role_(role), affiliation_(affiliation) {

+MUCOccupant::Role MUCOccupant::getRole() const {

+ return role_;

+}

+

+MUCOccupant::Affiliation MUCOccupant::getAffiliation() const {

+ return affiliation_;

+}

+

+void MUCOccupant::setRealJID(const JID& realJID) {

+ realJID_ = realJID;

+}

+

+void MUCOccupant::setNick(const String& nick) {

+ nick_ = nick;

+}

+

+

+boost::optional<JID> MUCOccupant::getRealJID() const {

+ return realJID_;

+}

+

+ * Copyright (c) 2010 Kevin Smith

+#pragma once

+

+#include <boost/optional.hpp>

+#include "Swiften/JID/JID.h"

+ enum Role {Moderator, Participant, Visitor, NoRole};

+ enum Affiliation {Owner, Admin, Member, Outcast, NoAffiliation};

+

+ MUCOccupant(const String &nick, Role role, Affiliation affiliation);

+ Role getRole() const;

+ Affiliation getAffiliation() const;

+ boost::optional<JID> getRealJID() const;

+ void setRealJID(const JID& jid);

+ void setNick(const String& nick);

+ Role role_;

+ Affiliation affiliation_;

+ boost::optional<JID> realJID_;

+#include "Swiften/Parser/PayloadParsers/MUCUserPayloadParserFactory.h"

+ factories_.push_back(shared_ptr<PayloadParserFactory>(new MUCUserPayloadParserFactory()));

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swiften/Parser/PayloadParsers/MUCUserPayloadParser.h"

+

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/MUC/MUCOccupant.h"

+

+#include <cassert>

+#include <iostream>

+

+namespace Swift {

+

+MUCUserPayloadParser::MUCUserPayloadParser() : level(TopLevel) {

+}

+

+void MUCUserPayloadParser::handleStartElement(const String& element, const String&, const AttributeMap& attributes) {

+ if (level == ItemLevel) {

+ if (element == "item") {

+ MUCUserPayload::Item item;

+ String affiliation = attributes.getAttribute("affiliation");

+ String role = attributes.getAttribute("role");

+ String nick = attributes.getAttribute("nick");

+ String jid = attributes.getAttribute("jid");

+ item.affiliation = parseAffiliation(affiliation);

+ item.role = parseRole(role);

+ if (!jid.isEmpty()) {

+ item.realJID = JID(jid);

+ }

+ if (!nick.isEmpty()) {

+ item.nick = nick;

+ }

+ getPayloadInternal()->addItem(item);

+ } else if (element == "status") {

+ MUCUserPayload::StatusCode status;

+ try {

+ status.code = boost::lexical_cast<int>(attributes.getAttribute("code").getUTF8Data());

+ getPayloadInternal()->addStatusCode(status);

+ } catch (boost::bad_lexical_cast&) {

+ }

+ }

+ }

+ ++level;

+}

+

+MUCOccupant::Role MUCUserPayloadParser::parseRole(const String& roleString) const {

+ if (roleString == "moderator") {

+ return MUCOccupant::Moderator;

+ }

+ if (roleString == "participant") {

+ return MUCOccupant::Participant;

+ }

+ if (roleString == "visitor") {

+ return MUCOccupant::Visitor;

+ }

+ if (roleString == "none") {

+ return MUCOccupant::NoRole;

+ }

+ return MUCOccupant::NoRole;

+}

+

+MUCOccupant::Affiliation MUCUserPayloadParser::parseAffiliation(const String& affiliationString) const {

+ if (affiliationString == "owner") {

+ return MUCOccupant::Owner;

+ }

+ if (affiliationString == "admin") {

+ return MUCOccupant::Admin;

+ }

+ if (affiliationString == "member") {

+ return MUCOccupant::Member;

+ }

+ if (affiliationString == "outcast") {

+ return MUCOccupant::Outcast;

+ }

+ if (affiliationString == "none") {

+ return MUCOccupant::NoAffiliation;

+ }

+ return MUCOccupant::NoAffiliation;

+}

+

+

+void MUCUserPayloadParser::handleEndElement(const String& /*element*/, const String&) {

+ --level;

+}

+

+void MUCUserPayloadParser::handleCharacterData(const String& /*data*/) {

+

+}

+

+}

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

+#include "Swiften/Elements/MUCUserPayload.h"

+#include "Swiften/Parser/GenericPayloadParser.h"

+

+namespace Swift {

+ class MUCUserPayloadParser : public GenericPayloadParser<MUCUserPayload> {

+ public:

+ MUCUserPayloadParser();

+

+ virtual void handleStartElement(const String& element, const String&, const AttributeMap& attributes);

+ virtual void handleEndElement(const String& element, const String&);

+ virtual void handleCharacterData(const String& data);

+ MUCOccupant::Role parseRole(const String& itemString) const;

+ MUCOccupant::Affiliation parseAffiliation(const String& statusString) const;

+ private:

+ enum Level {

+ TopLevel = 0,

+ ItemLevel = 1

+ };

+ int level;

+ };

+}

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include "Swiften/Parser/GenericPayloadParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/MUCUserPayloadParser.h"

+

+namespace Swift {

+ class MUCUserPayloadParserFactory : public GenericPayloadParserFactory<MUCUserPayloadParser> {

+ public:

+ MUCUserPayloadParserFactory() : GenericPayloadParserFactory<MUCUserPayloadParser>("x", "http://jabber.org/protocol/muc#user") {}

+ };

+}

+ "PayloadParsers/MUCUserPayloadParser.cpp",

+ "Serializer/PayloadSerializers/MUCUserPayloadSerializer.cpp",

+#include "Swiften/Serializer/PayloadSerializers/MUCUserPayloadSerializer.h"

+ * Copyright (c) 2010 Kevin Smith

+#include "Swiften/Serializer/XML/XMLElement.h"

+

+String MUCPayloadSerializer::serializePayload(boost::shared_ptr<MUCPayload> payload) const {

+ XMLElement mucElement("x", "http://jabber.org/protocol/muc");

+ return mucElement.serialize();

+ * Copyright (c) 2010 Kevin Smith

+#pragma once

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swiften/Serializer/PayloadSerializers/MUCUserPayloadSerializer.h"

+

+#include <sstream>

+

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Base/foreach.h"

+#include "Swiften/Serializer/XML/XMLElement.h"

+#include "Swiften/Serializer/XML/XMLTextNode.h"

+

+

+namespace Swift {

+

+MUCUserPayloadSerializer::MUCUserPayloadSerializer() : GenericPayloadSerializer<MUCUserPayload>() {

+}

+

+String MUCUserPayloadSerializer::serializePayload(boost::shared_ptr<MUCUserPayload> payload) const {

+ XMLElement mucElement("x", "http://jabber.org/protocol/muc");

+ foreach (const MUCUserPayload::StatusCode statusCode, payload->getStatusCodes()) {

+ boost::shared_ptr<XMLElement> statusElement(new XMLElement("status"));

+ std::ostringstream code;

+ code << statusCode.code;

+ statusElement->setAttribute("code", code.str());

+ mucElement.addNode(statusElement);

+ }

+ foreach (const MUCUserPayload::Item item, payload->getItems()) {

+ boost::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

+ itemElement->setAttribute("affiliation", affiliationToString(item.affiliation));

+ itemElement->setAttribute("role", roleToString(item.role));

+ if (item.realJID) {

+ itemElement->setAttribute("jid", item.realJID.get());

+ }

+ if (item.nick) {

+ itemElement->setAttribute("nick", item.nick.get());

+ }

+ mucElement.addNode(itemElement);

+ }

+ return mucElement.serialize();

+}

+

+String MUCUserPayloadSerializer::affiliationToString(MUCOccupant::Affiliation affiliation) const {

+ String result;

+ switch (affiliation) {

+ case MUCOccupant::Owner: result = "owner"; break;

+ case MUCOccupant::Admin: result = "admin"; break;

+ case MUCOccupant::Member: result = "member"; break;

+ case MUCOccupant::Outcast: result = "outcast"; break;

+ case MUCOccupant::NoAffiliation: result = "none"; break;

+ default: assert(false);

+ }

+ return result;

+}

+

+String MUCUserPayloadSerializer::roleToString(MUCOccupant::Role role) const {

+ String result;

+ switch (role) {

+ case MUCOccupant::Moderator: result = "moderator"; break;

+ case MUCOccupant::NoRole: result = "none"; break;

+ case MUCOccupant::Participant: result = "participant"; break;

+ case MUCOccupant::Visitor: result = "visitor"; break;

+ default: assert(false);

+ }

+ return result;

+

+}

+

+

+}

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include "Swiften/Serializer/GenericPayloadSerializer.h"

+#include "Swiften/Elements/MUCUserPayload.h"

+

+namespace Swift {

+ class MUCUserPayloadSerializer : public GenericPayloadSerializer<MUCUserPayload> {

+ public:

+ MUCUserPayloadSerializer();

+ String affiliationToString(MUCOccupant::Affiliation affiliation) const;

+ String roleToString(MUCOccupant::Role role) const;

+

+ virtual String serializePayload(boost::shared_ptr<MUCUserPayload> version) const;

+ };

+}

+