ChatControllerBase::~ChatControllerBase() {

delete chatWindow_;

}

void ChatControllerBase::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

if (info->hasFeature(DiscoInfo::SecurityLabels)) {

chatWindow_->setSecurityLabelsEnabled(true);

void activateChatWindow();

void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);

void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);

protected:

ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager);

#include "Swiften/Client/Client.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/VCardUpdate.h"

#include "Swiften/Queries/Responders/SoftwareVersionResponder.h"

#include "Swiften/Roster/TreeWidgetFactory.h"

#include "Swiften/Settings/SettingsProvider.h"

MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory *treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer)

: client_(NULL), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), treeWidgetFactory_(treeWidgetFactory), settings_(settings),

xmppRosterController_(NULL), rosterController_(NULL), loginWindow_(NULL), clientVersionResponder_(NULL), nickResolver_(NULL), discoResponder_(NULL),

application_ = application;

avatarStorage_ = new AvatarFileStorage(application_->getAvatarDir());

nickResolver_ = NULL;

delete avatarManager_;

avatarManager_ = NULL;

delete xmppRosterController_;

xmppRosterController_ = NULL;

delete clientVersionResponder_;

}

void MainController::handleConnected() {

presenceOracle_ = new PresenceOracle(client_);

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

avatarManager_ = new AvatarManager(client_, client_, avatarStorage_, this);

xmppRosterController_->requestRoster();

clientVersionResponder_ = new SoftwareVersionResponder(CLIENT_NAME, CLIENT_VERSION, client_);

DiscoInfo discoInfo;

discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

vCardRequest->send();

//Send presence last to catch all the incoming presences.

initialPresence->addPayload(capsInfo_);

sendPresence(initialPresence);

}

void MainController::handleEventQueueLengthChange(int count) {

presence->setShow(show);

}

presence->setStatus(statusText);

}

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

}

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

rosterController_->handleIncomingPresence(presence);

}

profileSettings->storeString("pass", remember ? password : "");

loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));

delete profileSettings;

resetClient();

//client_->onDataRead.connect(&printIncomingData);

//client_->onDataWritten.connect(&printOutgoingData);

}

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

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

logout();

}

loginWindow_->loggedOut();

delete discoResponder_;

discoResponder_ = NULL;

delete clientVersionResponder_;

clientVersionResponder_ = NULL;

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

}

}

#include "Swiften/Settings/SettingsProvider.h"

#include "Swiften/Elements/CapsInfo.h"

#include "Swiften/MUC/MUCRegistry.h"

namespace Swift {

class AvatarStorage;

ChatController* getChatController(const JID &contact);

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

void logout();

virtual bool isMUC(const JID& muc) const;

private:

Client* client_;

ChatWindowFactory* chatWindowFactory_;

MainWindowFactory* mainWindowFactory_;

std::map<JID, MUCController*> mucControllers_;

std::map<JID, ChatController*> chatControllers_;

boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

JID jid_;

PresenceOracle* presenceOracle_;

SystemTrayController* systemTrayController_;

AvatarManager* avatarManager_;

boost::shared_ptr<Presence> lastSentPresence_;

String vCardPhotoHash_;

};

}

#endif

*/

RosterController::RosterController(const JID& jid, boost::shared_ptr<XMPPRoster> xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, TreeWidgetFactory* treeWidgetFactory, NickResolver* nickResolver)

: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), treeWidgetFactory_(treeWidgetFactory), mainWindow_(mainWindowFactory_->createMainWindow()), roster_(new Roster(mainWindow_->getTreeWidget(), treeWidgetFactory_)), offlineFilter_(new OfflineRosterFilter()) {

roster_->addFilter(offlineFilter_);

mainWindow_->onStartChatRequest.connect(boost::bind(&RosterController::handleStartChatRequest, this, _1));

mainWindow_->onJoinMUCRequest.connect(boost::bind(&RosterController::handleJoinMUCRequest, this, _1, _2));

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

mainWindow_->onShowOfflineToggled.connect(boost::bind(&RosterController::handleShowOfflineToggled, this, _1));

roster_->onUserAction.connect(boost::bind(&RosterController::handleUserAction, this, _1));

xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));

}

RosterController::~RosterController() {

}

void RosterController::handleShowOfflineToggled(bool state) {

if (state) {

roster_->removeFilter(offlineFilter_);

~RosterController();

void showRosterWindow();

MainWindow* getWindow() {return mainWindow_;};

boost::signal<void (const JID&)> onStartChatRequest;

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

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

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

void handleAvatarChanged(const JID& jid, const String& hash);

private:

void handleOnJIDAdded(const JID &jid);

void handleStartChatRequest(const JID& contact);