/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/Controllers/Roster/RosterController.h"

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include "Swift/Controllers/Roster/SetName.h"

#include "Swift/Controllers/Roster/OfflineRosterFilter.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

#include "Swiften/Roster/XMPPRoster.h"

#include "Swiften/Roster/XMPPRosterItem.h"

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

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

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

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

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

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/Client/NickManager.h>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Disco/EntityCapsManager.h>

#include <Swiften/Jingle/JingleSessionManager.h>

namespace Swift {

/**

* The controller does not gain ownership of these parameters.

*/

RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, FileTransferOverview* fileTransferOverview)

: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), nickManager_(nickManager), nickResolver_(nickResolver), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview) {

assert(fileTransferOverview);

iqRouter_ = iqRouter;

presenceOracle_ = presenceOracle;

subscriptionManager_ = subscriptionManager;

avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1));

mainWindow_->setMyAvatarPath(avatarManager_->getAvatarPath(myJID_).string());

nickManager_->onOwnNickChanged.connect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

mainWindow_->setMyJID(jid);

mainWindow_->setMyNick(nickManager_->getOwnNick());

entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));

}

RosterController::~RosterController() {

nickManager_->onOwnNickChanged.disconnect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

delete offlineFilter_;

delete expandiness_;

mainWindow_->setRosterModel(NULL);

if (mainWindow_->canDelete()) {

delete mainWindow_;

}

}

void RosterController::setEnabled(bool enabled) {

if (!enabled) {

roster_->applyOnItems(AppearOffline());

}

}

void RosterController::handleShowOfflineToggled(bool state) {

}

if (state) {

roster_->removeFilter(offlineFilter_);

} else {

roster_->addFilter(offlineFilter_);

}

}

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

roster_->removeContactFromGroup(jid, group);

if (roster_->getGroup(group)->getChildren().size() == 0) {

roster_->removeGroup(group);

}

}

}

applyAllPresenceTo(jid);

}

}

RosterItemPayload item;

item.setName(addContactEvent->getName());

item.setJID(addContactEvent->getJID());

item.setGroups(std::vector<std::string>(addContactEvent->getGroups().begin(), addContactEvent->getGroups().end()));

boost::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(item);

SetRosterRequest::ref request = SetRosterRequest::create(roster, iqRouter_);

request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

request->send();

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

void handleSubscriptionRequest(const JID& jid, const std::string& message);

void handleSubscriptionRequestAccepted(SubscriptionRequestEvent* event);

void handleSubscriptionRequestDeclined(SubscriptionRequestEvent* event);

void handleUIEvent(boost::shared_ptr<UIEvent> event);

void handleRosterSetError(ErrorPayload::ref error, boost::shared_ptr<RosterPayload> rosterPayload);

void applyAllPresenceTo(const JID& jid);

void handleEditProfileRequest();

void handleOnCapsChanged(const JID& jid);

JID myJID_;

XMPPRoster* xmppRoster_;

MainWindowFactory* mainWindowFactory_;

MainWindow* mainWindow_;

Roster* roster_;

OfflineRosterFilter* offlineFilter_;

AvatarManager* avatarManager_;

NickManager* nickManager_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/bind.hpp>

#include <vector>

#include <Swiften/Base/foreach.h>

namespace Swift {

RosterGroupExpandinessPersister::RosterGroupExpandinessPersister(Roster* roster, SettingsProvider* settings) : roster_(roster), settings_(settings) {

load();

roster_->onGroupAdded.connect(boost::bind(&RosterGroupExpandinessPersister::handleGroupAdded, this, _1));

}

void RosterGroupExpandinessPersister::handleGroupAdded(GroupRosterItem* group) {

void RosterGroupExpandinessPersister::save() {

std::string setting;

foreach (const std::string& group, collapsed_) {

if (!setting.empty()) {

setting += "\n";

}

setting += group;

}

}

void RosterGroupExpandinessPersister::load() {

std::vector<std::string> collapsed = String::split(saved, '\n');

collapsed_.insert(collapsed.begin(), collapsed.end());

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <set>

#include "Swift/Controllers/Roster/Roster.h"

#include "Swift/Controllers/Settings/SettingsProvider.h"

RosterGroupExpandinessPersister(Roster* roster, SettingsProvider* settings);

private:

void handleExpandedChanged(GroupRosterItem* group, bool expanded);

void handleGroupAdded(GroupRosterItem* group);

void load();

void save();

std::set<std::string> collapsed_;

Roster* roster_;

SettingsProvider* settings_;

};

}