#include <Swift/Controllers/ProfileController.h>

#include <Swift/Controllers/ContactEditController.h>

#include <Swift/Controllers/XMPPURIController.h>

#include "Swift/Controllers/AdHocManager.h"

#include <SwifTools/Idle/IdleDetector.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swift/Controllers/SettingConstants.h>

namespace Swift {

static const std::string CLIENT_NAME = "Swift";

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

MainController::MainController(

EventLoop* eventLoop,

profileController_ = new ProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

srand(time(NULL));

int randomPort = 10000 + rand() % 10000;

client_->getFileTransferManager()->startListeningOnPort(randomPort);

ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());

fileTransferListController_->setFileTransferOverview(ftOverview_);

rosterController_ = new RosterController(jid_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), ftOverview_);

rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));

rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));

contactEditController_ = new ContactEditController(rosterController_, client_->getVCardManager(), uiFactory_, uiEventStream_);

chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_);

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

chatsManager_->setAvatarManager(client_->getAvatarManager());

eventWindowController_ = new EventWindowController(eventController_, uiFactory_);

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_->setEnabled(true);

profileController_->setAvailable(true);

contactEditController_->setAvailable(true);

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

sendPresence(statusTracker_->getNextPresence());

/* Enable chats last of all, so rejoining MUCs has the right sent presence */

chatsManager_->setOnline(true);

}

if (statusTracker_->goAutoUnAway()) {

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

sendPresence(statusTracker_->getNextPresence());

}

}

}

}

}

void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificatePath, CertificateWithKey::ref certificate, bool remember, bool loginAutomatically) {

jid_ = JID(username);

if (!jid_.isValid() || jid_.getNode().empty()) {

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

loginWindow_->setIsLoggingIn(false);

} else {

loginWindow_->setMessage("");

loginWindow_->setIsLoggingIn(true);

profileSettings_ = new ProfileSettingsProvider(username, settings_);

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

void handleDisconnected(const boost::optional<ClientError>& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, ErrorPayload::ref);

void handleEventQueueLengthChange(int count);

void handleVCardReceived(const JID& j, VCard::ref vCard);

void handleSettingChanged(const std::string& settingPath);

void handlePurgeSavedLoginRequest(const std::string& username);

void sendPresence(boost::shared_ptr<Presence> presence);

void handleInputIdleChanged(bool);

void logout();

void signOut();

void setReconnectTimer();

void resetPendingReconnects();

void resetCurrentError();

void performLoginFromCachedCredentials();

void reconnectAfterError();

void setManagersOffline();

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <string>

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/StatusShow.h"

#include "Swiften/Elements/DiscoItems.h"

#include "Swiften/Base/boost_bsignals.h"

#include <boost/shared_ptr.hpp>

namespace Swift {

class Roster;

class MainWindow {

public:

MainWindow(bool candelete = true) : canDelete_(candelete) {}

virtual void setMyNick(const std::string& name) = 0;

virtual void setMyJID(const JID& jid) = 0;

virtual void setMyAvatarPath(const std::string& path) = 0;

virtual void setMyStatusText(const std::string& status) = 0;

virtual void setMyStatusType(StatusShow::Type type) = 0;

/** Must be able to cope with NULL to clear the roster */

virtual void setRosterModel(Roster* roster) = 0;

virtual void setConnecting() = 0;

virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) = 0;

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

private:

bool canDelete_;

};

}

virtual ~MockMainWindow() {};

virtual void setRosterModel(Roster* roster) {this->roster = roster;};

virtual void setMyNick(const std::string& /*name*/) {};;

virtual void setMyJID(const JID& /*jid*/) {};;

virtual void setMyAvatarPath(const std::string& /*path*/) {};

virtual void setMyStatusText(const std::string& /*status*/) {};

virtual void setMyStatusType(StatusShow::Type /*type*/) {};

virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {};

virtual void setConnecting() {};

Roster* roster;

};

}