<key>?name?</key>

<value></value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.append_environment</key>

<value>true</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.autoBuildTarget</key>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.buildArguments</key>

<value>${ProjDirPath}/3rdParty/SCons/scons.py</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.buildCommand</key>

<value>python</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>

<value>-c</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.contents</key>

<value>org.eclipse.cdt.make.core.activeConfigSettings</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.enableAutoBuild</key>

<key>org.eclipse.cdt.make.core.enableCleanBuild</key>

<value>true</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.enableFullBuild</key>

<value>true</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.fullBuildTarget</key>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.stopOnError</key>

<value>true</value>

</dictionary>

<dictionary>

<key>org.eclipse.cdt.make.core.useDefaultBuildCmd</key>

<value>false</value>

</dictionary>

[including the GNU Public Licence.]

--- END OF OpenSSL LICENSE ---

Swift contains some code contributed under the BSD License, under the following terms:

--- START OF BSD LICENSE

Copyright (c) 2011, Arnt Gulbrandsen

Copyright (c) 2011, Thilo Cestonaro

Copyright (c) 2011, Vlad Voicu

Copyright (c) 2011, Jan Kaluza

All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

Neither the name of their organizations nor the names of the contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

--- END OF BSD LICENSE

#include <map>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/algorithm/string.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

namespace Swift {

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, EntityCapsProvider* entityCapsProvider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider) {

chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));

setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

if (messageEvent->isReadable() && !messageEvent->getConcluded()) {

unreadMessages_.push_back(messageEvent);

}

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

std::string body = message->getBody();

if (message->isError()) {

std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

chatWindow_->addErrorMessage(errorMessage);

}

else {

if (!messageEvent->isReadable()) {

return;

}

showChatWindow();

JID from = message->getFrom();

std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

if (!delayPayloads[i]->getFrom()) {

case ErrorPayload::ServiceUnavailable: return QT_TRANSLATE_NOOP("", "The service is unavailable"); break;

case ErrorPayload::SubscriptionRequired: return QT_TRANSLATE_NOOP("", "A subscription is required"); break;

case ErrorPayload::UndefinedCondition: return QT_TRANSLATE_NOOP("", "Undefined condition"); break;

case ErrorPayload::UnexpectedRequest: return QT_TRANSLATE_NOOP("", "Unexpected request"); break;

}

}

return defaultMessage;

}

}

private:

IDGenerator idGenerator_;

std::string lastSentMessageStanzaID_;

void createDayChangeTimer();

void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

void handleDayChangeTick();

protected:

JID selfJID_;

std::vector<boost::shared_ptr<MessageEvent> > unreadMessages_;

StanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

ChatWindowFactory* chatWindowFactory_;

ChatWindow* chatWindow_;

JID toJID_;

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swift/Controllers/FileTransfer/FileTransferController.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swift/Controllers/ProfileSettingsProvider.h>

#include <Swiften/Avatars/AvatarManager.h>

namespace Swift {

typedef std::pair<JID, ChatController*> JIDChatControllerPair;

typedef std::pair<JID, MUCController*> JIDMUCControllerPair;

#define RECENT_CHATS "recent_chats"

ChatsManager::ChatsManager(

}

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

return;

}

// Try to deliver it to a MUC

std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());

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

i->second->handleIncomingMessage(event);

return;

}

else if (message->getType() == Message::Groupchat) {

//FIXME: Error handling - groupchat messages from an unknown muc.

return;

}

void ChatsManager::handleRecentActivated(const ChatListWindow::Chat& chat) {

if (chat.isMUC) {

uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, chat.nick));

}

else {

uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(chat.jid));

}

}

}

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

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

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

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

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

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

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

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, 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));

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

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

if (timerFactory) {

void MUCController::handleConfigurationFormReceived(Form::ref form) {

chatWindow_->showRoomConfigurationForm(form);

}

void MUCController::handleDestroyRoomRequest() {

muc_->destroyRoom();

}

}

void updateJoinParts();

bool shouldUpdateJoinParts();

void dayTicked() {lastWasPresence_ = false;}

void processUserPart();

void handleBareJIDCapsChanged(const JID& jid);

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

private:

MUC::ref muc_;

UIEventStream* events_;

std::string nick_;

std::string desiredNick_;

Roster* roster_;

TabComplete* completer_;

bool parting_;

virtual void addSystemMessage(const std::string& message) = 0;

virtual void addPresenceMessage(const std::string& message) = 0;

