handleJIDsAdded(jids);

firstMultiJIDPage_->jid_->clear();

}

void QtUserSearchWindow::show() {

clear();

QWidget::show();

}

void QtUserSearchWindow::addSavedServices(const std::vector<JID>& services) {

if (type_ == AddContact) {

firstPage_->service_->clear();

foreach (JID jid, services) {

firstPage_->service_->addItem(P2QSTRING(jid.toString()));

}

firstPage_->service_->clearEditText();

} else {

firstMultiJIDPage_->service_->clear();

foreach (JID jid, services) {

firstMultiJIDPage_->service_->addItem(P2QSTRING(jid.toString()));

}

firstMultiJIDPage_->service_->clearEditText();

}

}

void QtUserSearchWindow::setSearchFields(boost::shared_ptr<SearchPayload> fields) {

fieldsPage_->fetchingThrobber_->hide();

fieldsPage_->fetchingThrobber_->movie()->stop();

fieldsPage_->fetchingLabel_->hide();

fieldsPage_->instructionsLabel_->setText(fields->getInstructions() ? P2QSTRING(fields->getInstructions().get()) : "Enter search terms");

if (fields->getForm()) {

fieldsPage_->setFormWidget(new QtFormWidget(fields->getForm(), fieldsPage_));

} else {

fieldsPage_->setFormWidget(NULL);

QWidget* legacySearchWidgets[8] = {fieldsPage_->nickInputLabel_, fieldsPage_->nickInput_, fieldsPage_->firstInputLabel_, fieldsPage_->firstInput_, fieldsPage_->lastInputLabel_, fieldsPage_->lastInput_, fieldsPage_->emailInputLabel_, fieldsPage_->emailInput_};

for (int i = 0; i < 8; i++) {

legacySearchWidgets[i]->setVisible(enabled[i]);

legacySearchWidgets[i]->setEnabled(enabled[i]);

}

}

fieldsPage_->emitCompletenessCheck();

}

void QtUserSearchWindow::setNameSuggestions(const std::vector<std::string>& suggestions) {

if (detailsPage_) {

detailsPage_->setNameSuggestions(suggestions);

}

}

void QtUserSearchWindow::prepopulateJIDAndName(const JID& jid, const std::string& name) {

firstPage_->jid_->setText(P2QSTRING(jid.toBare().toString()));

detailsPage_->setJID(jid);

lastPage_ = 1;

restart();

next();

detailsPage_->setName(name);

}

void QtUserSearchWindow::setContactSuggestions(const std::vector<Contact::ref>& suggestions) {

if (type_ == AddContact) {

firstPage_->jid_->setSuggestions(suggestions);

} else {

firstMultiJIDPage_->jid_->setSuggestions(suggestions);

}

}

void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {

foreach(JID jid, jids) {

addSearchedJIDToList(jid);

#include <Swiften/Avatars/CombinedAvatarProvider.h>

#include <algorithm>

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

namespace Swift {

boost::optional<std::string> CombinedAvatarProvider::getAvatarHash(const JID& jid) const {

return getCombinedAvatarAndCache(jid);

}

void CombinedAvatarProvider::addProvider(AvatarProvider* provider) {

provider->onAvatarChanged.connect(boost::bind(&CombinedAvatarProvider::handleAvatarChanged, this, _1));

providers.push_back(provider);

}

void CombinedAvatarProvider::removeProvider(AvatarProvider* provider) {

std::vector<AvatarProvider*>::iterator i = std::remove(providers.begin(), providers.end(), provider);

for(std::vector<AvatarProvider*>::iterator j = i; j < providers.end(); ++j) {

provider->onAvatarChanged.disconnect(boost::bind(&CombinedAvatarProvider::handleAvatarChanged, this, _1));

}

providers.erase(i, providers.end());

}

void CombinedAvatarProvider::handleAvatarChanged(const JID& jid) {

std::string oldHash;

std::map<JID, std::string>::const_iterator i = avatars.find(jid);

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

oldHash = i->second;

}

boost::optional<std::string> newHash = getCombinedAvatarAndCache(jid);

if (newHash != oldHash) {

onAvatarChanged(jid);

}

}

boost::optional<std::string> CombinedAvatarProvider::getCombinedAvatarAndCache(const JID& jid) const {

SWIFT_LOG(debug) << "JID: " << jid << std::endl;

boost::optional<std::string> hash;

for (size_t i = 0; i < providers.size() && !hash; ++i) {

hash = providers[i]->getAvatarHash(jid);

}

if (hash) {

avatars[jid] = *hash;

} else {

avatars[jid] = "";

}

return hash;

}

}

#include <iostream>

#include <boost/lexical_cast.hpp>

#include <Swiften/EventLoop/SimpleEventLoop.h>

#include <Swiften/Network/PlatformNATTraversalWorker.h>

#include <Swiften/Network/NATTraversalGetPublicIPRequest.h>

#include <Swiften/Network/NATTraversalForwardPortRequest.h>

#include <Swiften/Network/NATTraversalRemovePortForwardingRequest.h>

#include <Swiften/Network/PlatformNetworkEnvironment.h>

using namespace Swift;

static SimpleEventLoop eventLoop;

static void handleGetPublicIPRequestResponse(const boost::optional<HostAddress>& result) {

if (result) {

std::cerr << "Result: " << result->toString() << std::endl;;

}

else {

std::cerr << "No result" << std::endl;

}

eventLoop.stop();

}

static void handleGetForwardPortRequestResponse(const boost::optional<NATPortMapping>& result) {

if (result) {

std::cerr << "Result: " << result->getPublicPort() << " -> " << result->getLocalPort() << std::endl;;

}

else {

std::cerr << "No result" << std::endl;

}

eventLoop.stop();

}

std::cerr << "Result: OK" << std::endl;

}

