client_->getDiscoManager()->setCapsNode(CLIENT_NODE);

client_->getDiscoManager()->setDiscoInfo(discoInfo);

userSearchControllerChat_ = new UserSearchController(UserSearchController::StartChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

userSearchControllerAdd_ = new UserSearchController(UserSearchController::AddContact, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithoutRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

adHocManager_ = new AdHocManager(JID(boundJID_.getDomain()), uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());

chatsManager_->onImpromptuMUCServiceDiscovered.connect(boost::bind(&UserSearchController::setCanInitiateImpromptuMUC, userSearchControllerChat_, _1));

}

loginWindow_->setIsLoggingIn(false);

client_->requestRoster();

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(boundJID_.getDomain()), client_->getIQRouter());

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

client_->getVCardManager()->requestOwnVCard();

rosterController_->setJID(boundJID_);

rosterController_->setEnabled(true);

rosterController_->getWindow()->setStreamEncryptionStatus(client_->isStreamEncrypted());

profileController_->setAvailable(true);

contactEditController_->setAvailable(true);

/* Send presence later to catch all the incoming presences. */

SERIALIZE_STRING(manualProxyHostname);

SERIALIZE_INT(manualProxyPort);

SERIALIZE_URL(boshURL);

SERIALIZE_URL(boshHTTPConnectProxyURL);

SERIALIZE_SAFE_STRING(boshHTTPConnectProxyAuthID);

SERIALIZE_SAFE_STRING(boshHTTPConnectProxyAuthPassword);

return result;

}

#define PARSE_INT_RAW(defaultValue) CHECK_PARSE_LENGTH intVal = defaultValue; try {intVal = boost::lexical_cast<int>(segments[i]);} catch(const boost::bad_lexical_cast&) {};i++;

#define PARSE_STRING_RAW CHECK_PARSE_LENGTH stringVal = byteArrayToString(Base64::decode(segments[i]));i++;

#define PARSE_BOOL(option, defaultValue) PARSE_INT_RAW(defaultValue); result.option = (intVal == 1);

#define PARSE_INT(option, defaultValue) PARSE_INT_RAW(defaultValue); result.option = intVal;

#define PARSE_STRING(option) PARSE_STRING_RAW; result.option = stringVal;

PARSE_STRING(manualProxyHostname);

PARSE_INT(manualProxyPort, -1);

PARSE_URL(boshURL);

PARSE_URL(boshHTTPConnectProxyURL);

PARSE_SAFE_STRING(boshHTTPConnectProxyAuthID);

PARSE_SAFE_STRING(boshHTTPConnectProxyAuthPassword);

return result;

}

}

<property name="text">

<string>Allow sending password over insecure connection</string>

</property>

</widget>

</item>

<item>

<spacer name="verticalSpacer_2">

<property name="orientation">

<enum>Qt::Vertical</enum>

</property>

<property name="sizeType">

<enum>QSizePolicy::Fixed</enum>

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include "Swift/QtUI/QtConnectionSettingsWindow.h"

isDefault &= options.useAcks == defaults.useAcks;

isDefault &= options.manualHostname == defaults.manualHostname;

isDefault &= options.manualPort == defaults.manualPort;

isDefault &= options.proxyType == defaults.proxyType;

isDefault &= options.manualProxyHostname == defaults.manualProxyHostname;

isDefault &= options.manualProxyPort == defaults.manualProxyPort;

if (isDefault) {

ui.connectionMethod->setCurrentIndex(0);

}

else {

ui.connectionMethod->setCurrentIndex(1);

ui.manual_useTLS->setCurrentIndex(options.useTLS);

ui.manual_proxyType->setCurrentIndex(options.proxyType);

if (!options.manualProxyHostname.empty()) {

ui.manual_manualProxy->setChecked(true);

ui.manual_manualProxyHost->setText(P2QSTRING(options.manualProxyHostname));

ui.manual_manualProxyPort->setText(P2QSTRING(boost::lexical_cast<std::string>(options.manualProxyPort)));

}

}

} else {

ui.connectionMethod->setCurrentIndex(2);

ui.bosh_uri->setText(P2QSTRING(options.boshURL.toString()));

if (!options.boshHTTPConnectProxyURL.isEmpty()) {

ui.bosh_manualProxy->setChecked(true);

ui.bosh_manualProxyHost->setText(P2QSTRING(options.boshHTTPConnectProxyURL.getHost()));

if (options.boshHTTPConnectProxyURL.getPort()) {

ui.bosh_manualProxyPort->setText(P2QSTRING(boost::lexical_cast<std::string>(*options.boshHTTPConnectProxyURL.getPort())));

}

}

}

}

void QtConnectionSettingsWindow::handleProxyTypeChanged(int index) {

bool proxySettingsVisible = index != NoProxy && index != SystemProxy;

ui.manual_manualProxy->setVisible(proxySettingsVisible);

ui.manual_manualProxyHostLabel->setVisible(proxySettingsVisible);

/* Not automatic */

if (ui.connectionMethod->currentIndex() == 1) {

/* Manual */

options.useTLS = static_cast<ClientOptions::UseTLS>(ui.manual_useTLS->currentIndex());

options.useStreamCompression = ui.manual_allowCompression->isChecked();

options.allowPLAINWithoutTLS = ui.manual_allowPLAINWithoutTLS->isChecked();

if (ui.manual_manualHost->isChecked()) {

options.manualHostname = Q2PSTRING(ui.manual_manualHostName->text());

try {

options.manualPort = boost::lexical_cast<int>(Q2PSTRING(ui.manual_manualHostPort->text()));

} catch (const boost::bad_lexical_cast&) {

options.manualPort = -1;