virtual void addErrorMessage(const std::string& message) = 0;

virtual void replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time) = 0;

// File transfer related stuff

virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 0;

virtual void setFileTransferProgress(std::string, const int percentageDone) = 0;

virtual void setFileTransferStatus(std::string, const FileTransferState state, const std::string& msg = "") = 0;

virtual void setContactChatState(ChatState::ChatStateType state) = 0;

virtual void setName(const std::string& name) = 0;

virtual void show() = 0;

virtual void activate() = 0;

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) = 0;

virtual void setSecurityLabelsEnabled(bool enabled) = 0;

virtual void setCorrectionEnabled(Tristate enabled) = 0;

virtual void setUnreadMessageCount(int count) = 0;

virtual void setSecurityLabelsError() = 0;

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() = 0;

virtual void setInputEnabled(bool enabled) = 0;

virtual void setRosterModel(Roster* model) = 0;

virtual void setTabComplete(TabComplete* completer) = 0;

virtual void replaceLastMessage(const std::string& message) = 0;

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

virtual void flash() = 0;

virtual void setSubject(const std::string& subject) = 0;

/**

* Set an alert on the window.

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

*/

boost::signal<void ()> onSendCorrectionMessageRequest;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

boost::signal<void ()> onAlertButtonClicked;

boost::signal<void (ContactRosterItem*)> onOccupantSelectionChanged;

boost::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;

boost::signal<void (const std::string&)> onChangeSubjectRequest;

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

boost::signal<void ()> onDestroyRequest;

// File transfer related

boost::signal<void (std::string /* id */)> onFileTransferCancel;

boost::signal<void (std::string /* id */, std::string /* description */)> onFileTransferStart;

boost::signal<void (std::string /* id */, std::string /* path */)> onFileTransferAccept;

boost::signal<void (std::string /* path */)> onSendFileRequest;

};

}

#endif

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*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

void setSubject(const std::string& /*subject*/) {}

virtual void showRoomConfigurationForm(Form::ref) {}

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

#include "MessageSnippet.h"

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtSettingsProvider.h"

#include "QtScaledAvatarCache.h"

#include "SwifTools/TabComplete.h"

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

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

#include "QtFileTransferJSBridge.h"

#include <boost/cstdint.hpp>

#include <boost/format.hpp>

#include <boost/lexical_cast.hpp>

#include <QLabel>

#include <QInputDialog>

#include <QApplication>

#include <QBoxLayout>

#include <QCloseEvent>

#include <QComboBox>

#include <QFileInfo>

#include <QLineEdit>

#include <QSplitter>

#include <QString>

//subject_->setVisible(!subject.empty());

subject_->setText(P2QSTRING(subject));

}

void QtChatWindow::handleActionButtonClicked() {

QMenu contextMenu;

QAction* changeSubject = contextMenu.addAction(tr("Change subject"));

QAction* configure = contextMenu.addAction(tr("Configure room"));

QAction* destroy = contextMenu.addAction(tr("Destroy room"));

QAction* result = contextMenu.exec(QCursor::pos());

if (result == changeSubject) {

bool ok;

QString subject = QInputDialog::getText(this, tr("Change room subject"), tr("New subject:"), QLineEdit::Normal, subject_->text(), &ok);

if (ok) {

onChangeSubjectRequest(Q2PSTRING(subject));

}

}

else if (result == configure) {

onConfigureRequest(Form::ref());

}

else if (result == destroy) {

onDestroyRequest();

}

}

void QtChatWindow::showRoomConfigurationForm(Form::ref form) {

if (mucConfigurationWindow) {

delete mucConfigurationWindow.data();

}

mucConfigurationWindow = new QtMUCConfigurationWindow(form);

mucConfigurationWindow->onFormComplete.connect(boost::bind(boost::ref(onConfigureRequest), _1));

}

}

void setTabComplete(TabComplete* completer);

int getCount();

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

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

void flash();

QByteArray getSplitterState();

virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions);

void setSubject(const std::string& subject);

void showRoomConfigurationForm(Form::ref);

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:

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/MUCPayload.h>

#include <Swiften/Elements/MUCDestroyPayload.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) {

scopedConnection_ = stanzaChannel->onPresenceReceived.connect(boost::bind(&MUC::handleIncomingPresence, this, _1));

