std::string group = renameGroupEvent->getGroup();

// FIXME: We should handle contacts groups specially to avoid clashes

if (group == QT_TRANSLATE_NOOP("", "Contacts")) {

group = "";

}

foreach(XMPPRosterItem& item, items) {

std::vector<std::string> groups = item.getGroups();

if ( (group.empty() && groups.empty()) || std::find(groups.begin(), groups.end(), group) != groups.end()) {

groups.erase(std::remove(groups.begin(), groups.end(), group), groups.end());

if (std::find(groups.begin(), groups.end(), renameGroupEvent->getNewName()) == groups.end()) {

groups.push_back(renameGroupEvent->getNewName());

}

item.setGroups(groups);

updateItem(item);

}

}

}

else if (boost::shared_ptr<SendFileUIEvent> sendFileEvent = boost::dynamic_pointer_cast<SendFileUIEvent>(event)) {

//TODO add send file dialog to ChatView of receipient jid

ftOverview_->sendFile(sendFileEvent->getJID(), sendFileEvent->getFilename());

}

}

void RosterController::setContactGroups(const JID& jid, const std::vector<std::string>& groups) {

updateItem(XMPPRosterItem(jid, xmppRoster_->getNameForJID(jid), groups, xmppRoster_->getSubscriptionStateForJID(jid)));

}

void RosterController::updateItem(const XMPPRosterItem& item) {

RosterItemPayload itemPayload(item.getJID(), item.getName(), item.getSubscription());

itemPayload.setGroups(item.getGroups());

RosterPayload::ref roster = boost::make_shared<RosterPayload>();

roster->addItem(itemPayload);

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

request->send();

}

void RosterController::initBlockingCommand() {

boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&RosterController::handleBlockingStateChanged, this));

blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&RosterController::handleBlockingItemAdded, this, _1));

blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&RosterController::handleBlockingItemRemoved, this, _1));

roster_->setBlockingSupported(true);

if (blockList->getState() == BlockList::Available) {

foreach(const JID& jid, blockList->getItems()) {

roster_->applyOnItems(SetBlockingState(jid, ContactRosterItem::IsBlocked));

}

}

}

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

if (!error) {

return;

}

std::string text = str(format(QT_TRANSLATE_NOOP("", "Server %1% rejected contact list change to item '%2%'")) % myJID_.getDomain() % rosterPayload->getItems()[0].getJID().toString());

if (!error->getText().empty()) {

text += ": " + error->getText();

}

boost::shared_ptr<ErrorEvent> errorEvent(new ErrorEvent(JID(myJID_.getDomain()), text));

eventController_->handleIncomingEvent(errorEvent);

}

void RosterController::handleIncomingPresence(Presence::ref newPresence) {

if (newPresence->getType() == Presence::Error) {

return;

}

roster_->applyOnItems(SetPresence(newPresence));

}

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

if (xmppRoster_->containsJID(jid) && (xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::To || xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::Both)) {

subscriptionManager_->confirmSubscription(jid);

return;

}

SubscriptionRequestEvent* eventPointer = new SubscriptionRequestEvent(jid, message);

eventPointer->onAccept.connect(boost::bind(&RosterController::handleSubscriptionRequestAccepted, this, eventPointer));

eventPointer->onDecline.connect(boost::bind(&RosterController::handleSubscriptionRequestDeclined, this, eventPointer));

boost::shared_ptr<StanzaEvent> event(eventPointer);

eventController_->handleIncomingEvent(event);

}

void RosterController::handleSubscriptionRequestAccepted(SubscriptionRequestEvent* event) {

subscriptionManager_->confirmSubscription(event->getJID());

if (!xmppRoster_->containsJID(event->getJID()) || xmppRoster_->getSubscriptionStateForJID(event->getJID()) == RosterItemPayload::None || xmppRoster_->getSubscriptionStateForJID(event->getJID()) == RosterItemPayload::From) {

subscriptionManager_->requestSubscription(event->getJID());

class RosterController {

public:

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* entityCapsProvider, FileTransferOverview* fileTransferOverview, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager);

~RosterController();

void showRosterWindow();

void setJID(const JID& jid) { myJID_ = jid; }

MainWindow* getWindow() {return mainWindow_;}

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

boost::signal<void ()> onSignOutRequest;

void handleOwnVCardChanged(VCard::ref vcard);

void handleAvatarChanged(const JID& jid);

void handlePresenceChanged(Presence::ref presence);

void setEnabled(bool enabled);

boost::optional<XMPPRosterItem> getItem(const JID&) const;

std::set<std::string> getGroups() const;

void setContactGroups(const JID& jid, const std::vector<std::string>& groups);

void updateItem(const XMPPRosterItem&);

void initBlockingCommand();

private:

void handleOnJIDAdded(const JID &jid);

void handleRosterCleared();

void handleOnJIDRemoved(const JID &jid);

void handleOnJIDUpdated(const JID &jid, const std::string& oldName, const std::vector<std::string>& oldGroups);

void handleStartChatRequest(const JID& contact);

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

void handleShowOfflineToggled(bool state);

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);

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

void handleBlockingStateChanged();

void handleBlockingItemAdded(const JID& jid);

void handleBlockingItemRemoved(const JID& jid);

JID myJID_;

XMPPRoster* xmppRoster_;

MainWindowFactory* mainWindowFactory_;

MainWindow* mainWindow_;

Roster* roster_;

OfflineRosterFilter* offlineFilter_;

VCardManager* vcardManager_;

AvatarManager* avatarManager_;

NickManager* nickManager_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

SubscriptionManager* subscriptionManager_;

EventController* eventController_;

RosterGroupExpandinessPersister* expandiness_;

IQRouter* iqRouter_;

SettingsProvider* settings_;

UIEventStream* uiEventStream_;

EntityCapsProvider* entityCapsManager_;

FileTransferOverview* ftOverview_;

ClientBlockListManager* clientBlockListManager_;

RosterVCardProvider* rosterVCardProvider_;

boost::shared_ptr<ContactRosterItem> ownContact_;

boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

boost::bsignals::scoped_connection blockingOnItemAddedConnection_;