#include <Swiften/Base/foreach.h>

#include <SwifTools/TabComplete.h>

#include <Swiften/Base/foreach.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

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

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

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

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

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swift/Controllers/Roster/Roster.h>

#include <Swift/Controllers/Roster/SetAvatar.h>

#include <Swift/Controllers/Roster/SetPresence.h>

#include <Swiften/Disco/EntityCapsProvider.h>

doneGettingHistory_ = false;

events_ = uiEventStream;

roster_ = new Roster(false, true);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

chatWindow_->setName(muc->getJID().getNode());

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

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

chatWindow_->setRosterModel(NULL);

delete roster_;

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

chatWindow_->setTabComplete(NULL);

delete completer_;

}

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

ChatWindow::Tristate support = ChatWindow::Yes;

bool any = false;

foreach (const std::string& nick, currentOccupants_) {

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

any = true;

} else {

support = ChatWindow::Maybe;

#include <set>

#include <string>

#include <Swiften/Network/Timer.h>

#include <Swift/Controllers/Chat/ChatControllerBase.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/Elements/MUCOccupant.h>

namespace Swift {

class StanzaChannel;

class IQRouter;

class ChatWindowFactory;

class Roster;

class AvatarManager;

class UIEventStream;

class TimerFactory;

class TabComplete;

enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

bool isIncomingMessageFromMe(boost::shared_ptr<Message> message);

std::string senderDisplayNameFromMessage(const JID& from);

boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message> message) const;

void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>);

void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>);

private:

void clearPresenceQueue();

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

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 handleJoinComplete(const std::string& nick);

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

void handleJoinTimeoutTick();

#include <string>

#include "Swiften/Elements/SecurityLabelsCatalog.h"

#include "Swiften/Elements/ChatState.h"

namespace Swift {

class AvatarManager;

class TreeWidget;

class Roster;

class TabComplete;

class ChatWindow {

public:

enum AckState {Pending, Received, Failed};

enum Tristate {Yes, No, Maybe};

ChatWindow() {}

virtual ~ChatWindow() {};

/** Add message to window.

* @return id of added message (for acks).

*/

virtual std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) = 0;

/** Adds action to window.

* @return id of added message (for acks);

* @param alertText Description of alert (required).

* @param buttonText Button text to use (optional, no button is shown if empty).

*/

virtual void setAlert(const std::string& alertText, const std::string& buttonText = "") = 0;

/**

* Removes an alert.

*/

virtual void cancelAlert() = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

boost::signal<void ()> onSendCorrectionMessageRequest;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

boost::signal<void ()> onAlertButtonClicked;

};

}

#endif

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

virtual void setTabComplete(TabComplete*) {};

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

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

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

virtual void flash() {};

virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {};

virtual void cancelAlert() {};

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

std::string name_;

std::string lastMessageBody_;

std::vector<SecurityLabelsCatalog::Item> labels_;

bool labelsEnabled_;