void MUC::destroyRoom() {

MUCOwnerPayload::ref mucPayload = boost::make_shared<MUCOwnerPayload>();

MUCDestroyPayload::ref mucDestroyPayload = boost::make_shared<MUCDestroyPayload>();

mucPayload->setPayload(mucDestroyPayload);

GenericRequest<MUCOwnerPayload>* request = new GenericRequest<MUCOwnerPayload>(IQ::Set, getJID(), mucPayload, iqRouter_);

request->onResponse.connect(boost::bind(&MUC::handleConfigurationResultReceived, this, _1, _2));

request->send();

}

//TODO: Invites(direct/mediated)

//TODO: requesting membership

//TODO: get member list

//TODO: request voice

//TODO: moderator use cases

void handleUserLeft(LeavingType);

/** Get occupant information*/

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

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

void kickUser(const JID& jid);

void changeSubject(const std::string& subject);

void requestConfigurationForm();

void configureRoom(Form::ref);

void destroyRoom();

public:

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

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

boost::signal<void (ErrorPayload::ref, const JID&)> onKickFailed;

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

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;

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

#include <Swiften/Parser/PayloadParsers/VCardParser.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/MUCAdminPayloadParser.h>

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

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

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

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

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

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

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

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

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

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

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

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<SearchPayloadParser> >("query", "jabber:iq:search"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<StreamInitiationParser> >("si", "http://jabber.org/protocol/si"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<BytestreamsParser> >("query", "http://jabber.org/protocol/bytestreams"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<VCardUpdateParser> >("x", "vcard-temp:x:update"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<VCardParser> >("vCard", "vcard-temp"));

factories_.push_back(boost::make_shared<PrivateStorageParserFactory>(this));

factories_.push_back(boost::make_shared<ChatStateParserFactory>());

factories_.push_back(boost::make_shared<MUCUserPayloadParserFactory>(this));

factories_.push_back(boost::make_shared<MUCOwnerPayloadParserFactory>(this));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<MUCAdminPayloadParser> >("query", "http://jabber.org/protocol/muc#admin"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<MUCDestroyPayloadParser> >("destroy", "http://jabber.org/protocol/muc#user"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<MUCDestroyPayloadParser> >("destroy", "http://jabber.org/protocol/muc#owner"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<NicknameParser> >("nick", "http://jabber.org/protocol/nick"));

factories_.push_back(boost::make_shared<JingleParserFactory>(this));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<JingleReasonParser> >("reason", "urn:xmpp:jingle:1"));

factories_.push_back(boost::make_shared<JingleContentPayloadParserFactory>(this));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<JingleIBBTransportMethodPayloadParser> >("transport", "urn:xmpp:jingle:transports:ibb:1"));

factories_.push_back(boost::make_shared<GenericPayloadParserFactory<JingleS5BTransportMethodPayloadParser> >("transport", "urn:xmpp:jingle:transports:s5b:1"));

"PayloadParsers/StreamInitiationParser.cpp",

"PayloadParsers/BytestreamsParser.cpp",

"PayloadParsers/VCardParser.cpp",

"PayloadParsers/VCardUpdateParser.cpp",

"PayloadParsers/DelayParser.cpp",

"PayloadParsers/MUCUserPayloadParser.cpp",

"PayloadParsers/MUCAdminPayloadParser.cpp",

"PayloadParsers/MUCOwnerPayloadParser.cpp",

"PayloadParsers/MUCDestroyPayloadParser.cpp",

"PayloadParsers/MUCItemParser.cpp",

"PayloadParsers/NicknameParser.cpp",

"PayloadParsers/ReplaceParser.cpp",

"PayloadParsers/LastParser.cpp",

"PayloadParsers/S5BProxyRequestParser.cpp",

"PlatformXMLParserFactory.cpp",

"PresenceParser.cpp",

"SerializingParser.cpp",

"StanzaParser.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/MUCAdminPayloadSerializer.cpp",

"Serializer/PayloadSerializers/MUCOwnerPayloadSerializer.cpp",

"Serializer/PayloadSerializers/MUCDestroyPayloadSerializer.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",

"Serializer/PayloadSerializers/VCardSerializer.cpp",

#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/MUCAdminPayloadSerializer.h>

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

#include <Swiften/Serializer/PayloadSerializers/MUCDestroyPayloadSerializer.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>

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

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

serializers_.push_back(new MUCAdminPayloadSerializer());

serializers_.push_back(new MUCOwnerPayloadSerializer(this));

serializers_.push_back(new MUCUserPayloadSerializer(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"));