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

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

if (show == StatusShow::None) {

// Note: this is misleading, None doesn't mean unavailable on the wire.

presence->setType(Presence::Unavailable);

resetPendingReconnects();

myStatusLooksOnline_ = false;

offlineRequested_ = true;

}

else {

offlineRequested_ = false;

presence->setShow(show);

}

presence->setStatus(statusText);

statusTracker_->setRequestedPresence(presence);

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

profileSettings_->storeInt("lastShow", presence->getShow());

profileSettings_->storeString("lastStatus", presence->getStatus());

}

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

performLoginFromCachedCredentials();

} else {

sendPresence(presence);

}

}

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

rosterController_->getWindow()->setMyStatusType(presence->getShow());

rosterController_->getWindow()->setMyStatusText(presence->getStatus());

systemTrayController_->setMyStatusType(presence->getShow());

notifier_->setTemporarilyDisabled(presence->getShow() == StatusShow::DND);

// Add information and send

if (!vCardPhotoHash_.empty()) {

}

client_->getPresenceSender()->sendPresence(presence);

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

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!statusTracker_) {

//Haven't logged in yet.

return;

}

if (settings_->getSetting(SettingConstants::IDLE_GOES_OFFLINE)) {

if (idle) {

logout();

}

}

else {

if (idle) {

if (statusTracker_->goAutoAway()) {

if (client_ && client_->isAvailable()) {

sendPresence(statusTracker_->getNextPresence());

}

}

} else {

if (statusTracker_->goAutoUnAway()) {

if (client_ && client_->isAvailable()) {

sendPresence(statusTracker_->getNextPresence());

}

}

}

}

}

case ClientError::InvalidServerIdentityError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate does not match the host identity"); break;

}

bool forceReconnectAfterCertificateTrust = false;

if (!certificateErrorMessage.empty()) {

Certificate::ref certificate = certificateTrustChecker_->getLastCertificate();

if (loginWindow_->askUserToTrustCertificatePermanently(certificateErrorMessage, certificate)) {

certificateStorage_->addCertificate(certificate);

forceReconnectAfterCertificateTrust = true;

}

else {

message = QT_TRANSLATE_NOOP("", "Certificate error");

}

}

if (forceReconnectAfterCertificateTrust) {

performLoginFromCachedCredentials();

}

else if (!rosterController_) { //hasn't been logged in yet

signOut();

loginWindow_->setMessage(message);

loginWindow_->setIsLoggingIn(false);

} else {

logout();

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

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_) {

message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % boost::lexical_cast<std::string>(timeBeforeNextReconnect_));

lastDisconnectError_->conclude();

} else {

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

}

eventController_->handleIncomingEvent(lastDisconnectError_);

}

}

}

else if (!rosterController_) { //hasn't been logged in yet

loginWindow_->setIsLoggingIn(false);

}

}

void MainController::setReconnectTimer() {

if (timeBeforeNextReconnect_ < 0) {

timeBeforeNextReconnect_ = 1;

} else {

timeBeforeNextReconnect_ = timeBeforeNextReconnect_ >= 150 ? 300 : timeBeforeNextReconnect_ * 2; // Randomly selected by roll of a die, as required by 3920bis

}

if (reconnectTimer_) {

reconnectTimer_->stop();

}

reconnectTimer_ = networkFactories_->getTimerFactory()->createTimer(timeBeforeNextReconnect_ * 1000);

reconnectTimer_->onTick.connect(boost::bind(&MainController::reconnectAfterError, this));

reconnectTimer_->start();

}

void MainController::handleCancelLoginRequest() {

signOut();

}

void MainController::signOut() {

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

purgeCachedCredentials();

}

eventController_->clear();

logout();

loginWindow_->loggedOut();

resetClient();

if (rosterController_) {

rosterController_->setEnabled(false);

}

if (profileController_) {

profileController_->setAvailable(false);

}

if (contactEditController_) {

contactEditController_->setAvailable(false);

}

}

void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, ErrorPayload::ref error) {

if (!error) {

chatsManager_->setServerDiscoInfo(info);

adHocManager_->setServerDiscoInfo(info);

}

}

void MainController::handleVCardReceived(const JID& jid, VCard::ref vCard) {

if (!jid.equals(jid_, JID::WithoutResource) || !vCard || vCard->getPhoto().empty()) {

return;

}

std::string hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

if (hash != vCardPhotoHash_) {

vCardPhotoHash_ = hash;

if (client_ && client_->isAvailable()) {

sendPresence(statusTracker_->getNextPresence());

}

}

}

void MainController::handleNotificationClicked(const JID& jid) {

assert(chatsManager_);

if (clientInitialized_) {

if (client_->getMUCRegistry()->isMUC(jid)) {

}

else {

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(jid)));

}

}

}

void MainController::handleQuitRequest() {

if (client_ && client_->isActive()) {

quitRequested_ = true;

client_->disconnect();

}

else {

resetClient();

loginWindow_->quit();

}

}

}