void MainController::handleServerStopped(boost::optional<ServerError> error) {

if (error) {

std::string message;

switch (error->getType()) {

case ServerError::C2SPortConflict:

break;

case ServerError::C2SError:

message = std::string("Local connection server error");

break;

case ServerError::LinkLocalPortConflict:

break;

case ServerError::LinkLocalError:

message = std::string("External connection server error");

break;

}

menuletController->setXMPPStatus(message, MenuletController::Offline);

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%. To reconnect, Sign Out and provide your password again.")) % jid_.getDomain() % message);

} else {

if (!offlineRequested_) {

setReconnectTimer();

}

if (lastDisconnectError_) {

lastDisconnectError_->conclude();

} else {

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%.")) % jid_.getDomain() % message);

}

lastDisconnectError_ = std::make_shared<ErrorEvent>(JID(jid_.getDomain()), message);

eventController_->handleIncomingEvent(lastDisconnectError_);

QtCachedImageScaler::QtCachedImageScaler() {

}

boost::filesystem::path QtCachedImageScaler::getScaledImage(const boost::filesystem::path& imagePath, int size) {

boost::filesystem::path scaledImagePath(imagePath);

scaledImagePath = stringToPath(pathToString(scaledImagePath) + suffix);

if (!boost::filesystem::exists(scaledImagePath)) {

QImage image(P2QSTRING(pathToString(imagePath)));

if (!image.isNull()) {

if (image.width() > size || image.height() > size) {

QImage scaledImage = image.scaled(size, size, Qt::KeepAspectRatio, Qt::SmoothTransformation);

if (type == FormField::ListMultiType) {

widget = createList(field);

}

std::string indexString;

if (index) {

/* for multi-item forms we need to distinguish between the different rows */

}

fields_[field->getName() + indexString] = widget;

return widget;

}

Form::ref QtFormWidget::getCompletedForm() {

// note: time uses localtime

QDate date = QDate(time.date().year(), time.date().month(), time.date().day());

QTime dayTime = QTime(time.time_of_day().hours(), time.time_of_day().minutes(), time.time_of_day().seconds());

QDateTime qTime = QDateTime(date, dayTime);

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

if (addAtTheTop) {

bool appendToPrevious = ((senderIsSelf && previousTopMessageWasSelf_) || (!senderIsSelf && !previousTopMessageWasSelf_&& previousTopSenderName_ == P2QSTRING(senderName)));

conversation_->addMessageTop(std::make_shared<MessageSnippet>(messageHTML, QtUtilities::htmlEscape(P2QSTRING(senderName)), qTime, qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), ChatSnippet::getDirection(message)));

addSystemMessage(ChatWindow::ChatMessage("Message delivery failed due to disconnection from server."), ChatWindow::DefaultDirection);

}

}

std::string QtPlainChatView::addFileTransfer(const std::string& senderName, const std::string& /*avatarPath*/, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description)

{

const std::string sizeString = formatSize(sizeInBytes);

FileTransfer* transfer;

if (senderIsSelf) {

QString description = QInputDialog::getText(this, tr("File transfer description"),

tr("Description:"), QLineEdit::Normal, "");

QString highlightSpanEnd = highlightWholeMessage ? "</span>" : "";

htmlString += "<span class='swift_inner_message'>" + styleSpanStart + highlightSpanStart + message + highlightSpanEnd + styleSpanEnd + "</span>" ;

bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasMessage, senderName, senderIsSelf, label);

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.svg" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

addMessageBottom(std::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), direction));

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

previousMessageKind_ = PreviousMessageWasMessage;

previousMessageDisplayMarking_ = messageMarkingValue;

"</div>";

}

bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasFileTransfer, senderName, senderIsSelf);

QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.svg" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

addMessageBottom(std::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::universal_time()), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

previousMessageKind_ = PreviousMessageWasFileTransfer;

return Q2PSTRING(ft_id);

htmlString = "<div id='" + wb_id + "'>" + actionText.arg(QtUtilities::htmlEscape(contact)) + ": <br/>" +

buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +

buildChatWindowButton(tr("Accept"), ButtonWhiteboardSessionAcceptRequest, wb_id) +

"</div>";

}

