ApplicationPathProvider::~ApplicationPathProvider() {

}

boost::filesystem::path ApplicationPathProvider::getProfileDir(const String& profile) const {

boost::filesystem::path result(getHomeDir() / profile.getUTF8String());

try {

ApplicationPathProvider(const String& applicationName);

virtual ~ApplicationPathProvider();

virtual boost::filesystem::path getHomeDir() const = 0;

virtual boost::filesystem::path getDataDir() const = 0;

virtual boost::filesystem::path getExecutableDir() const = 0;

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Network/MainBoostIOServiceThread.h"

#include "Swift/Controllers/BuildVersion.h"

#include "Swiften/VCards/VCardManager.h"

#include "Swift/Controllers/Chat/MUCSearchController.h"

#include "Swift/Controllers/Chat/ChatsManager.h"

#include "Swift/Controllers/XMPPEvents/EventController.h"

#include "Swiften/Disco/CapsInfoGenerator.h"

#include "Swiften/Disco/GetDiscoInfoRequest.h"

#include "Swiften/VCards/GetVCardRequest.h"

#include "Swiften/Avatars/AvatarManagerImpl.h"

#include "Swiften/Disco/CapsManager.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/StringCodecs/SHA1.h"

XMLConsoleWidgetFactory* xmlConsoleWidgetFactory,

ChatListWindowFactory* chatListWindowFactory,

MUCSearchWindowFactory* mucSearchWindowFactory,

Dock* dock,

Notifier* notifier,

bool useDelayForLatency) :

timerFactory_(&boostIOServiceThread_.getIOService()),

idleDetector_(&idleQuerier_, &timerFactory_, 100),

chatWindowFactory_(chatWindowFactory),

mainWindowFactory_(mainWindowFactory),

loginWindowFactory_(loginWindowFactory),

settings_(settings),

loginWindow_(NULL) ,

useDelayForLatency_(useDelayForLatency) {

statusTracker_ = NULL;

client_ = NULL;

avatarManager_ = NULL;

capsManager_ = NULL;

entityCapsManager_ = NULL;

chatListWindowFactory_ = chatListWindowFactory;

uiEventStream_ = new UIEventStream();

notifier_ = new TogglableNotifier(notifier);

eventController_ = new EventController();

eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));

resetClient();

delete eventController_;

delete notifier_;

}

void MainController::resetClient() {

avatarManager_ = NULL;

delete nickResolver_;

nickResolver_ = NULL;

delete client_;

client_ = NULL;

delete statusTracker_;

statusTracker_ = NULL;

delete profileSettings_;

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

discoInfoRequest->send();

rosterController_->setEnabled(true);

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

statusTracker_ = new StatusTracker();

}

if (!client_) {

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

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

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

client_->setSoftwareVersion(CLIENT_NAME, buildVersion);

entityCapsManager_ = new EntityCapsManager(capsManager_, client_->getStanzaChannel());

presenceNotifier_ = new PresenceNotifier(client_->getStanzaChannel(), notifier_, client_->getMUCRegistry(), avatarManager_, nickResolver_, client_->getPresenceOracle(), &timerFactory_);

presenceNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));

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

}

}

#include "Swift/Controllers/UIEvents/UIEvent.h"

namespace Swift {

class Application;

class Client;

class ChatWindowFactory;

class MUCSearchController;

class MUCSearchWindowFactory;

class StatusTracker;

class Dock;

class MainController {

public:

XMLConsoleWidgetFactory* xmlConsoleWidgetFactory,

ChatListWindowFactory* chatListWindowFactory_,

MUCSearchWindowFactory* mucSearchWindowFactory,

Dock* dock,

Notifier* notifier,

bool useDelayForLatency);

void setManagersOffline();

void handleNotificationClicked(const JID& jid);

private:

BoostIOServiceThread boostIOServiceThread_;

BoostTimerFactory timerFactory_;

PlatformIdleQuerier idleQuerier_;

ActualIdleDetector idleDetector_;

Client* client_;

ChatWindowFactory* chatWindowFactory_;

MainWindowFactory* mainWindowFactory_;

EventWindowFactory* eventWindowFactory_;

SettingsProvider *settings_;

ProfileSettingsProvider* profileSettings_;

Dock* dock_;

TogglableNotifier* notifier_;

PresenceNotifier* presenceNotifier_;

Timer::ref reconnectTimer_;

StatusTracker* statusTracker_;

bool myStatusLooksOnline_;

};

}

