* See the COPYING file for more information.

*/

#include <cstdlib>

#include <memory>

static const std::string CLIENT_NODE = "http://swift.im";

EventLoop* eventLoop,

NetworkFactories* networkFactories,

UIFactory* uiFactories,

notifier_ = new TogglableNotifier(notifier);

notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

eventController_ = new EventController();

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

idleDetector_->setIdleTimeSeconds(settings->getSetting(SettingConstants::IDLE_TIMEOUT));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);

fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

}

purgeCachedCredentials();

//setManagersOffline();

delete uiEventStream_;

}

safeClear(password_);

}

purgeCachedCredentials();

resetCurrentError();

resetPendingReconnects();

clientInitialized_ = false;

}

if (settingPath == SettingConstants::SHOW_NOTIFICATIONS.getKey()) {

notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

}

}

timeBeforeNextReconnect_ = -1;

if (reconnectTimer_) {

reconnectTimer_->stop();

resetCurrentError();

}

if (lastDisconnectError_) {

lastDisconnectError_->conclude();

lastDisconnectError_ = std::shared_ptr<ErrorEvent>();

}

}

boundJID_ = client_->getJID();

resetCurrentError();

resetPendingReconnects();

fileTransferListController_->setFileTransferOverview(ftOverview_);

chattables_ = std::make_unique<Chattables>();

rosterController_ = new RosterController(boundJID_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), client_->getClientBlockListManager(), client_->getVCardManager(), *chattables_);

blockListController_ = new BlockListController(client_->getClientBlockListManager(), uiEventStream_, uiFactory_, eventController_);

client_->requestRoster();

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

discoInfoRequest->send();

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

adHocManager_->setOnline(true);

}

dock_->setNumberOfPendingMessages(count);

}

if (reconnectTimer_) {

reconnectTimer_->stop();

}

performLoginFromCachedCredentials();

}

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

if (show == StatusShow::None) {

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

}

}

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

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

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

}

}

if (!statusTracker_) {

//Haven't logged in yet.

return;

}

}

std::vector<Certificate::ref> chain = client_->getStanzaChannel()->getPeerCertificateChain();

rosterController_->getWindow()->openCertificateDialog(chain);

}

jid_ = JID(username);

if (options.singleSignOn && (!jid_.isValid() || !jid_.getNode().empty())) {

loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'wonderland.lit'"));

}

}

settings_->removeProfile(username);

loginWindow_->removeAvailableAccount(username);

}

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS) && password_.empty()) {

/* Then we can't try to login again. */

return;

client_->setCertificateTrustChecker(certificateTrustChecker_);

client_->onDataRead.connect(boost::bind(&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

client_->onDataWritten.connect(boost::bind(&XMLConsoleController::handleDataWritten, xmlConsoleController_, _1));

client_->setSoftwareVersion(CLIENT_NAME, buildVersion);

presenceNotifier_ = new PresenceNotifier(client_->getStanzaChannel(), notifier_, client_->getMUCRegistry(), client_->getAvatarManager(), client_->getNickResolver(), client_->getPresenceOracle(), networkFactories_->getTimerFactory());

eventNotifier_ = new EventNotifier(eventController_, notifier_, client_->getAvatarManager(), client_->getNickResolver());

if (certificate_) {

client_->setCertificate(certificate_);

}

client_->connect(clientOptions);

}

if (rosterController_) {

rosterController_->getWindow()->setStreamEncryptionStatus(false);

}

}

}

if (timeBeforeNextReconnect_ < 0) {

timeBeforeNextReconnect_ = 1;

} else {

reconnectTimer_->stop();

}

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

reconnectTimer_->start();

}

signOut();

}

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

purgeCachedCredentials();

}

resetClient();

}

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

purgeCachedCredentials();

}

setManagersOffline();

}

if (chatsManager_) {

chatsManager_->setOnline(false);

}

}

}

if (!error) {

chatsManager_->setServerDiscoInfo(info);

adHocManager_->setServerDiscoInfo(info);

}

}

auto enableCarbonsRequest = EnableCarbonsRequest::create(client_->getIQRouter());

enableCarbonsRequestHandlerConnection_ = enableCarbonsRequest->onResponse.connect([&](Payload::ref /*payload*/, ErrorPayload::ref error) {

if (error) {

enableCarbonsRequest->send();

}

if (!jid.equals(jid_, JID::WithoutResource) || !vCard) {

return;

}

}

}

assert(chatsManager_);

if (clientInitialized_) {

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

}

}

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

quitRequested_ = true;

client_->disconnect();

#define SERIALIZE_SAFE_STRING(option) result += safeByteArrayToString(Base64::encode(options.option)); result += ",";

#define SERIALIZE_URL(option) SERIALIZE_STRING(option.toString())

std::string result;

SERIALIZE_BOOL(useStreamCompression);

switch (options.useTLS) {

class ContactSuggester;

class ContactsFromXMPPRoster;

public:

EventLoop* eventLoop,

NetworkFactories* networkFactories,

UIFactory* uiFactories,

IdleDetector* idleDetector,

const std::map<std::string, std::string>& emoticons,

bool useDelayForLatency);

private:

void resetClient();

"Highlighting/Highlighter.cpp",

"HistoryController.cpp",

"HistoryViewController.cpp",

"PresenceNotifier.cpp",

"PreviousStatusStore.cpp",

"ProfileController.cpp",

#include <Swift/Controllers/ApplicationInfo.h>

#include <Swift/Controllers/BuildVersion.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

#include <Swift/Controllers/Settings/XMLSettingsProvider.h>

for (auto* factory : uiFactories_) {

delete factory;

}

delete controller;

}

delete notifier_;

auto tabs = new QtChatTabs(settingsHierarchy_, true);

QtUIFactory* uiFactory = new QtUIFactory(settingsHierarchy_, qtSettings_, tabs, splitter_, systemTrays_[systemTrays_.size() - 1], networkFactories_.getTimerFactory(), statusCache_, autoUpdater_, emoticons_, enableAdHocCommandOnJID_);

uiFactories_.push_back(uiFactory);

&clientMainThreadCaller_,

&networkFactories_,

uiFactory,

&idleDetector_,

emoticons_,

useDelayForLatency_);

auto loginWindow = uiFactory->createLoginWindow(nullptr);

return dynamic_cast<QtLoginWindow*>(loginWindow);

class CertificateStorageFactory;

class Dock;

class EventLoop;

class Notifier;

class QtChatTabs;

class QtChatWindowFactory;

PlatformTLSFactories tlsFactories_;

BoostNetworkFactories networkFactories_;

QtChatWindowFactory* chatWindowFactory_;

std::vector<QtSystemTray*> systemTrays_;

std::vector<QtUIFactory*> uiFactories_;

QtSettingsProvider* qtSettings_;