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

} else {

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

if (!certificateFile_.isEmpty()) {

client_->setCertificate(certificateFile_);

}

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

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

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

}

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;

case ClientError::ConnectionReadError: message = "Error while receiving server data"; break;

case ClientError::ConnectionWriteError: message = "Error while sending data to the server"; break;

case ClientError::XMLError: message = "Error parsing server data"; break;

case ClientError::AuthenticationFailedError: message = "Login/password invalid"; break;

case ClientError::CompressionFailedError: message = "Error while compressing stream"; break;

case ClientError::ServerVerificationFailedError: message = "Server verification failed"; break;

case ClientError::NoSupportedAuthMechanismsError: message = "Authentication mechanisms not supported"; break;

case ClientError::UnexpectedElementError: message = "Unexpected response"; break;

case ClientError::ResourceBindError: message = "Error binding resource"; break;

case ClientError::SessionStartError: message = "Error starting session"; break;

case ClientError::TLSError: message = "Encryption error"; break;

case ClientError::ClientCertificateLoadError: message = "Error loading certificate (Invalid password?)"; break;

case ClientError::ClientCertificateError: message = "Certificate not authorized"; break;

}

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

signOut();

loginWindow_->setMessage(message);

}

logout();

if (rosterController_) {

//reconnectAfterError();

}

}

void MainController::handleCancelLoginRequest() {

signOut();

}

void MainController::signOut() {

logout();

loginWindow_->loggedOut();

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

#include "QtSwift.h"

#include "QtLoginWindowFactory.h"

#include "QtChatWindowFactory.h"

#include "QtLoginWindow.h"

#include "QtChatTabs.h"

#include "QtMainWindowFactory.h"

#include "Roster/QtTreeWidgetFactory.h"

#include "QtSystemTray.h"

#include "QtSoundPlayer.h"

#include "QtXMLConsoleWidgetFactory.h"

#include <boost/bind.hpp>

#include <QSplitter>

#include "Swiften/Application/Application.h"

#include "Swiften/Application/Platform/PlatformApplication.h"

#include "Swiften/Base/String.h"

#include "Swiften/Base/Platform.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Client/Client.h"

#include "Swift/Controllers/ChatController.h"

#include "Swift/Controllers/MainController.h"

#include "Swift/QtUI/BuildVersion.h"

#include "SwifTools/AutoUpdater/AutoUpdater.h"

#include "SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h"

namespace Swift{

#if defined(SWIFTEN_PLATFORM_MACOSX)

#else

#define SWIFT_APPCAST_URL ""

#endif

QtSwift::QtSwift(bool netbookMode) : autoUpdater_(NULL) {

if (netbookMode) {

splitter_ = new QSplitter();

} else {

splitter_ = NULL;

}

QCoreApplication::setApplicationName("Swift");

QCoreApplication::setOrganizationName("Swift");

QCoreApplication::setOrganizationDomain("swift.im");

QCoreApplication::setApplicationVersion(buildVersion);

tabs_ = new QtChatTabs();

settings_ = new QtSettingsProvider();

application_ = new PlatformApplication("Swift");

treeWidgetFactory_ = new QtTreeWidgetFactory();

systemTray_ = new QtSystemTray();

loginWindowFactory_ = new QtLoginWindowFactory(splitter_, systemTray_, settings_);

chatWindowFactory_ = new QtChatWindowFactory(treeWidgetFactory_, splitter_, settings_, tabs_);

rosterWindowFactory_ = new QtMainWindowFactory(treeWidgetFactory_);

xmlConsoleWidgetFactory_ = new QtXMLConsoleWidgetFactory(tabs_);

soundPlayer_ = new QtSoundPlayer();

if (splitter_) {

splitter_->show();

}

mainController_ = new MainController(chatWindowFactory_, rosterWindowFactory_, loginWindowFactory_, treeWidgetFactory_, settings_, application_, systemTray_, soundPlayer_, xmlConsoleWidgetFactory_);

PlatformAutoUpdaterFactory autoUpdaterFactory;

if (autoUpdaterFactory.isSupported()) {

autoUpdater_ = autoUpdaterFactory.createAutoUpdater(SWIFT_APPCAST_URL);

autoUpdater_->checkForUpdates();

}

}

QtSwift::~QtSwift() {

delete autoUpdater_;

delete chatWindowFactory_;

delete rosterWindowFactory_;

delete loginWindowFactory_;

delete treeWidgetFactory_;

delete mainController_;

delete settings_;

delete application_;

delete systemTray_;