QString qAvatarPath = "qrc:/icons/avatar.svg";

addMessageBottom(std::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(contact), B2QDATE(boost::posix_time::second_clock::universal_time()), qAvatarPath, false, false, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));

previousMessageWasSelf_ = false;

previousSenderName_ = contact;

return Q2PSTRING(wb_id);

}

void QtWebKitChatView::addErrorMessage(const ChatWindow::ChatMessage& errorMessage) {

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString errorMessageHTML(chatMessageToHTML(errorMessage));

addMessageBottom(std::make_shared<SystemMessageSnippet>("<span class=\"error\">" + errorMessageHTML + "</span>", QDateTime::currentDateTime(), false, theme_, P2QSTRING(id), ChatSnippet::getDirection(errorMessage)));

previousMessageWasSelf_ = false;

previousMessageKind_ = PreviousMessageWasSystem;

}

std::string QtWebKitChatView::addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString messageHTML = chatMessageToHTML(message);

addMessageBottom(std::make_shared<SystemMessageSnippet>(messageHTML, QDateTime::currentDateTime(), false, theme_, P2QSTRING(id), getActualDirection(message, direction)));

previousMessageKind_ = PreviousMessageWasSystem;

return id;

}

void QtWebKitChatView::addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {

if (window_->isWidgetSelected()) {

window_->onAllMessagesRead();

}

QString messageHTML = chatMessageToHTML(message);

addMessageBottom(std::make_shared<SystemMessageSnippet>(messageHTML, QDateTime::currentDateTime(), false, theme_, P2QSTRING(id), getActualDirection(message, direction)));

previousMessageKind_ = PreviousMessageWasPresence;

}

void QtWebKitChatView::replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour timestampBehaviour) {

}

else {

result += host;

}

if (port) {

result += ":";

}

result += path;

return result;

}

// Disabling this code for now, since GCC4.5+boost1.42 (on ubuntu) seems to

append(result, getEncoded("msg=" + message));

}

if (!nick.empty()) {

append(result, getEncoded("nick=" + nick));

}

if (port) {

}

switch (status) {

case Available: append(result, getEncoded("status=avail")); break;

case Away: append(result, getEncoded("status=away")); break;

case DND: append(result, getEncoded("status=dnd")); break;

port_ = endpoint.port();

}

std::string HostAddressPort::toString() const {

std::string portAsString;

try {

} catch (boost::bad_lexical_cast&) {

}

return getAddress().toString() + ":" + portAsString;

}

if (!p->isValid) {

return boost::optional<NATPortMapping>();

}

NATPortMapping mapping(actualLocalPort, actualPublicPort, NATPortMapping::TCP);

int ret = UPNP_AddPortMapping(

p->urls.controlURL,

p->data.first.servicetype,

publicPort.c_str(),

localPort.c_str(),

bool MiniUPnPInterface::removePortForward(const NATPortMapping& mapping) {

if (!p->isValid) {

return false;

}

int ret = UPNP_DeletePortMapping(p->urls.controlURL, p->data.first.servicetype, publicPort.c_str(), mapping.getProtocol() == NATPortMapping::TCP ? "TCP" : "UDP", nullptr);

return ret == UPNPCOMMAND_SUCCESS;

}

bool MiniUPnPInterface::isAvailable() {

void StaticDomainNameResolver::addService(const std::string& service, const DomainNameServiceQuery::Result& result) {

services.push_back(std::make_pair(service, result));

}

void StaticDomainNameResolver::addXMPPClientService(const std::string& domain, const HostAddressPort& address) {

static int hostid = 0;

hostid++;

addService("_xmpp-client._tcp." + domain, ServiceQuery::Result(hostname, address.getPort(), 0, 0));

addAddress(hostname, address.getAddress());

}

rid++;

testling->write(createSafeByteArray("<blah/>"));

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size()); /* 0 was waiting for response, open and send on 1 */

CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* data */

c1 = connectionFactory->connections[1];

CPPUNIT_ASSERT_EQUAL(fullBody, lastBody());

CPPUNIT_ASSERT(c0->pending);

CPPUNIT_ASSERT(c1->pending);

rid++;

testling->restartStream();

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(2), boshDataWritten.size());

readResponse("<body></body>", c0);

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size());

