Swiftdiff options
Diffstat (limited to 'Swift/Controllers')
25 files changed, 1134 insertions, 23 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp index a447f60..001251e 100644 --- a/Swift/Controllers/Chat/MUCController.cpp +++ b/Swift/Controllers/Chat/MUCController.cpp @@ -23,9 +23,9 @@ #include "Swiften/Elements/Delay.h" #include "Swiften/MUC/MUC.h" #include "Swiften/Client/StanzaChannel.h" -#include "Swiften/Roster/Roster.h" -#include "Swiften/Roster/SetAvatar.h" -#include "Swiften/Roster/SetPresence.h" +#include "Swift/Controllers/Roster/Roster.h" +#include "Swift/Controllers/Roster/SetAvatar.h" +#include "Swift/Controllers/Roster/SetPresence.h" #define MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS 60000 diff --git a/Swift/Controllers/ContactEditController.cpp b/Swift/Controllers/ContactEditController.cpp index 286fdeb..a8f7811 100644 --- a/Swift/Controllers/ContactEditController.cpp +++ b/Swift/Controllers/ContactEditController.cpp @@ -13,7 +13,7 @@ #include <Swift/Controllers/UIEvents/UIEventStream.h> #include <Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h> #include <Swift/Controllers/UIInterfaces/ContactEditWindowFactory.h> -#include <Swift/Controllers/RosterController.h> +#include <Swift/Controllers/Roster/RosterController.h> namespace Swift { diff --git a/Swift/Controllers/MainController.cpp b/Swift/Controllers/MainController.cpp index 3e1b366..98599bb 100644 --- a/Swift/Controllers/MainController.cpp +++ b/Swift/Controllers/MainController.cpp @@ -28,7 +28,7 @@ #include "Swift/Controllers/UIInterfaces/MainWindow.h" #include "Swift/Controllers/Chat/MUCController.h" #include "Swiften/Client/NickResolver.h" -#include "Swift/Controllers/RosterController.h" +#include "Swift/Controllers/Roster/RosterController.h" #include "Swift/Controllers/SoundEventController.h" #include "Swift/Controllers/SoundPlayer.h" #include "Swift/Controllers/StatusTracker.h" diff --git a/Swift/Controllers/Roster/AppearOffline.h b/Swift/Controllers/Roster/AppearOffline.h new file mode 100644 index 0000000..8bd53d7 --- /dev/null +++ b/Swift/Controllers/Roster/AppearOffline.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include <Swift/Controllers/Roster/RosterItemOperation.h> +#include <Swift/Controllers/Roster/ContactRosterItem.h> + +namespace Swift { + +class RosterItem; + +class AppearOffline : public RosterItemOperation { + public: + AppearOffline() { + } + + virtual void operator() (RosterItem* item) const { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item); + if (contact) { + contact->clearPresence(); + } + } + +}; + +} + + diff --git a/Swift/Controllers/Roster/ContactRosterItem.cpp b/Swift/Controllers/Roster/ContactRosterItem.cpp new file mode 100644 index 0000000..df0eb7b --- /dev/null +++ b/Swift/Controllers/Roster/ContactRosterItem.cpp @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#include "Swift/Controllers/Roster/ContactRosterItem.h" +#include "Swift/Controllers/Roster/GroupRosterItem.h" + +namespace Swift { + + +ContactRosterItem::ContactRosterItem(const JID& jid, const JID& displayJID, const String& name, GroupRosterItem* parent) : RosterItem(name, parent), jid_(jid), displayJID_(displayJID) { +} + +ContactRosterItem::~ContactRosterItem() { +} + +StatusShow::Type ContactRosterItem::getStatusShow() const { + return shownPresence_ ? shownPresence_->getShow() : StatusShow::None; +} + +StatusShow::Type ContactRosterItem::getSimplifiedStatusShow() const { + switch (shownPresence_ ? shownPresence_->getShow() : StatusShow::None) { + case StatusShow::Online: return StatusShow::Online; break; + case StatusShow::Away: return StatusShow::Away; break; + case StatusShow::XA: return StatusShow::Away; break; + case StatusShow::FFC: return StatusShow::Online; break; + case StatusShow::DND: return StatusShow::DND; break; + case StatusShow::None: return StatusShow::None; break; + } + assert(false); + return StatusShow::None; +} + +String ContactRosterItem::getStatusText() const { + return shownPresence_ ? shownPresence_->getStatus() : ""; +} + +void ContactRosterItem::setAvatarPath(const String& path) { + avatarPath_ = path; + onDataChanged(); +} +const String& ContactRosterItem::getAvatarPath() const { + return avatarPath_; +} + +const JID& ContactRosterItem::getJID() const { + return jid_; +} + +void ContactRosterItem::setDisplayJID(const JID& jid) { + displayJID_ = jid; +} + +const JID& ContactRosterItem::getDisplayJID() const { + return displayJID_; +} + + +typedef std::pair<String, boost::shared_ptr<Presence> > StringPresencePair; + +void ContactRosterItem::calculateShownPresence() { + shownPresence_ = offlinePresence_; + foreach (StringPresencePair presencePair, presences_) { + boost::shared_ptr<Presence> presence = presencePair.second; + if (!shownPresence_ || presence->getPriority() > shownPresence_->getPriority() || presence->getShow() < shownPresence_->getShow()) { + shownPresence_ = presence; + } + } +} + +void ContactRosterItem::clearPresence() { + presences_.clear(); + calculateShownPresence(); + onDataChanged(); +} + +void ContactRosterItem::applyPresence(const String& resource, boost::shared_ptr<Presence> presence) { + if (offlinePresence_) { + offlinePresence_ = boost::shared_ptr<Presence>(); + } + if (presence->getType() == Presence::Unavailable) { + if (resource.isEmpty()) { + /* Unavailable from the bare JID means all resources are offline.*/ + presences_.clear(); + } else { + if (presences_.find(resource) != presences_.end()) { + presences_.erase(resource); + } + } + if (presences_.size() == 0) { + offlinePresence_ = presence; + } + } else { + presences_[resource] = presence; + } + calculateShownPresence(); + onDataChanged(); +} + +const std::vector<String> ContactRosterItem::getGroups() const { + return groups_; +} + +/** Only used so a contact can know about the groups it's in*/ +void ContactRosterItem::addGroup(const String& group) { + groups_.push_back(group); +} +void ContactRosterItem::removeGroup(const String& group) { + groups_.erase(std::remove(groups_.begin(), groups_.end(), group), groups_.end()); +} + +} + + diff --git a/Swift/Controllers/Roster/ContactRosterItem.h b/Swift/Controllers/Roster/ContactRosterItem.h new file mode 100644 index 0000000..ca9d727 --- /dev/null +++ b/Swift/Controllers/Roster/ContactRosterItem.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swiften/Base/String.h" +#include "Swiften/JID/JID.h" +#include "Swift/Controllers/Roster/RosterItem.h" +#include "Swiften/Elements/StatusShow.h" +#include "Swiften/Elements/Presence.h" + +#include <map> +#include <boost/bind.hpp> +#include "Swiften/Base/boost_bsignals.h" +#include <boost/shared_ptr.hpp> + +namespace Swift { + +class GroupRosterItem; +class ContactRosterItem : public RosterItem { + public: + ContactRosterItem(const JID& jid, const JID& displayJID, const String& name, GroupRosterItem* parent); + virtual ~ContactRosterItem(); + + StatusShow::Type getStatusShow() const; + StatusShow::Type getSimplifiedStatusShow() const; + String getStatusText() const; + void setAvatarPath(const String& path); + const String& getAvatarPath() const; + const JID& getJID() const; + void setDisplayJID(const JID& jid); + const JID& getDisplayJID() const; + void applyPresence(const String& resource, boost::shared_ptr<Presence> presence); + void clearPresence(); + void calculateShownPresence(); + const std::vector<String> getGroups() const; + /** Only used so a contact can know about the groups it's in*/ + void addGroup(const String& group); + void removeGroup(const String& group); + private: + JID jid_; + JID displayJID_; + String avatarPath_; + std::map<String, boost::shared_ptr<Presence> > presences_; + boost::shared_ptr<Presence> offlinePresence_; + boost::shared_ptr<Presence> shownPresence_; + std::vector<String> groups_; +}; + +} + diff --git a/Swift/Controllers/Roster/GroupRosterItem.cpp b/Swift/Controllers/Roster/GroupRosterItem.cpp new file mode 100644 index 0000000..c473ae7 --- /dev/null +++ b/Swift/Controllers/Roster/GroupRosterItem.cpp @@ -0,0 +1,201 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#include "Swift/Controllers/Roster/GroupRosterItem.h" + +#include <boost/bind.hpp> +//#include <boost/algorithm.hpp> +#include <iostream> + +namespace Swift { + +GroupRosterItem::GroupRosterItem(const String& name, GroupRosterItem* parent, bool sortByStatus) : RosterItem(name, parent), sortByStatus_(sortByStatus) { + expanded_ = true; +} + +GroupRosterItem::~GroupRosterItem() { + +} + +bool GroupRosterItem::isExpanded() const { + return expanded_; +} + +/** + This has no effect, and is only used by the UI. + If reTransmit is specified, dataChanged will be emitted on a change - + This may be undesireable if called from the UI, so you can use reTransmit=false + to avoid a loop in this case. + */ +void GroupRosterItem::setExpanded(bool expanded) { + bool old = expanded_; + expanded_ = expanded; + if (expanded != old) { + onExpandedChanged(expanded); + } +} + +const std::vector<RosterItem*>& GroupRosterItem::getChildren() const { + return children_; +} + +const std::vector<RosterItem*>& GroupRosterItem::getDisplayedChildren() const { + return displayedChildren_; +} + +void GroupRosterItem::addChild(RosterItem* item) { + children_.push_back(item); + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item); + if (group) { + group->onChildrenChanged.connect(boost::bind(&GroupRosterItem::handleChildrenChanged, this, group)); + } else { + item->onDataChanged.connect(boost::bind(&GroupRosterItem::handleDataChanged, this, item)); + } + onChildrenChanged(); + onDataChanged(); +} + +/** + * Does not emit a changed signal. + */ +void GroupRosterItem::removeAll() { + std::vector<RosterItem*>::iterator it = children_.begin(); + displayedChildren_.clear(); + while (it != children_.end()) { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(*it); + if (contact) { + delete contact; + } else { + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(*it); + if (group) { + group->removeAll(); + delete group; + } + } + it++; + } + children_.clear(); +} + +/** + * Returns the removed item - but only if it's the only one, otherwise + * the return result is undefined. + */ +ContactRosterItem* GroupRosterItem::removeChild(const JID& jid) { + std::vector<RosterItem*>::iterator it = children_.begin(); + ContactRosterItem* removed = NULL; + while (it != children_.end()) { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(*it); + if (contact && contact->getJID() == jid) { + displayedChildren_.erase(std::remove(displayedChildren_.begin(), displayedChildren_.end(), contact), displayedChildren_.end()); + removed = contact; + delete contact; + it = children_.erase(it); + continue; + } + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(*it); + if (group) { + ContactRosterItem* groupRemoved = group->removeChild(jid); + if (groupRemoved) { + removed = groupRemoved; + } + } + it++; + } + onChildrenChanged(); + onDataChanged(); + return removed; +} + +/** + * Returns false if the list didn't need a resort + */ +bool GroupRosterItem::sortDisplayed() { + /* Not doing this until we import boost::algorithm*/ +// if (boost::is_sorted(displayedChildren_begin(), displayedChildren_.end(), itemLessThan)) { +// return false; +// } + //Sholudn't need stable_sort here + std::sort(displayedChildren_.begin(), displayedChildren_.end(), sortByStatus_? itemLessThanWithStatus : itemLessThanWithoutStatus); + return true; +} + +bool GroupRosterItem::itemLessThanWithoutStatus(const RosterItem* left, const RosterItem* right) { + return left->getSortableDisplayName() < right->getSortableDisplayName(); +} + +bool GroupRosterItem::itemLessThanWithStatus(const RosterItem* left, const RosterItem* right) { + const ContactRosterItem* leftContact = dynamic_cast<const ContactRosterItem*>(left); + const ContactRosterItem* rightContact = dynamic_cast<const ContactRosterItem*>(right); + if (leftContact) { + if (!rightContact) { + return false; + } + StatusShow::Type leftType = leftContact->getSimplifiedStatusShow(); + StatusShow::Type rightType = rightContact->getSimplifiedStatusShow(); + if (leftType == rightType) { + return left->getSortableDisplayName() < right->getSortableDisplayName(); + } else { + return leftType < rightType; + } + } else { + if (rightContact) { + return true; + } + return left->getSortableDisplayName() < right->getSortableDisplayName(); + } +} + +void GroupRosterItem::setDisplayed(RosterItem* item, bool displayed) { + bool found = false; + for (size_t i = 0; i < displayedChildren_.size(); i++) { + if (displayedChildren_[i] == item) { + found = true; + } + } + if (found == displayed) { + return; + } + if (displayed) { + displayedChildren_.push_back(item); + sortDisplayed(); + } else { + displayedChildren_.erase(std::remove(displayedChildren_.begin(), displayedChildren_.end(), item), displayedChildren_.end()); + } + onChildrenChanged(); + onDataChanged(); +} + +void GroupRosterItem::handleDataChanged(RosterItem* /*item*/) { + if (sortDisplayed()) { + onChildrenChanged(); + } +} + +void GroupRosterItem::handleChildrenChanged(GroupRosterItem* group) { + size_t oldSize = getDisplayedChildren().size(); + if (group->getDisplayedChildren().size() > 0) { + bool found = false; + for (size_t i = 0; i < displayedChildren_.size(); i++) { + if (displayedChildren_[i] == group) { + found = true; + } + } + if (!found) { + displayedChildren_.push_back(group); + sortDisplayed(); + } + } else { + displayedChildren_.erase(std::remove(displayedChildren_.begin(), displayedChildren_.end(), group), displayedChildren_.end()); + } + if (oldSize != getDisplayedChildren().size()) { + onChildrenChanged(); + onDataChanged(); + } +} + + +} diff --git a/Swift/Controllers/Roster/GroupRosterItem.h b/Swift/Controllers/Roster/GroupRosterItem.h new file mode 100644 index 0000000..85e8e46 --- /dev/null +++ b/Swift/Controllers/Roster/GroupRosterItem.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swift/Controllers/Roster/RosterItem.h" +#include "Swiften/Base/String.h" +#include "Swift/Controllers/Roster/ContactRosterItem.h" + +#include <vector> + +namespace Swift { + +class GroupRosterItem : public RosterItem { + public: + GroupRosterItem(const String& name, GroupRosterItem* parent, bool sortByStatus); + virtual ~GroupRosterItem(); + const std::vector<RosterItem*>& getChildren() const; + const std::vector<RosterItem*>& getDisplayedChildren() const; + void addChild(RosterItem* item); + ContactRosterItem* removeChild(const JID& jid); + void removeAll(); + void setDisplayed(RosterItem* item, bool displayed); + boost::signal<void ()> onChildrenChanged; + static bool itemLessThanWithStatus(const RosterItem* left, const RosterItem* right); + static bool itemLessThanWithoutStatus(const RosterItem* left, const RosterItem* right); + void setExpanded(bool expanded); + bool isExpanded() const; + boost::signal<void (bool)> onExpandedChanged; + private: + void handleChildrenChanged(GroupRosterItem* group); + void handleDataChanged(RosterItem* item); + bool sortDisplayed(); + String name_; + bool expanded_; + std::vector<RosterItem*> children_; + std::vector<RosterItem*> displayedChildren_; + bool sortByStatus_; +}; + +} + diff --git a/Swift/Controllers/Roster/OfflineRosterFilter.h b/Swift/Controllers/Roster/OfflineRosterFilter.h new file mode 100644 index 0000000..1af2624 --- /dev/null +++ b/Swift/Controllers/Roster/OfflineRosterFilter.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swift/Controllers/Roster/ContactRosterItem.h" +#include "Swift/Controllers/Roster/RosterItem.h" +#include "Swift/Controllers/Roster/RosterFilter.h" +#include "Swiften/Elements/StatusShow.h" + +namespace Swift { + +class OfflineRosterFilter : public RosterFilter { + public: + virtual ~OfflineRosterFilter() {} + virtual bool operator() (RosterItem *item) const { + ContactRosterItem *contactItem = dynamic_cast<ContactRosterItem*>(item); + return contactItem && contactItem->getStatusShow() == StatusShow::None; + } +}; + +} + + diff --git a/Swift/Controllers/Roster/Roster.cpp b/Swift/Controllers/Roster/Roster.cpp new file mode 100644 index 0000000..7967a38 --- /dev/null +++ b/Swift/Controllers/Roster/Roster.cpp @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#include "Swift/Controllers/Roster/Roster.h" + +#include "Swiften/Base/foreach.h" +#include "Swiften/Base/String.h" +#include "Swiften/JID/JID.h" +#include "Swift/Controllers/Roster/ContactRosterItem.h" +#include "Swift/Controllers/Roster/RosterItem.h" +#include "Swift/Controllers/Roster/GroupRosterItem.h" +#include "Swift/Controllers/Roster/RosterItemOperation.h" + +#include <boost/bind.hpp> + +#include <iostream> +#include <deque> + +namespace Swift { + +Roster::Roster(bool sortByStatus, bool fullJIDMapping) { + sortByStatus_ = sortByStatus; + fullJIDMapping_ = fullJIDMapping; + root_ = new GroupRosterItem("Dummy-Root", NULL, sortByStatus_); + root_->onChildrenChanged.connect(boost::bind(&Roster::handleChildrenChanged, this, root_)); +} + +Roster::~Roster() { + std::deque<RosterItem*> queue; + queue.push_back(root_); + while (!queue.empty()) { + RosterItem* item = *queue.begin(); + queue.pop_front(); + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item); + if (group) { + queue.insert(queue.begin(), group->getChildren().begin(), group->getChildren().end()); + } + delete item; + } +} + +GroupRosterItem* Roster::getRoot() { + return root_; +} + +GroupRosterItem* Roster::getGroup(const String& groupName) { + foreach (RosterItem *item, root_->getChildren()) { + GroupRosterItem *group = dynamic_cast<GroupRosterItem*>(item); + if (group && group->getDisplayName() == groupName) { + return group; + } + } + GroupRosterItem* group = new GroupRosterItem(groupName, root_, sortByStatus_); + root_->addChild(group); + group->onChildrenChanged.connect(boost::bind(&Roster::handleChildrenChanged, this, group)); + group->onDataChanged.connect(boost::bind(&Roster::handleDataChanged, this, group)); + return group; +} + +void Roster::handleDataChanged(RosterItem* item) { + onDataChanged(item); +} + +void Roster::handleChildrenChanged(GroupRosterItem* item) { + onChildrenChanged(item); +} + +void Roster::addContact(const JID& jid, const JID& displayJID, const String& name, const String& groupName, const String& avatarPath) { + GroupRosterItem* group(getGroup(groupName)); + ContactRosterItem *item = new ContactRosterItem(jid, displayJID, name, group); + item->setAvatarPath(avatarPath); + group->addChild(item); + if (itemMap_[fullJIDMapping_ ? jid : jid.toBare()].size() > 0) { + foreach (String existingGroup, itemMap_[fullJIDMapping_ ? jid : jid.toBare()][0]->getGroups()) { + item->addGroup(existingGroup); + } + } + itemMap_[fullJIDMapping_ ? jid : jid.toBare()].push_back(item); + item->onDataChanged.connect(boost::bind(&Roster::handleDataChanged, this, item)); + filterContact(item, group); + + foreach (ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) { + item->addGroup(groupName); + } +} + +struct JIDEqualsTo { + JIDEqualsTo(const JID& jid) : jid(jid) {} + bool operator()(ContactRosterItem* i) const { return jid == i->getJID(); } + JID jid; +}; + +void Roster::removeAll() { + root_->removeAll(); + itemMap_.clear(); + onChildrenChanged(root_); + onDataChanged(root_); +} + +void Roster::removeContact(const JID& jid) { + std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()]; + items->erase(std::remove_if(items->begin(), items->end(), JIDEqualsTo(jid)), items->end()); + if (items->size() == 0) { + itemMap_.erase(fullJIDMapping_ ? jid : jid.toBare()); + } + //Causes the delete + root_->removeChild(jid); +} + +void Roster::removeContactFromGroup(const JID& jid, const String& groupName) { + std::vector<RosterItem*> children = root_->getChildren(); + std::vector<RosterItem*>::iterator it = children.begin(); + while (it != children.end()) { + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(*it); + if (group && group->getDisplayName() == groupName) { + ContactRosterItem* deleted = group->removeChild(jid); + std::vector<ContactRosterItem*>* items = &itemMap_[fullJIDMapping_ ? jid : jid.toBare()]; + items->erase(std::remove(items->begin(), items->end(), deleted), items->end()); + } + it++; + } + foreach (ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) { + item->removeGroup(groupName); + } +} + + +void Roster::applyOnItems(const RosterItemOperation& operation) { + if (operation.requiresLookup()) { + applyOnItem(operation, operation.lookupJID()); + } else { + applyOnAllItems(operation); + } +} + +void Roster::applyOnItem(const RosterItemOperation& operation, const JID& jid) { + + foreach (ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) { + operation(item); + filterContact(item, item->getParent()); + } +} + +void Roster::applyOnAllItems(const RosterItemOperation& operation) { + std::deque<RosterItem*> queue; + queue.push_back(root_); + while (!queue.empty()) { + RosterItem* item = *queue.begin(); + queue.pop_front(); + operation(item); + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item); + if (group) { + queue.insert(queue.begin(), group->getChildren().begin(), group->getChildren().end()); + } + } + filterAll(); +} + +void Roster::removeFilter(RosterFilter *filter) { + for (unsigned int i = 0; i < filters_.size(); i++) { + if (filters_[i] == filter) { + filters_.erase(filters_.begin() + i); + break; + } + } + filterAll(); +} + +void Roster::filterContact(ContactRosterItem* contact, GroupRosterItem* group) { + int oldDisplayedSize = group->getDisplayedChildren().size(); + bool hide = true; + foreach (RosterFilter *filter, filters_) { + hide &= (*filter)(contact); + } + group->setDisplayed(contact, filters_.size() == 0 || !hide); + int newDisplayedSize = group->getDisplayedChildren().size(); + if (oldDisplayedSize == 0 && newDisplayedSize > 0) { + onGroupAdded(group); + } +} + +void Roster::filterGroup(GroupRosterItem* group) { + foreach (RosterItem* child, group->getChildren()) { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(child); + if (contact) { + filterContact(contact, group); + } + } +} + +void Roster::filterAll() { + std::deque<RosterItem*> queue; + queue.push_back(root_); + while (!queue.empty()) { + RosterItem *item = *queue.begin(); + queue.pop_front(); + GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item); + if (group) { + queue.insert(queue.begin(), group->getChildren().begin(), group->getChildren().end()); + filterGroup(group); + } + } +} + +} + diff --git a/Swift/Controllers/Roster/Roster.h b/Swift/Controllers/Roster/Roster.h new file mode 100644 index 0000000..70ff0b5 --- /dev/null +++ b/Swift/Controllers/Roster/Roster.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swiften/Base/String.h" +#include "Swiften/JID/JID.h" +#include "Swift/Controllers/Roster/RosterItemOperation.h" +#include "Swift/Controllers/Roster/RosterFilter.h" + +#include <vector> +#include <map> +#include "Swiften/Base/boost_bsignals.h" +#include <boost/shared_ptr.hpp> + +namespace Swift { + +class RosterItem; +class GroupRosterItem; +class ContactRosterItem; + +class Roster { + public: + Roster(bool sortByStatus = true, bool fullJIDMapping = false); + ~Roster(); + + void addContact(const JID& jid, const JID& displayJID, const String& name, const String& group, const String& avatarPath); + void removeContact(const JID& jid); + void removeContactFromGroup(const JID& jid, const String& group); + void removeAll(); + void applyOnItems(const RosterItemOperation& operation); + void applyOnAllItems(const RosterItemOperation& operation); + void applyOnItem(const RosterItemOperation& operation, const JID& jid); + void addFilter(RosterFilter *filter) {filters_.push_back(filter);filterAll();}; + void removeFilter(RosterFilter *filter); + GroupRosterItem* getRoot(); + std::vector<RosterFilter*> getFilters() {return filters_;}; + boost::signal<void (GroupRosterItem*)> onChildrenChanged; + boost::signal<void (GroupRosterItem*)> onGroupAdded; + boost::signal<void (RosterItem*)> onDataChanged; + private: + GroupRosterItem* getGroup(const String& groupName); + void handleDataChanged(RosterItem* item); + void handleChildrenChanged(GroupRosterItem* item); + void filterGroup(GroupRosterItem* item); + void filterContact(ContactRosterItem* contact, GroupRosterItem* group); + void filterAll(); + GroupRosterItem* root_; + std::vector<RosterFilter*> filters_; + std::map<JID, std::vector<ContactRosterItem*> > itemMap_; + bool fullJIDMapping_; + bool sortByStatus_; +}; + +} diff --git a/Swift/Controllers/RosterController.cpp b/Swift/Controllers/Roster/RosterController.cpp index be735cf..2dddd7d 100644 --- a/Swift/Controllers/RosterController.cpp +++ b/Swift/Controllers/Roster/RosterController.cpp @@ -4,7 +4,7 @@ * See Documentation/Licenses/GPLv3.txt for more information. */ -#include "Swift/Controllers/RosterController.h" +#include "Swift/Controllers/Roster/RosterController.h" #include <boost/bind.hpp> #include <boost/smart_ptr/make_shared.hpp> @@ -21,12 +21,12 @@ #include "Swiften/Presence/SubscriptionManager.h" #include "Swift/Controllers/XMPPEvents/EventController.h" #include "Swiften/Queries/IQRouter.h" -#include "Swiften/Roster/Roster.h" -#include "Swiften/Roster/SetPresence.h" -#include "Swiften/Roster/AppearOffline.h" -#include "Swiften/Roster/SetAvatar.h" -#include "Swiften/Roster/SetName.h" -#include "Swiften/Roster/OfflineRosterFilter.h" +#include "Swift/Controllers/Roster/Roster.h" +#include "Swift/Controllers/Roster/SetPresence.h" +#include "Swift/Controllers/Roster/AppearOffline.h" +#include "Swift/Controllers/Roster/SetAvatar.h" +#include "Swift/Controllers/Roster/SetName.h" +#include "Swift/Controllers/Roster/OfflineRosterFilter.h" #include "Swiften/Roster/XMPPRoster.h" #include "Swiften/Roster/XMPPRosterItem.h" #include "Swift/Controllers/UIEvents/AddContactUIEvent.h" diff --git a/Swift/Controllers/RosterController.h b/Swift/Controllers/Roster/RosterController.h index d8c2487..b0641c3 100644 --- a/Swift/Controllers/RosterController.h +++ b/Swift/Controllers/Roster/RosterController.h @@ -13,7 +13,7 @@ #include "Swiften/Elements/RosterPayload.h" #include "Swiften/Avatars/AvatarManager.h" #include "Swift/Controllers/UIEvents/UIEvent.h" -#include "Swift/Controllers/RosterGroupExpandinessPersister.h" +#include "RosterGroupExpandinessPersister.h" #include "Swiften/Base/boost_bsignals.h" #include <boost/shared_ptr.hpp> diff --git a/Swift/Controllers/Roster/RosterFilter.h b/Swift/Controllers/Roster/RosterFilter.h new file mode 100644 index 0000000..508b9da --- /dev/null +++ b/Swift/Controllers/Roster/RosterFilter.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swift/Controllers/Roster/RosterItem.h" + +namespace Swift { + +class RosterFilter { + public: + virtual ~RosterFilter() {} + virtual bool operator() (RosterItem* item) const = 0; +}; + +} + + diff --git a/Swift/Controllers/RosterGroupExpandinessPersister.cpp b/Swift/Controllers/Roster/RosterGroupExpandinessPersister.cpp index d532fcb..64baac9 100644 --- a/Swift/Controllers/RosterGroupExpandinessPersister.cpp +++ b/Swift/Controllers/Roster/RosterGroupExpandinessPersister.cpp @@ -4,12 +4,12 @@ * See Documentation/Licenses/GPLv3.txt for more information. */ -#include "Swift/Controllers/RosterGroupExpandinessPersister.h" +#include "RosterGroupExpandinessPersister.h" #include <boost/bind.hpp> #include <vector> -#include "Swiften/Roster/GroupRosterItem.h" +#include "Swift/Controllers/Roster/GroupRosterItem.h" namespace Swift { diff --git a/Swift/Controllers/RosterGroupExpandinessPersister.h b/Swift/Controllers/Roster/RosterGroupExpandinessPersister.h index 0b88a48..f73afa8 100644 --- a/Swift/Controllers/RosterGroupExpandinessPersister.h +++ b/Swift/Controllers/Roster/RosterGroupExpandinessPersister.h @@ -7,7 +7,7 @@ #pragma once #include <set> -#include "Swiften/Roster/Roster.h" +#include "Swift/Controllers/Roster/Roster.h" #include "Swift/Controllers/Settings/SettingsProvider.h" namespace Swift { diff --git a/Swift/Controllers/Roster/RosterItem.cpp b/Swift/Controllers/Roster/RosterItem.cpp new file mode 100644 index 0000000..61c5aea --- /dev/null +++ b/Swift/Controllers/Roster/RosterItem.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#include "Swift/Controllers/Roster/RosterItem.h" + +#include "Swift/Controllers/Roster/GroupRosterItem.h" + +namespace Swift { + +RosterItem::RosterItem(const String& name, GroupRosterItem* parent) : name_(name), sortableDisplayName_(name_.getLowerCase()), parent_(parent) { + /* The following would be good, but because of C++'s inheritance not working in constructors, it's not going to work. */ + //if (parent) { + // parent_->addChild(this); + //} +} + +RosterItem::~RosterItem() { + +} + +GroupRosterItem* RosterItem::getParent() const { + return parent_; +} + +void RosterItem::setDisplayName(const String& name) { + name_ = name; + sortableDisplayName_ = name_.getLowerCase(); + onDataChanged(); +} + +String RosterItem::getDisplayName() const { + return name_; +} + +String RosterItem::getSortableDisplayName() const { + return sortableDisplayName_; +} + + +} + diff --git a/Swift/Controllers/Roster/RosterItem.h b/Swift/Controllers/Roster/RosterItem.h new file mode 100644 index 0000000..35dbe73 --- /dev/null +++ b/Swift/Controllers/Roster/RosterItem.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swiften/Base/boost_bsignals.h" +#include <boost/shared_ptr.hpp> + +#include "Swiften/Base/String.h" + +namespace Swift { +class GroupRosterItem; +class RosterItem { + public: + RosterItem(const String& name, GroupRosterItem* parent); + virtual ~RosterItem(); + boost::signal<void ()> onDataChanged; + GroupRosterItem* getParent() const; + void setDisplayName(const String& name); + String getDisplayName() const; + String getSortableDisplayName() const; + private: + String name_; + String sortableDisplayName_; + GroupRosterItem* parent_; +}; + +} + diff --git a/Swift/Controllers/Roster/RosterItemOperation.h b/Swift/Controllers/Roster/RosterItemOperation.h new file mode 100644 index 0000000..691c8ef --- /dev/null +++ b/Swift/Controllers/Roster/RosterItemOperation.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swift/Controllers/Roster/RosterItem.h" + +namespace Swift { + +class RosterItemOperation { + public: + RosterItemOperation(bool requiresLookup = false, const JID& lookupJID = JID()) : requiresLookup_(requiresLookup), lookupJID_(lookupJID) {}; + virtual ~RosterItemOperation() {}; + bool requiresLookup() const {return requiresLookup_;}; + const JID& lookupJID() const {return lookupJID_;}; + /** + * This is called when iterating over possible subjects, so must check it's + * applying to the right items - even if requiresLookup() is true an item + * with the same bare JID but different full JID may be passed. + */ + virtual void operator() (RosterItem*) const = 0; + private: + bool requiresLookup_; + JID lookupJID_; +}; + +} diff --git a/Swift/Controllers/Roster/SetAvatar.h b/Swift/Controllers/Roster/SetAvatar.h new file mode 100644 index 0000000..2b9cfa8 --- /dev/null +++ b/Swift/Controllers/Roster/SetAvatar.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swiften/Elements/Presence.h" +#include "Swiften/JID/JID.h" +#include "Swift/Controllers/Roster/RosterItemOperation.h" +#include "Swift/Controllers/Roster/ContactRosterItem.h" + +namespace Swift { + +class RosterItem; + +class SetAvatar : public RosterItemOperation { + public: + SetAvatar(const JID& jid, const String& path, JID::CompareType compareType = JID::WithoutResource) : RosterItemOperation(true, jid), jid_(jid), path_(path), compareType_(compareType) { + } + + virtual void operator() (RosterItem* item) const { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item); + if (contact && contact->getJID().equals(jid_, compareType_)) { + contact->setAvatarPath(path_); + } + } + + private: + JID jid_; + String path_; + JID::CompareType compareType_; +}; + +} diff --git a/Swift/Controllers/Roster/SetName.h b/Swift/Controllers/Roster/SetName.h new file mode 100644 index 0000000..4d75392 --- /dev/null +++ b/Swift/Controllers/Roster/SetName.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2010 Kevin Smith + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swiften/JID/JID.h" +#include "Swift/Controllers/Roster/RosterItemOperation.h" +#include "Swift/Controllers/Roster/ContactRosterItem.h" + +namespace Swift { + +class RosterItem; + +class SetName : public RosterItemOperation { + public: + SetName(const String& name, const JID& jid, JID::CompareType compareType = JID::WithoutResource) : RosterItemOperation(true, jid), name_(name), jid_(jid), compareType_(compareType) { + } + + virtual void operator() (RosterItem* item) const { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item); + if (contact && contact->getJID().equals(jid_, compareType_)) { + contact->setDisplayName(name_); + } + } + + private: + String name_; + JID jid_; + JID::CompareType compareType_; +}; + +} + + diff --git a/Swift/Controllers/Roster/SetPresence.h b/Swift/Controllers/Roster/SetPresence.h new file mode 100644 index 0000000..06adfa4 --- /dev/null +++ b/Swift/Controllers/Roster/SetPresence.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#pragma once + +#include "Swiften/Elements/Presence.h" +#include "Swiften/JID/JID.h" +#include "Swift/Controllers/Roster/RosterItemOperation.h" +#include "Swift/Controllers/Roster/ContactRosterItem.h" + +namespace Swift { + +class RosterItem; + +class SetPresence : public RosterItemOperation { + public: + SetPresence(Presence::ref presence, JID::CompareType compareType = JID::WithoutResource) : RosterItemOperation(true, compareType == JID::WithoutResource ? presence->getFrom().toBare() : presence->getFrom()), presence_(presence), compareType_(compareType) { + } + + virtual void operator() (RosterItem* item) const { + ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item); + if (contact && contact->getJID().equals(presence_->getFrom(), compareType_)) { + contact->applyPresence(presence_->getFrom().getResource(), presence_); + } + } + + private: + Presence::ref presence_; + JID::CompareType compareType_; +}; + +} + diff --git a/Swift/Controllers/UnitTest/RosterControllerTest.cpp b/Swift/Controllers/Roster/UnitTest/RosterControllerTest.cpp index 2f6f0da..604cda6 100644 --- a/Swift/Controllers/UnitTest/RosterControllerTest.cpp +++ b/Swift/Controllers/Roster/UnitTest/RosterControllerTest.cpp @@ -8,7 +8,7 @@ #include <cppunit/extensions/HelperMacros.h> #include <cppunit/extensions/TestFactoryRegistry.h> -#include "Swift/Controllers/RosterController.h" +#include "Swift/Controllers/Roster/RosterController.h" #include "Swift/Controllers/UnitTest/MockMainWindowFactory.h" // #include "Swiften/Elements/Payload.h" // #include "Swiften/Elements/RosterItemPayload.h" @@ -17,9 +17,9 @@ #include "Swiften/Client/DummyStanzaChannel.h" #include "Swiften/Queries/IQRouter.h" #include "Swiften/Roster/XMPPRosterImpl.h" -#include "Swiften/Roster/Roster.h" -#include "Swiften/Roster/GroupRosterItem.h" -#include "Swiften/Roster/ContactRosterItem.h" +#include "Swift/Controllers/Roster/Roster.h" +#include "Swift/Controllers/Roster/GroupRosterItem.h" +#include "Swift/Controllers/Roster/ContactRosterItem.h" #include "Swift/Controllers/Settings/DummySettingsProvider.h" #include "Swiften/Avatars/NullAvatarManager.h" #include "Swift/Controllers/XMPPEvents/EventController.h" diff --git a/Swift/Controllers/Roster/UnitTest/RosterTest.cpp b/Swift/Controllers/Roster/UnitTest/RosterTest.cpp new file mode 100644 index 0000000..754f3e1 --- /dev/null +++ b/Swift/Controllers/Roster/UnitTest/RosterTest.cpp @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2010 Remko Tronçon + * Licensed under the GNU General Public License v3. + * See Documentation/Licenses/GPLv3.txt for more information. + */ + +#include <cppunit/extensions/HelperMacros.h> +#include <cppunit/extensions/TestFactoryRegistry.h> +#include <boost/shared_ptr.hpp> + +#include "Swift/Controllers/Roster/Roster.h" +#include "Swift/Controllers/Roster/GroupRosterItem.h" +#include "Swift/Controllers/Roster/SetPresence.h" + +using namespace Swift; + +class RosterTest : public CppUnit::TestFixture { + CPPUNIT_TEST_SUITE(RosterTest); + CPPUNIT_TEST(testGetGroup); + CPPUNIT_TEST(testRemoveContact); + CPPUNIT_TEST(testRemoveSecondContact); + CPPUNIT_TEST(testRemoveSecondContactSameBare); + CPPUNIT_TEST(testApplyPresenceLikeMUC); + CPPUNIT_TEST_SUITE_END(); + + public: + void setUp() { + jid1_ = JID("a@b.c"); + jid2_ = JID("b@c.d"); + jid3_ = JID("c@d.e"); + roster_ = new Roster(); + } + + void tearDown() { + delete roster_; + } + + void testGetGroup() { + roster_->addContact(jid1_, JID(), "Bert", "group1", ""); + roster_->addContact(jid2_, JID(), "Ernie", "group2", ""); + roster_->addContact(jid3_, JID(), "Cookie", "group1", ""); + + CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(roster_->getRoot()->getChildren().size())); + CPPUNIT_ASSERT_EQUAL(String("group1"), roster_->getRoot()->getChildren()[0]->getDisplayName()); + CPPUNIT_ASSERT_EQUAL(String("group2"), roster_->getRoot()->getChildren()[1]->getDisplayName()); + CPPUNIT_ASSERT_EQUAL(String("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName()); + CPPUNIT_ASSERT_EQUAL(String("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName()); + CPPUNIT_ASSERT_EQUAL(String("Ernie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[1])->getChildren()[0]->getDisplayName()); + + } + + void testRemoveContact() { + roster_->addContact(jid1_, jid1_, "Bert", "group1", ""); + CPPUNIT_ASSERT_EQUAL(String("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName()); + + roster_->removeContact(jid1_); + CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren().size())); + } + + void testRemoveSecondContact() { + roster_->addContact(jid1_, jid1_, "Bert", "group1", ""); + roster_->addContact(jid2_, jid2_, "Cookie", "group1", ""); + CPPUNIT_ASSERT_EQUAL(String("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName()); + + roster_->removeContact(jid2_); + CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren().size())); + CPPUNIT_ASSERT_EQUAL(String("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName()); + } + + void testRemoveSecondContactSameBare() { + JID jid4a("a@b/c"); + JID jid4b("a@b/d"); + roster_->addContact(jid4a, JID(), "Bert", "group1", ""); + roster_->addContact(jid4b, JID(), "Cookie", "group1", ""); + CPPUNIT_ASSERT_EQUAL(String("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName()); + + roster_->removeContact(jid4b); + CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren().size())); + CPPUNIT_ASSERT_EQUAL(String("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName()); + } + + void testApplyPresenceLikeMUC() { + JID jid4a("a@b/c"); + JID jid4b("a@b/d"); + JID jid4c("a@b/e"); + roster_->addContact(jid4a, JID(), "Bird", "group1", ""); + roster_->addContact(jid4b, JID(), "Cookie", "group1", ""); + roster_->removeContact(jid4b); + roster_->addContact(jid4c, JID(), "Bert", "group1", ""); + roster_->addContact(jid4b, JID(), "Ernie", "group1", ""); + boost::shared_ptr<Presence> presence(new Presence()); + presence->setShow(StatusShow::DND); + presence->setFrom(jid4a); + roster_->applyOnItems(SetPresence(presence, JID::WithResource)); + presence->setFrom(jid4b); + roster_->applyOnItems(SetPresence(presence, JID::WithResource)); + presence->setFrom(jid4c); + roster_->applyOnItems(SetPresence(presence, JID::WithResource)); + + presence = boost::shared_ptr<Presence>(new Presence()); + presence->setFrom(jid4b); + presence->setShow(StatusShow::Online); + roster_->applyOnItems(SetPresence(presence, JID::WithResource)); + std::vector<RosterItem*> children = static_cast<GroupRosterItem*>(roster_->getRoot()->getDisplayedChildren()[0])->getDisplayedChildren(); + CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(children.size())); + + /* Check order */ + CPPUNIT_ASSERT_EQUAL(String("Ernie"), children[0]->getDisplayName()); + CPPUNIT_ASSERT_EQUAL(String("Bert"), children[1]->getDisplayName()); + CPPUNIT_ASSERT_EQUAL(String("Bird"), children[2]->getDisplayName()); + + presence = boost::shared_ptr<Presence>(new Presence()); + presence->setFrom(jid4c); + presence->setType(Presence::Unavailable); + roster_->removeContact(jid4c); + roster_->applyOnItems(SetPresence(presence, JID::WithResource)); + + } + + private: + Roster *roster_; + JID jid1_; + JID jid2_; + JID jid3_; +}; + +CPPUNIT_TEST_SUITE_REGISTRATION(RosterTest); + diff --git a/Swift/Controllers/SConscript b/Swift/Controllers/SConscript index c8314de..c563c7b 100644 --- a/Swift/Controllers/SConscript +++ b/Swift/Controllers/SConscript @@ -31,8 +31,12 @@ if env["SCONS_STAGE"] == "build" : "MainController.cpp", "ProfileController.cpp", "ContactEditController.cpp", - "RosterController.cpp", - "RosterGroupExpandinessPersister.cpp", + "Roster/RosterController.cpp", + "Roster/RosterGroupExpandinessPersister.cpp", + "Roster/ContactRosterItem.cpp", + "Roster/GroupRosterItem.cpp", + "Roster/RosterItem.cpp", + "Roster/Roster.cpp", "EventWindowController.cpp", "SoundEventController.cpp", "SystemTrayController.cpp", @@ -51,7 +55,8 @@ if env["SCONS_STAGE"] == "build" : ]) env.Append(UNITTEST_SOURCES = [ - File("UnitTest/RosterControllerTest.cpp"), + File("Roster/UnitTest/RosterControllerTest.cpp"), + File("Roster/UnitTest/RosterTest.cpp"), File("UnitTest/PreviousStatusStoreTest.cpp"), File("UnitTest/PresenceNotifierTest.cpp"), File("Chat/UnitTest/ChatsManagerTest.cpp"), |