/*

* Copyright (c) 2010-2011 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "QtChatWindow.h"

#include "QtSwiftUtil.h"

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

#include "SwifTools/Linkify.h"

#include "QtChatView.h"

#include "MessageSnippet.h"

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtSettingsProvider.h"

#include "QtScaledAvatarCache.h"

#include "SwifTools/TabComplete.h"

alertLabel_->setStyleSheet(alertStyleSheet_);

alertWidget_->hide();

logRosterSplitter_ = new QSplitter(this);

logRosterSplitter_->setAutoFillBackground(true);

layout->addWidget(logRosterSplitter_);

messageLog_ = new QtChatView(theme, this);

logRosterSplitter_->addWidget(messageLog_);

treeWidget_->hide();

logRosterSplitter_->addWidget(treeWidget_);

logRosterSplitter_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

connect(logRosterSplitter_, SIGNAL(splitterMoved(int, int)), this, SLOT(handleSplitterMoved(int, int)));

QWidget* midBar = new QWidget(this);

layout->addWidget(midBar);

midBar->setAutoFillBackground(true);

QHBoxLayout *midBarLayout = new QHBoxLayout(midBar);

connect(input_, SIGNAL(textChanged()), this, SLOT(handleInputChanged()));

setFocusProxy(input_);

logRosterSplitter_->setFocusProxy(input_);

midBar->setFocusProxy(input_);

messageLog_->setFocusProxy(input_);

connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(qAppFocusChanged(QWidget*, QWidget*)));

connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));

resize(400,300);

connect(messageLog_, SIGNAL(fontResized(int)), this, SIGNAL(fontResized(int)));

}

QtChatWindow::~QtChatWindow() {

}

void QtChatWindow::handleFontResized(int fontSizeSteps) {

messageLog_->resizeFont(fontSizeSteps);

}

void QtChatWindow::handleAlertButtonClicked() {

onAlertButtonClicked();

}

void QtChatWindow::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

void QtChatWindow::replaceLastMessage(const std::string& message) {

messageLog_->replaceLastMessage(P2QSTRING(Linkify::linkify(message)));

}

}

class QTextEdit;

class QLineEdit;

class QComboBox;

class QLabel;

class QSplitter;

class QPushButton;

namespace Swift {

class QtChatView;

class QtChatTheme;

class TreeWidget;

class QtTextEdit;

class UIEventStream;

class QtChatWindow : public QtTabbable, public ChatWindow {

Q_OBJECT

public:

QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream);

~QtChatWindow();

QtTabbable::AlertType getWidgetAlertState();

void setContactChatState(ChatState::ChatStateType state);

void setRosterModel(Roster* roster);

void setTabComplete(TabComplete* completer);

int getCount();

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

void setAckState(const std::string& id, AckState state);

void flash();

QByteArray getSplitterState();

public slots:

void handleChangeSplitterState(QByteArray state);

void handleFontResized(int fontSizeSteps);

void setAlert(const std::string& alertText, const std::string& buttonText = "");

void cancelAlert();

void setCorrectionEnabled(Tristate enabled);

signals:

protected:

void showEvent(QShowEvent* event);

private slots:

void returnPressed();

void handleInputChanged();

void handleKeyPressEvent(QKeyEvent* event);

void handleSplitterMoved(int pos, int index);

void handleAlertButtonClicked();

private:

void updateTitleWithUnreadCount();

void tabComplete();

void beginCorrection();

void cancelCorrection();

std::string addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const QString& style, const boost::posix_time::ptime& time);

int unreadCount_;

bool contactIsTyping_;

LastLineTracker lastLineTracker_;

QString contact_;

QString lastSentMessage_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QComboBox* labelsWidget_;

QLabel* correctingLabel_;

QLabel* alertLabel_;

QWidget* alertWidget_;

QPushButton* alertButton_;

TabComplete* completer_;

std::vector<SecurityLabelsCatalog::Item> availableLabels_;

bool isCorrection_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

tabs_->setTabPosition(QTabWidget::South);

mainLayout->addWidget(tabs_);

contactsTabWidget_ = new QWidget(this);

contactsTabWidget_->setContentsMargins(0, 0, 0, 0);

QBoxLayout *contactTabLayout = new QBoxLayout(QBoxLayout::TopToBottom, contactsTabWidget_);

contactsTabWidget_->setLayout(contactTabLayout);

contactTabLayout->setSpacing(0);

contactTabLayout->setContentsMargins(0, 0, 0, 0);

contactTabLayout->addWidget(treeWidget_);

tabs_->addTab(contactsTabWidget_, tr("&Contacts"));

eventWindow_ = new QtEventWindow(uiEventStream_);

connect(eventWindow_, SIGNAL(onNewEventCountUpdated(int)), this, SLOT(handleEventCountUpdated(int)));

chatListWindow_ = new QtChatListWindow(uiEventStream_);

connect(chatListWindow_, SIGNAL(onCountUpdated(int)), this, SLOT(handleChatCountUpdated(int)));

connect(chatUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleChatUserActionTriggered(bool)));

actionsMenu->addAction(chatUserAction_);

serverAdHocMenu_ = new QMenu(tr("Run Server Command"), this);

actionsMenu->addMenu(serverAdHocMenu_);

actionsMenu->addSeparator();

QAction* signOutAction = new QAction(tr("&Sign Out"), this);

connect(signOutAction, SIGNAL(triggered()), SLOT(handleSignOutAction()));

actionsMenu->addAction(signOutAction);

setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

QAction* adHocAction = new QAction(tr("Collecting commands..."), this);

adHocAction->setEnabled(false);

serverAdHocMenu_->addAction(adHocAction);

serverAdHocCommandActions_.append(adHocAction);

lastOfflineState_ = false;

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

* Licensed under the GNU General Public License v3.

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

*/