std::string response = boshDataWritten[2];

size_t bodyPosition = response.find("\r\n\r\n");

CPPUNIT_ASSERT_EQUAL(fullBody, response.substr(bodyPosition+4));

}

"HTTP/1.1 200 OK\r\n"

"Content-Type: text/xml; charset=utf-8\r\n"

"Access-Control-Allow-Origin: *\r\n"

"Access-Control-Allow-Headers: Content-Type\r\n"

"Content-Length: "));

connection->onDataRead(data1);

connection->onDataRead(data2);

std::shared_ptr<SafeByteArray> data3 = std::make_shared<SafeByteArray>(createSafeByteArray("\r\n\r\n"));

connection->onDataRead(data3);

std::shared_ptr<SafeByteArray> data4 = std::make_shared<SafeByteArray>(createSafeByteArray(response));

connection->onDataRead(data4);

}

std::string fullRequestFor(const std::string& data) {

std::string body = data;

std::string result = "POST /" + path + " HTTP/1.1\r\n"

+ "Host: " + to + ":" + port + "\r\n"

+ "Content-Type: text/xml; charset=utf-8\r\n"

+ body;

return result;

}

private:

URL boshURL;

"HTTP/1.1 200 OK\r\n"

"Content-Type: text/xml; charset=utf-8\r\n"

"Access-Control-Allow-Origin: *\r\n"

"Access-Control-Allow-Headers: Content-Type\r\n"

"Content-Length: "));

connection->onDataRead(data1);

connection->onDataRead(data2);

std::shared_ptr<SafeByteArray> data3 = std::make_shared<SafeByteArray>(createSafeByteArray("\r\n\r\n"));

connection->onDataRead(data3);

std::shared_ptr<SafeByteArray> data4 = std::make_shared<SafeByteArray>(createSafeByteArray(response));

connection->onDataRead(data4);

}

XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

queryElement.setAttribute("sid", bytestreams->getStreamID());

for (const auto& streamHost : bytestreams->getStreamHosts()) {

std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost"));

streamHostElement->setAttribute("host", streamHost.host);

streamHostElement->setAttribute("jid", streamHost.jid.toString());

queryElement.addNode(streamHostElement);

}