else {

std::cerr << "Result: ERROR" << std::endl;

}

eventLoop.stop();

}

int main(int argc, char* argv[]) {

if (argc < 2) {

std::cerr << "Invalid parameters" << std::endl;

return -1;

}

PlatformNATTraversalWorker natTraverser(&eventLoop);

if (std::string(argv[1]) == "get-public-ip") {

boost::shared_ptr<NATTraversalGetPublicIPRequest> query = natTraverser.createGetPublicIPRequest();

query->onResult.connect(boost::bind(&handleGetPublicIPRequestResponse, _1));

query->start();

eventLoop.run();

}

else if (std::string(argv[1]) == "add-port-forward") {

if (argc < 4) {

std::cerr << "Invalid parameters" << std::endl;

}

boost::shared_ptr<NATTraversalForwardPortRequest> query = natTraverser.createForwardPortRequest(boost::lexical_cast<int>(argv[2]), boost::lexical_cast<int>(argv[3]));

query->onResult.connect(boost::bind(&handleGetForwardPortRequestResponse, _1));

query->start();

eventLoop.run();

}

else if (std::string(argv[1]) == "remove-port-forward") {

if (argc < 4) {

std::cerr << "Invalid parameters" << std::endl;

}

boost::shared_ptr<NATTraversalRemovePortForwardingRequest> query = natTraverser.createRemovePortForwardingRequest(boost::lexical_cast<int>(argv[2]), boost::lexical_cast<int>(argv[3]));

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/bind.hpp>

#include <boost/thread.hpp>

#include <iostream>

#include <Swiften/Client/Client.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Network/BoostNetworkFactories.h>

#include <Swiften/EventLoop/EventLoop.h>

#include <Swiften/EventLoop/SimpleEventLoop.h>

#include <Swiften/Roster/GetRosterRequest.h>

#include <Swiften/Client/ClientXMLTracer.h>

using namespace Swift;

static SimpleEventLoop eventLoop;

static BoostNetworkFactories networkFactories(&eventLoop);

static Client* client = 0;

static bool rosterReceived = false;

enum TestStage {

FirstConnect,

Reconnect

};

static TestStage stage;

static ClientOptions options;

static void handleDisconnected(boost::optional<ClientError> e) {

if (stage == FirstConnect) {

stage = Reconnect;

client->connect(options);

}

else {

eventLoop.stop();

}

}

static void handleRosterReceived(boost::shared_ptr<Payload>) {

rosterReceived = true;

std::cout << "Disconnecting" << std::endl;

client->disconnect();

}

static void handleConnected() {

std::cout << "Connected" << std::endl;

rosterReceived = false;

GetRosterRequest::ref rosterRequest = GetRosterRequest::create(client->getIQRouter());

rosterRequest->onResponse.connect(boost::bind(&handleRosterReceived, _1));

rosterRequest->send();

}

int main(int, char**) {

char* jid = getenv("SWIFT_CLIENTTEST_JID");

if (!jid) {

std::cerr << "Please set the SWIFT_CLIENTTEST_JID environment variable" << std::endl;

return -1;

}

char* pass = getenv("SWIFT_CLIENTTEST_PASS");

if (!pass) {

std::cerr << "Please set the SWIFT_CLIENTTEST_PASS environment variable" << std::endl;

return -1;

}

/*

* Copyright (c) 2011-2014 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/StreamResumeSerializer.h>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/StreamResume.h>

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

using namespace Swift;

StreamResumeSerializer::StreamResumeSerializer() : GenericElementSerializer<StreamResume>() {

}

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

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

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

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

if (e->getHandledStanzasCount()) {

}

return createSafeByteArray(element.serialize());

}

/*

* Copyright (c) 2011-2014 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/StreamResumedSerializer.h>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/StreamResumed.h>

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

using namespace Swift;

StreamResumedSerializer::StreamResumedSerializer() : GenericElementSerializer<StreamResumed>() {

}

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

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

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

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

if (e->getHandledStanzasCount()) {

}

return createSafeByteArray(element.serialize());

}