#include "Roster/QtOccupantListWidget.h"

#include <QContextMenuEvent>

#include <QMenu>

#include <QInputDialog>

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

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

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

#include "QtSwiftUtil.h"

namespace Swift {

QtOccupantListWidget::QtOccupantListWidget(UIEventStream* eventStream, QWidget* parent) : QtTreeWidget(eventStream, parent) {

}

QtOccupantListWidget::~QtOccupantListWidget() {

}

void QtOccupantListWidget::contextMenuEvent(QContextMenuEvent* event) {

}

}

* Copyright (c) 2011 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include "Swift/QtUI/Roster/QtTreeWidget.h"

namespace Swift {

class QtOccupantListWidget : public QtTreeWidget {

Q_OBJECT

public:

QtOccupantListWidget(UIEventStream* eventStream, QWidget* parent = 0);

virtual ~QtOccupantListWidget();

protected:

void contextMenuEvent(QContextMenuEvent* event);

};

}

void QtRosterWidget::renameGroup(GroupRosterItem* group) {

bool ok;

QString newName = QInputDialog::getText(NULL, tr("Rename group"), tr("Enter a new name for group '%1':").arg(P2QSTRING(group->getDisplayName())), QLineEdit::Normal, P2QSTRING(group->getDisplayName()), &ok);

if (ok) {

eventStream_->send(boost::make_shared<RenameGroupUIEvent>(group->getDisplayName(), Q2PSTRING(newName)));

}

}

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include "Swift/QtUI/Roster/QtTreeWidget.h"

namespace Swift {

class QtRosterWidget : public QtTreeWidget {

Q_OBJECT

public:

QtRosterWidget(UIEventStream* eventStream, QWidget* parent = 0);

virtual ~QtRosterWidget();

public slots:

void handleEditUserActionTriggered(bool checked);

protected:

void contextMenuEvent(QContextMenuEvent* event);

private:

void renameGroup(GroupRosterItem* group);

};

}

if (ranges.at(i).left() == 0 && ranges.at(i).right() == right) {

for (int r = ranges.at(i).top(); r <= ranges.at(i).bottom(); ++r) {

selectedIndexList.append(ranges.at(i).model()->index(r, 0, parent));

}

}

}

return selectedIndexList;

}

void QtTreeWidget::handleItemActivated(const QModelIndex& index) {

RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

if (contact) {

eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(contact->getJID())));

}

}