if (bytestreams->getUsedStreamHost()) {

std::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost-used"));

streamHostElement->setAttribute("jid", *bytestreams->getUsedStreamHost());

std::string IBBSerializer::serializePayload(std::shared_ptr<IBB> ibb) const {

switch(ibb->getAction()) {

case IBB::Data: {

XMLElement ibbElement("data", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

if (ibb->getSequenceNumber() >= 0) {

}

ibbElement.addNode(std::make_shared<XMLTextNode>(Base64::encode(ibb->getData())));

return ibbElement.serialize();

}

case IBB::Open: {

XMLElement ibbElement("open", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

switch (ibb->getStanzaType()) {

case IBB::IQStanza: ibbElement.setAttribute("stanza", "iq"); break;

case IBB::MessageStanza: ibbElement.setAttribute("stanza", "message"); break;

}

assert(ibb->getBlockSize() > 0);

return ibbElement.serialize();

}

case IBB::Close: {

XMLElement ibbElement("close", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

return ibbElement.serialize();

fileElement.addNode(std::make_shared<XMLElement>("name", "", fileInfo->getName()));

}

if (fileInfo->getSupportsRangeRequests()) {

std::shared_ptr<XMLElement> range = std::make_shared<XMLElement>("range");

if (fileInfo->getRangeOffset() != 0) {

}

fileElement.addNode(range);

}

if (fileInfo->getSize() > 0) {

}

for (const auto& hashElement : fileInfo->getHashes()) {

std::shared_ptr<XMLElement> hash = std::make_shared<XMLElement>("hash", "urn:xmpp:hashes:1", Base64::encode(hashElement.second));

hash->setAttribute("algo", hashElement.first);

fileElement.addNode(hash);

JingleIBBTransportPayloadSerializer::JingleIBBTransportPayloadSerializer() {

}

std::string JingleIBBTransportPayloadSerializer::serializePayload(std::shared_ptr<JingleIBBTransportPayload> payload) const {

XMLElement payloadXML("transport", "urn:xmpp:jingle:transports:ibb:1");

if (payload->getBlockSize()) {

}

payloadXML.setAttribute("sid", payload->getSessionID());

return payloadXML.serialize();

}

for (const auto& candidate : payload->getCandidates()) {

std::shared_ptr<XMLElement> candidateXML = std::make_shared<XMLElement>("candidate");

candidateXML->setAttribute("cid", candidate.cid);

candidateXML->setAttribute("host", candidate.hostPort.getAddress().toString());

candidateXML->setAttribute("jid", candidate.jid.toString());

candidateXML->setAttribute("type", typeToString(candidate.type));

payloadXML.addNode(candidateXML);

}

if (payload->hasCandidateError()) {

payloadXML.addNode(std::make_shared<XMLElement>("candidate-error"));

namespace Swift {

class SWIFTEN_API LastSerializer : public GenericPayloadSerializer<Last> {

public:

LastSerializer() : GenericPayloadSerializer<Last>() {}

virtual std::string serializePayload(std::shared_ptr<Last> last) const {

}

};

}

std::string MUCPayloadSerializer::serializePayload(std::shared_ptr<MUCPayload> muc) const {

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

std::shared_ptr<XMLElement> historyElement(new XMLElement("history"));

bool history = false;

if (muc->getMaxChars() >= 0) {

history = true;

}

if (muc->getMaxStanzas() >= 0) {

history = true;

}

if (muc->getSeconds() >= 0) {

history = true;

}

if (muc->getSince() != boost::posix_time::not_a_date_time) {

std::string sinceString = std::string(boost::posix_time::to_iso_extended_string(muc->getSince()));

String::replaceAll(sinceString, ',', ".");

sinceString += "Z";

namespace Swift {

class SWIFTEN_API PrioritySerializer : public GenericPayloadSerializer<Priority> {

public:

PrioritySerializer() : GenericPayloadSerializer<Priority>() {}

virtual std::string serializePayload(std::shared_ptr<Priority> priority) const {

}

};

}

}

element.setAttribute("node", payload->getNode());

for (const auto& item : payload->getItems()) {

element.addNode(std::make_shared<XMLRawTextNode>(PubSubItemSerializer(serializers).serialize(item)));

}

if (payload->getMaximumItems()) {

}

if (payload->getSubscriptionID()) {

element.setAttribute("subid", *payload->getSubscriptionID());

}

return element.serialize();

}

return "";

}

XMLElement element("set", "http://jabber.org/protocol/rsm");

if (payload->getMaxItems()) {

}

if (payload->getCount()) {

}

if (payload->getIndex()) {

}

if (payload->getFirstID()) {

std::shared_ptr<XMLElement> firstElement = std::make_shared<XMLElement>("first", "", *payload->getFirstID());

if (payload->getFirstIDIndex()) {

}

element.addNode(firstElement);

}

if (payload->getLastID()) {

element.addNode(std::make_shared<XMLElement>("last", "", *payload->getLastID()));

public:

virtual std::string serializePayload(std::shared_ptr<S5BProxyRequest> s5bProxyRequest) const {

XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

if (s5bProxyRequest && s5bProxyRequest->getStreamHost()) {

std::shared_ptr<XMLElement> streamHost = std::make_shared<XMLElement>("streamhost");

streamHost->setAttribute("host", s5bProxyRequest->getStreamHost().get().host);

streamHost->setAttribute("jid", s5bProxyRequest->getStreamHost().get().jid.toString());

queryElement.addNode(streamHost);

} else if (s5bProxyRequest && s5bProxyRequest->getActivate()) {

queryElement.setAttribute("sid", s5bProxyRequest->getSID());

std::shared_ptr<XMLElement> activate = std::make_shared<XMLElement>("activate", "", s5bProxyRequest->getActivate().get().toString());

queryElement.addNode(activate);

fileElement.setAttribute("algo", fileInfo->getAlgo());

}

if (!fileInfo->getName().empty()) {

fileElement.setAttribute("name", fileInfo->getName());

}

if (fileInfo->getSize() != 0) {

}

if (!fileInfo->getDescription().empty()) {

std::shared_ptr<XMLElement> desc = std::make_shared<XMLElement>("desc", "", fileInfo->getDescription());

fileElement.addNode(desc);

}

if (fileInfo->getSupportsRangeRequests()) {

std::shared_ptr<XMLElement> range = std::make_shared<XMLElement>("range");

if (fileInfo->getRangeOffset() != 0) {

}

fileElement.addNode(range);

}

return fileElement.serialize();

}

if (streamInitiation->getFileInfo()) {

StreamInitiationFileInfo file = *streamInitiation->getFileInfo();

std::shared_ptr<XMLElement> fileElement(new XMLElement("file", "http://jabber.org/protocol/si/profile/file-transfer"));

fileElement->setAttribute("name", file.getName());

if (file.getSize() != 0) {

}

if (!file.getDescription().empty()) {

std::shared_ptr<XMLElement> descElement(new XMLElement("desc"));

descElement->addNode(std::make_shared<XMLTextNode>(file.getDescription()));

fileElement->addNode(descElement);

}

std::string UserTuneSerializer::serializePayload(std::shared_ptr<UserTune> payload) const {

if (!payload) {

return "";

}

XMLElement element("tune", "http://jabber.org/protocol/tune");

if (payload->getRating()) {

}

if (payload->getTitle()) {

element.addNode(std::make_shared<XMLElement>("title", "", *payload->getTitle()));

}

if (payload->getTrack()) {

element.addNode(std::make_shared<XMLElement>("track", "", *payload->getTrack()));

element.addNode(std::make_shared<XMLElement>("uri", "", *payload->getURI()));

}

if (payload->getSource()) {

element.addNode(std::make_shared<XMLElement>("source", "", *payload->getSource()));

}

if (payload->getLength()) {

}

return element.serialize();

}

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

void WhiteboardElementSerializingVisitor::visit(WhiteboardLineElement& line) {

element = std::make_shared<XMLElement>("line");

try {

element->setAttribute("id", line.getID());

element->setAttribute("stroke", line.getColor().toHex());

element->setAttribute("opacity", alphaToOpacity(line.getColor().getAlpha()));

} catch (boost::bad_lexical_cast&) {

}

}

void WhiteboardElementSerializingVisitor::visit(WhiteboardFreehandPathElement& path) {

element = std::make_shared<XMLElement>("path");

element->setAttribute("id", path.getID());

element->setAttribute("stroke", path.getColor().toHex());

try {

element->setAttribute("opacity", alphaToOpacity(path.getColor().getAlpha()));

std::string pathData;

if (path.getPoints().size() != 0) {

std::vector<std::pair<int, int> >::const_iterator it = path.getPoints().begin();

for (; it != path.getPoints().end(); ++it) {

}

}

element->setAttribute("d", pathData);

} catch (boost::bad_lexical_cast&) {

}

}

void WhiteboardElementSerializingVisitor::visit(WhiteboardRectElement& rect) {

element = std::make_shared<XMLElement>("rect");

try {

element->setAttribute("id", rect.getID());

element->setAttribute("stroke", rect.getPenColor().toHex());

element->setAttribute("fill", rect.getBrushColor().toHex());;

element->setAttribute("opacity", alphaToOpacity(rect.getPenColor().getAlpha()));

element->setAttribute("fill-opacity", alphaToOpacity(rect.getBrushColor().getAlpha()));

} catch (boost::bad_lexical_cast&) {

}

}

void WhiteboardElementSerializingVisitor::visit(WhiteboardPolygonElement& polygon) {

element = std::make_shared<XMLElement>("polygon");

try {

element->setAttribute("id", polygon.getID());

element->setAttribute("stroke", polygon.getPenColor().toHex());

element->setAttribute("fill", polygon.getBrushColor().toHex());;

element->setAttribute("opacity", alphaToOpacity(polygon.getPenColor().getAlpha()));

element->setAttribute("fill-opacity", alphaToOpacity(polygon.getBrushColor().getAlpha()));

std::string points;

std::vector<std::pair<int, int> >::const_iterator it = polygon.getPoints().begin();

for (; it != polygon.getPoints().end(); ++it) {

}

element->setAttribute("points", points);

} catch (boost::bad_lexical_cast&) {

}

}

void WhiteboardElementSerializingVisitor::visit(WhiteboardTextElement& text) {

element = std::make_shared<XMLElement>("text");

try {

element->setAttribute("id", text.getID());

element->setAttribute("fill", text.getColor().toHex());

element->setAttribute("opacity", alphaToOpacity(text.getColor().getAlpha()));

element->addNode(std::make_shared<XMLTextNode>(text.getText()));

} catch (boost::bad_lexical_cast&) {

}

}

void WhiteboardElementSerializingVisitor::visit(WhiteboardEllipseElement& ellipse) {

element = std::make_shared<XMLElement>("ellipse");

try {

element->setAttribute("id", ellipse.getID());

element->setAttribute("stroke", ellipse.getPenColor().toHex());

element->setAttribute("fill", ellipse.getBrushColor().toHex());;

element->setAttribute("opacity", alphaToOpacity(ellipse.getPenColor().getAlpha()));

element->setAttribute("fill-opacity", alphaToOpacity(ellipse.getBrushColor().getAlpha()));

} catch (boost::bad_lexical_cast&) {

}

}

std::string WhiteboardElementSerializingVisitor::alphaToOpacity(int alpha) const {

int opacity = 100*alpha/254;

if (opacity == 100) {

return "1";

} else {

}

}

std::string WhiteboardSerializer::serializePayload(std::shared_ptr<WhiteboardPayload> payload) const {

XMLElement element("wb", "http://swift.im/whiteboard");

if (payload->getType() == WhiteboardPayload::Data) {

WhiteboardElementSerializingVisitor visitor;

// payload->getElement()->accept(visitor);

WhiteboardInsertOperation::ref insertOp = std::dynamic_pointer_cast<WhiteboardInsertOperation>(payload->getOperation());

if (insertOp) {

try {

operationNode->setAttribute("type", "insert");

operationNode->setAttribute("id", insertOp->getID());

operationNode->setAttribute("parentid", insertOp->getParentID());

} catch (boost::bad_lexical_cast&) {

}

insertOp->getElement()->accept(visitor);

operationNode->addNode(visitor.getResult());

}

WhiteboardUpdateOperation::ref updateOp = std::dynamic_pointer_cast<WhiteboardUpdateOperation>(payload->getOperation());

if (updateOp) {

try {

operationNode->setAttribute("type", "update");

operationNode->setAttribute("id", updateOp->getID());

operationNode->setAttribute("parentid", updateOp->getParentID());

} catch (boost::bad_lexical_cast&) {

}

updateOp->getElement()->accept(visitor);

operationNode->addNode(visitor.getResult());

}

WhiteboardDeleteOperation::ref deleteOp = std::dynamic_pointer_cast<WhiteboardDeleteOperation>(payload->getOperation());

if (deleteOp) {

try {

operationNode->setAttribute("type", "delete");

operationNode->setAttribute("id", deleteOp->getID());

operationNode->setAttribute("parentid", deleteOp->getParentID());

operationNode->setAttribute("elementid", deleteOp->getElementID());

} catch (boost::bad_lexical_cast&) {

}

}

}

virtual SafeByteArray serialize(std::shared_ptr<ToplevelElement> element) const {

StanzaAck::ref stanzaAck(std::dynamic_pointer_cast<StanzaAck>(element));

assert(stanzaAck->isValid());

XMLElement result("a", "urn:xmpp:sm:2");

return createSafeByteArray(result.serialize());

}

};

}

SafeByteArray StreamResumeSerializer::serialize(std::shared_ptr<ToplevelElement> el) const {

std::shared_ptr<StreamResume> e(std::dynamic_pointer_cast<StreamResume>(el));

XMLElement element("resume", "urn:xmpp:sm:2");

element.setAttribute("previd", e->getResumeID());

if (e->getHandledStanzasCount()) {

}

return createSafeByteArray(element.serialize());

}

SafeByteArray StreamResumedSerializer::serialize(std::shared_ptr<ToplevelElement> el) const {

std::shared_ptr<StreamResumed> e(std::dynamic_pointer_cast<StreamResumed>(el));

XMLElement element("resumed", "urn:xmpp:sm:2");

element.setAttribute("previd", e->getResumeID());

if (e->getHandledStanzasCount()) {

}

return createSafeByteArray(element.serialize());

}