discoResponder_ = new DiscoInfoResponder(client_);

discoResponder_->setDiscoInfo(discoInfo);

discoResponder_->setDiscoInfo(capsInfo_->getNode() + "#" + capsInfo_->getVersion(), discoInfo);

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());

}

boost::shared_ptr<GetDiscoInfoRequest> discoInfoRequest(new GetDiscoInfoRequest(JID(), client_));

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

discoInfoRequest->send();

boost::shared_ptr<GetVCardRequest> vCardRequest(new GetVCardRequest(JID(), client_));

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

vCardRequest->send();

//Send presence last to catch all the incoming presences.

boost::shared_ptr<Presence> initialPresence;

if (queuedPresence_.get() != NULL) {

initialPresence = queuedPresence_;

} else {

initialPresence = boost::shared_ptr<Presence>(new Presence());

}

initialPresence->addPayload(capsInfo_);

setManagersEnabled(true);

sendPresence(initialPresence);

}

void MainController::handleEventQueueLengthChange(int count) {

application_->getApplicationMessageDisplay()->setMessage(count == 0 ? "" : boost::lexical_cast<std::string>(count).c_str());

}

void MainController::reconnectAfterError() {

performLoginFromCachedCredentials();

sendPresence(queuedPresence_);

}

void MainController::handleChangeStatusRequest(StatusShow::Type show, const String &statusText) {

boost::shared_ptr<Presence> presence(new Presence());

if (show == StatusShow::None) {

// FIXME: This is wrong. None doesn't mean unavailable

presence->setType(Presence::Unavailable);

}

else {

presence->setShow(show);

}

presence->setStatus(statusText);

if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {

performLoginFromCachedCredentials();

queuedPresence_ = presence;

sendPresence(presence);

}

}

void MainController::sendPresence(boost::shared_ptr<Presence> presence) {

if (!vCardPhotoHash_.isEmpty()) {

presence->addPayload(boost::shared_ptr<VCardUpdate>(new VCardUpdate(vCardPhotoHash_)));

}

presence->addPayload(capsInfo_);

presenceSender_->sendPresence(presence);

if (presence->getType() == Presence::Unavailable) {

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!client_ || !client_->isAvailable()) {

return;

}

if (idle) {

preIdlePresence_ = lastSentPresence_;

boost::shared_ptr<Presence> presence(new Presence());

presence->setShow(StatusShow::Away);

presence->setStatus("Auto-away");

sendPresence(presence);

}

else {

if (client_) {

sendPresence(preIdlePresence_);

queuedPresence_ = preIdlePresence_;

}

}

}

void MainController::handleIncomingPresence(boost::shared_ptr<Presence> presence) {

//FIXME: subscribe, subscribed

rosterController_->handleIncomingPresence(presence);

}

void MainController::handleLoginRequest(const String &username, const String &password, const String& certificateFile, bool remember) {

loginWindow_->setMessage("");

ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(username, settings_);

profileSettings->storeString("jid", username);

profileSettings->storeString("certificate", certificateFile);

profileSettings->storeString("pass", remember ? password : "");

settings_->storeString("lastLoginJID", username);

loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));

delete profileSettings;

jid_ = JID(username);

password_ = password;

certificateFile_ = certificateFile;

performLoginFromCachedCredentials();

}

void MainController::performLoginFromCachedCredentials() {

if (!client_) {

client_ = new Swift::Client(jid_, password_);

presenceSender_ = new PresenceSender(client_);

client_->onDataRead.connect(boost::bind(

&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

client_->onDataWritten.connect(boost::bind(

&XMLConsoleController::handleDataWritten, xmlConsoleController_, _1));

if (!certificateFile_.isEmpty()) {

client_->setCertificate(certificateFile_);

}

client_->onError.connect(boost::bind(&MainController::handleError, this, _1));

client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));

}

client_->connect();

}

void MainController::handleError(const ClientError& error) {

String message;

switch(error.getType()) {

case ClientError::UnknownError: message = "Unknown Error"; break;

case ClientError::DomainNameResolveError: message = "Unable to find server"; break;

case ClientError::ConnectionError: message = "Error connecting to server"; break;

namespace Swift {

class Presence : public Stanza

{

public:

enum Type { Available, Error, Probe, Subscribe, Subscribed, Unavailable, Unsubscribe, Unsubscribed };

Presence() : type_(Available) /*, showType_(Online)*/ {}

Presence(const String& status) : type_(Available) {

setStatus(status);

}

Type getType() const { return type_; }

void setType(Type type) { type_ = type; }

StatusShow::Type getShow() const {

boost::shared_ptr<StatusShow> show(getPayload<StatusShow>());

if (show) {

return show->getType();

}

return type_ == Available ? StatusShow::Online : StatusShow::None;

}

void setShow(const StatusShow::Type &show) {

updatePayload(boost::shared_ptr<StatusShow>(new StatusShow(show)));

}

String getStatus() const {

boost::shared_ptr<Status> status(getPayload<Status>());

if (status) {

return status->getText();

}

return "";

}

void setStatus(const String& status) {

updatePayload(boost::shared_ptr<Status>(new Status(status)));

}

int getPriority() const {

boost::shared_ptr<Priority> priority(getPayload<Priority>());

return (priority ? priority->getPriority() : 0);

}

void setPriority(int priority) {

updatePayload(boost::shared_ptr<Priority>(new Priority(priority)));

}

private:

Presence::Type type_;

};

}