#pragma once

namespace Swift {

public:

};

}

#include "SwifTools/Application/PlatformApplicationPathProvider.h"

#include "Swiften/Avatars/AvatarFileStorage.h"

#include "Swiften/Disco/CapsFileStorage.h"

#include "Swiften/Base/String.h"

#include "Swiften/Base/Platform.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Client/Client.h"

#include "Swift/Controllers/MainController.h"

tabs_ = options.count("no-tabs") && !(splitter_ > 0) ? NULL : new QtChatTabs();

settings_ = new QtSettingsProvider();

applicationPathProvider_ = new PlatformApplicationPathProvider(SWIFT_APPLICATION_NAME);

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

soundPlayer_ = new QtSoundPlayer(applicationPathProvider_);

#if defined(HAVE_GROWL)

xmlConsoleWidgetFactory,

chatListWindowFactory,

mucSearchWindowFactory,

dock_,

notifier_,

options.count("latency-debug") > 0);

foreach (QtChatListWindowFactory* factory, chatListWindowFactories_) {

delete factory;

}

}

}

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

*/

#include <boost/program_options/variables_map.hpp>

#include <boost/program_options/options_description.hpp>

namespace Swift {

class Dock;

class Notifier;

class AutoUpdater;

class ApplicationPathProvider;

class AvatarStorage;

Dock* dock_;

QtChatTabs* tabs_;

ApplicationPathProvider* applicationPathProvider_;

AutoUpdater* autoUpdater_;

Notifier* notifier_;

#if defined(SWIFTEN_PLATFORM_MACOSX)

#endif

};

}

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Presence/PresenceSender.h"

#include "Swiften/MUC/MUCRegistry.h"

namespace Swift {

softwareVersionResponder = new SoftwareVersionResponder(getIQRouter());

softwareVersionResponder->start();

presenceSender = new PresenceSender(getStanzaChannel());

mucRegistry = new MUCRegistry();

}

Client::~Client() {

delete mucRegistry;

delete presenceSender;

softwareVersionResponder->stop();

delete softwareVersionResponder;

}

XMPPRoster* Client::getRoster() const {

return presenceOracle->getHighestPriorityPresence(bareJID);

}

}

class PresenceOracle;

class PresenceSender;

class MUCRegistry;

/**

* Provides the core functionality for writing XMPP client software.

*

* Besides connecting to an XMPP server, this class also provides interfaces for

* performing most tasks on the XMPP network.

*/

class Client : public CoreClient {

public:

~Client();

return mucRegistry;

}

public:

/**

* This signal is emitted when a JID changes presence.

boost::signal<void (const JID&, const String&)> onPresenceSubscriptionRequest;

private:

SoftwareVersionResponder* softwareVersionResponder;

XMPPRosterImpl* roster;

XMPPRosterController* rosterController;

PresenceOracle* presenceOracle;

PresenceSender* presenceSender;

MUCRegistry* mucRegistry;

};

}

"Client/CoreClient.cpp",

"Client/Client.cpp",

"Client/ClientSession.cpp",

"Compress/ZLibCodecompressor.cpp",

"Compress/ZLibDecompressor.cpp",

"Compress/ZLibCompressor.cpp",

"VCardManager.cpp",

"VCardStorage.cpp",

"VCardFileStorage.cpp",

])

swiften_env.Append(SWIFTEN_OBJECTS = [objects])