void QtTreeWidget::handleExpanded(const QModelIndex& index) {

class QtTreeWidget : public QTreeView{

Q_OBJECT

public:

QtTreeWidget(UIEventStream* eventStream, QWidget* parent = 0);

~QtTreeWidget();

void show();

QtTreeWidgetItem* getRoot();

void setRosterModel(Roster* roster);

Roster* getRoster() {return roster_;}

private slots:

void handleItemActivated(const QModelIndex&);

void handleModelItemExpanded(const QModelIndex&, bool expanded);

void handleExpanded(const QModelIndex&);

void handleCollapsed(const QModelIndex&);

void handleClicked(const QModelIndex&);

protected:

QModelIndexList getSelectedIndexes() const;

private:

void drawBranches(QPainter*, const QRect&, const QModelIndex&) const;

protected:

UIEventStream* eventStream_;

private:

RosterModel* model_;

Roster* roster_;

RosterDelegate* delegate_;

QtTreeWidgetItem* treeRoot_;

};

#include <boost/optional.hpp>

#include <boost/shared_ptr.hpp>

#include <string>

#include <vector>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/MUCOccupant.h>

namespace Swift {

class MUCUserPayload : public Payload {

public:

typedef boost::shared_ptr<MUCUserPayload> ref;

struct StatusCode {

StatusCode() : code(0) {}

int code;

};

// struct Password {

// }

// }

// struct Invite {

// }

MUCUserPayload() {

}

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

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

private:

std::vector<StatusCode> statusCodes_;

};

}

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Elements/MUCPayload.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/Queries/GenericRequest.h>

namespace Swift {

typedef std::pair<std::string, MUCOccupant> StringMUCOccupantPair;

MUC::MUC(StanzaChannel* stanzaChannel, IQRouter* iqRouter, DirectedPresenceSender* presenceSender, const JID &muc, MUCRegistry* mucRegistry) : ownMUCJID(muc), stanzaChannel(stanzaChannel), iqRouter_(iqRouter), presenceSender(presenceSender), mucRegistry(mucRegistry) {

std::string nick = presence->getFrom().getResource();

if (nick.empty()) {

return;

}

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

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

boost::optional<JID> realJID;

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

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

if (presence->getFrom() == ownMUCJID) {

bool MUC::hasOccupant(const std::string& nick) {

return occupants.find(nick) != occupants.end();

}

MUCOccupant MUC::getOccupant(const std::string& nick) {

return occupants.find(nick)->second;

}

//FIXME: Recognise Topic changes

//TODO: Invites(direct/mediated)

//TODO: requesting membership

//TODO: get member list

//TODO: request voice

#pragma once

#include <Swiften/JID/JID.h>

#include <string>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/Elements/MUCOwnerPayload.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/signals/connection.hpp>

#include <map>

namespace Swift {

class StanzaChannel;

/*void queryRoomItems(); */

std::string getCurrentNick();

void part();

void handleIncomingMessage(Message::ref message);

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

void handleUserLeft(LeavingType);

/** Get occupant information*/

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

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

public:

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

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

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 (const MUCInfo&)> onInfoResult; */

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

const std::string& getOwnNick() const {

return ownMUCJID.getResource();

}

private:

void handleIncomingPresence(Presence::ref presence);

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

void handleCreationConfigResponse(MUCOwnerPayload::ref, ErrorPayload::ref);

private:

JID ownMUCJID;

StanzaChannel* stanzaChannel;

IQRouter* iqRouter_;

DirectedPresenceSender* presenceSender;

MUCRegistry* mucRegistry;

std::map<std::string, MUCOccupant> occupants;

bool joinSucceeded_;

#include <Swiften/Parser/PayloadParsers/StreamInitiationParserFactory.h>

#include <Swiften/Parser/PayloadParsers/BytestreamsParserFactory.h>

#include <Swiften/Parser/PayloadParsers/IBBParser.h>

#include <Swiften/Parser/PayloadParsers/VCardUpdateParserFactory.h>

#include <Swiften/Parser/PayloadParsers/VCardParserFactory.h>

#include <Swiften/Parser/PayloadParsers/RawXMLPayloadParserFactory.h>

#include <Swiften/Parser/PayloadParsers/PrivateStorageParserFactory.h>

#include <Swiften/Parser/PayloadParsers/DelayParser.h>

#include <Swiften/Parser/PayloadParsers/MUCUserPayloadParserFactory.h>

#include <Swiften/Parser/PayloadParsers/NicknameParserFactory.h>

#include <Swiften/Parser/PayloadParsers/ReplaceParser.h>

#include <Swiften/Parser/PayloadParsers/LastParser.h>

using namespace boost;

namespace Swift {

FullPayloadParserFactoryCollection::FullPayloadParserFactoryCollection() {

factories_.push_back(shared_ptr<PayloadParserFactory>(new InBandRegistrationPayloadParserFactory()));

factories_.push_back(shared_ptr<PayloadParserFactory>(new SearchPayloadParserFactory()));

factories_.push_back(shared_ptr<PayloadParserFactory>(new StreamInitiationParserFactory()));

factories_.push_back(shared_ptr<PayloadParserFactory>(new BytestreamsParserFactory()));

factories_.push_back(shared_ptr<PayloadParserFactory>(new VCardUpdateParserFactory()));

factories_.push_back(shared_ptr<PayloadParserFactory>(new VCardParserFactory()));

factories_.push_back(shared_ptr<PayloadParserFactory>(new PrivateStorageParserFactory(this)));

factories_.push_back(shared_ptr<PayloadParserFactory>(new ChatStateParserFactory()));

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

factories_.push_back(shared_ptr<PayloadParserFactory>(new NicknameParserFactory()));

foreach(shared_ptr<PayloadParserFactory> factory, factories_) {

addFactory(factory.get());

}

defaultFactory_ = new RawXMLPayloadParserFactory();

setDefaultFactory(defaultFactory_);

}

FullPayloadParserFactoryCollection::~FullPayloadParserFactoryCollection() {

* 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/Elements/MUCOccupant.h>

namespace Swift {

}

}

}

}

* 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>

namespace Swift {

public:

};

}

sources = [

"AttributeMap.cpp",

"AuthRequestParser.cpp",

"AuthChallengeParser.cpp",

"AuthSuccessParser.cpp",

"AuthResponseParser.cpp",

"CompressParser.cpp",

"ElementParser.cpp",

"IQParser.cpp",

"MessageParser.cpp",

"PayloadParser.cpp",

"StanzaAckParser.cpp",

"ComponentHandshakeParser.cpp",

"PayloadParserFactory.cpp",

"PayloadParserFactoryCollection.cpp",

"PayloadParsers/BodyParser.cpp",

"PayloadParsers/SubjectParser.cpp",

"PayloadParsers/ChatStateParser.cpp",

"PayloadParsers/StorageParser.cpp",

"PayloadParsers/StatusParser.cpp",

"PayloadParsers/StatusShowParser.cpp",

"PayloadParsers/StreamInitiationParser.cpp",

"PayloadParsers/BytestreamsParser.cpp",

"PayloadParsers/VCardParser.cpp",

"PayloadParsers/VCardUpdateParser.cpp",

"PayloadParsers/DelayParser.cpp",

"PayloadParsers/MUCUserPayloadParser.cpp",

"PayloadParsers/NicknameParser.cpp",

"PayloadParsers/ReplaceParser.cpp",

"PayloadParsers/LastParser.cpp",

"PlatformXMLParserFactory.cpp",

"PresenceParser.cpp",

"SerializingParser.cpp",

"StanzaParser.cpp",

"StreamErrorParser.cpp",

"StreamFeaturesParser.cpp",

"StreamManagementEnabledParser.cpp",

"StreamResumeParser.cpp",

"StreamResumedParser.cpp",

"XMLParser.cpp",

"XMLParserClient.cpp",

"XMLParserFactory.cpp",

"XMPPParser.cpp",

"XMPPParserClient.cpp",

]

if myenv.get("HAVE_EXPAT", 0) :

myenv.Append(CPPDEFINES = "HAVE_EXPAT")

"Serializer/PayloadSerializers/IBBSerializer.cpp",

"Serializer/PayloadSerializers/CapsInfoSerializer.cpp",

"Serializer/PayloadSerializers/ChatStateSerializer.cpp",

"Serializer/PayloadSerializers/DiscoInfoSerializer.cpp",

"Serializer/PayloadSerializers/DiscoItemsSerializer.cpp",

"Serializer/PayloadSerializers/ErrorSerializer.cpp",

"Serializer/PayloadSerializers/FullPayloadSerializerCollection.cpp",

"Serializer/PayloadSerializers/MUCPayloadSerializer.cpp",

"Serializer/PayloadSerializers/MUCUserPayloadSerializer.cpp",

"Serializer/PayloadSerializers/MUCOwnerPayloadSerializer.cpp",

"Serializer/PayloadSerializers/ResourceBindSerializer.cpp",

"Serializer/PayloadSerializers/RosterItemExchangeSerializer.cpp",

"Serializer/PayloadSerializers/RosterSerializer.cpp",

"Serializer/PayloadSerializers/SecurityLabelSerializer.cpp",

"Serializer/PayloadSerializers/SecurityLabelsCatalogSerializer.cpp",

"Serializer/PayloadSerializers/SoftwareVersionSerializer.cpp",

"Serializer/PayloadSerializers/StreamInitiationSerializer.cpp",

"Serializer/PayloadSerializers/BytestreamsSerializer.cpp",

File("Parser/PayloadParsers/UnitTest/SoftwareVersionParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/StatusParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/StatusShowParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/StreamInitiationParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/VCardParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/StorageParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/PrivateStorageParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/VCardUpdateParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/ReplaceTest.cpp"),

File("Parser/UnitTest/AttributeMapTest.cpp"),

File("Parser/UnitTest/IQParserTest.cpp"),

File("Parser/UnitTest/MessageParserTest.cpp"),

File("Parser/UnitTest/PayloadParserFactoryCollectionTest.cpp"),

File("Parser/UnitTest/PresenceParserTest.cpp"),

File("Parser/UnitTest/StanzaAckParserTest.cpp"),

File("Parser/UnitTest/SerializingParserTest.cpp"),

File("Parser/UnitTest/StanzaParserTest.cpp"),

File("Parser/UnitTest/StreamFeaturesParserTest.cpp"),

File("Parser/UnitTest/StreamManagementEnabledParserTest.cpp"),

File("Parser/UnitTest/XMLParserTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StatusSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StatusShowSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StreamInitiationSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/InBandRegistrationPayloadSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/VCardUpdateSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/VCardSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StorageSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/PrivateStorageSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/ReplaceSerializerTest.cpp"),

File("Serializer/UnitTest/StreamFeaturesSerializerTest.cpp"),

File("Serializer/UnitTest/AuthSuccessSerializerTest.cpp"),

File("Serializer/UnitTest/AuthChallengeSerializerTest.cpp"),

File("Serializer/UnitTest/AuthRequestSerializerTest.cpp"),

File("Serializer/UnitTest/AuthResponseSerializerTest.cpp"),

File("Serializer/UnitTest/XMPPSerializerTest.cpp"),

File("Serializer/XML/UnitTest/XMLElementTest.cpp"),

File("StreamManagement/UnitTest/StanzaAckRequesterTest.cpp"),

File("StreamManagement/UnitTest/StanzaAckResponderTest.cpp"),

#include <Swiften/Serializer/PayloadSerializers/BlockSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/SubjectSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/ChatStateSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/PrioritySerializer.h>

#include <Swiften/Serializer/PayloadSerializers/ErrorSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/RosterSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/RosterItemExchangeSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/MUCPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/MUCUserPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/MUCOwnerPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/SoftwareVersionSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/StatusSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/StatusShowSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DiscoInfoSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/DiscoItemsSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/CapsInfoSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/ResourceBindSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/StartSessionSerializer.h>

serializers_.push_back(new BodySerializer());

serializers_.push_back(new SubjectSerializer());

serializers_.push_back(new ChatStateSerializer());

serializers_.push_back(new PrioritySerializer());

serializers_.push_back(new ErrorSerializer());

serializers_.push_back(new RosterSerializer());

serializers_.push_back(new RosterItemExchangeSerializer());

serializers_.push_back(new MUCPayloadSerializer());

serializers_.push_back(new MUCUserPayloadSerializer());

serializers_.push_back(new MUCOwnerPayloadSerializer(this));

serializers_.push_back(new SoftwareVersionSerializer());

serializers_.push_back(new StatusSerializer());

serializers_.push_back(new StatusShowSerializer());

serializers_.push_back(new DiscoInfoSerializer());

serializers_.push_back(new DiscoItemsSerializer());

serializers_.push_back(new CapsInfoSerializer());

serializers_.push_back(new BlockSerializer<BlockPayload>("block"));

serializers_.push_back(new BlockSerializer<UnblockPayload>("unblock"));

#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>() {

}

std::string MUCUserPayloadSerializer::serializePayload(boost::shared_ptr<MUCUserPayload> payload) const {

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

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

}

}

return mucElement.serialize();

}

}

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Elements/MUCUserPayload.h>

namespace Swift {

class MUCUserPayloadSerializer : public GenericPayloadSerializer<MUCUserPayload> {

public:

MUCUserPayloadSerializer();

virtual std::string serializePayload(boost::shared_ptr<MUCUserPayload> version) const;

};

}