+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream) {

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream);

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency) {

+ chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

+ class UIEventStream;

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

+ChatsManager::ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, boost::shared_ptr<DiscoInfo> serverDiscoInfo, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency) : jid_(jid), useDelayForLatency_(useDelayForLatency) {

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_);

+ MUCController* controller = new MUCController(jid_, muc, nick, stanzaChannel_, presenceSender_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false);

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, boost::shared_ptr<DiscoInfo> serverDiscoInfo, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency);

+ void handleChatRequest(const String& contact);

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc, presenceOracle, avatarManager, useDelayForLatency, uiEventStream),

+ nick_(nick) {

+ roster_ = new Roster();

+ chatWindow_->setRosterModel(roster_);

+ chatWindow_->setRosterModel(NULL);

+ MUCController(const JID& self, const JID &muc, const String &nick, StanzaChannel* stanzaChannel, PresenceSender* presenceSender, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency);

+#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, nickResolver_, presenceOracle_, serverDiscoInfo_, presenceSender_, uiEventStream_, chatListWindowFactory_, true);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID1, uiEventStream_).Return(window1);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID2, uiEventStream_).Return(window2);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString), uiEventStream_).Return(window);

+

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString))));

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(bareJIDString), uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(bareJIDString))));

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString1), uiEventStream_).Return(window1);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString1))));

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString2), uiEventStream_).Return(window2);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString2))));

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(bareJIDString), uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(bareJIDString))));

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID1, uiEventStream_).Return(window1);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID2, uiEventStream_).Return(window2);

+MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, EventWindowFactory* eventWindowFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, XMLConsoleWidgetFactory* xmlConsoleWidgetFactory, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency)

+ : timerFactory_(&boostIOServiceThread_.getIOService()), idleDetector_(&idleQuerier_, &timerFactory_, 100), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), settings_(settings), loginWindow_(NULL), useDelayForLatency_(useDelayForLatency) {

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickResolver_, presenceOracle_, eventController_, uiEventStream_, client_);

+ chatsManager_ = new ChatsManager(jid_, client_, client_, eventController_, chatWindowFactory_, nickResolver_, presenceOracle_, serverDiscoInfo_, presenceSender_, uiEventStream_, chatListWindowFactory_, useDelayForLatency_);

+ MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, EventWindowFactory* eventWindowFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, XMLConsoleWidgetFactory* xmlConsoleWidgetFactory, ChatListWindowFactory* chatListWindowFactory_, bool useDelayForLatency);

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

+RosterController::RosterController(const JID& jid, boost::shared_ptr<XMPPRoster> xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter)

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

+ mainWindow_->setRosterModel(roster_);

+ return;

+ boost::shared_ptr<RemoveRosterItemUIEvent> removeEvent = boost::dynamic_pointer_cast<RemoveRosterItemUIEvent>(event);

+ if (removeEvent) {

+ RosterItemPayload item(removeEvent->getJID(), "", RosterItemPayload::Remove);

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

+ roster->addItem(item);

+ boost::shared_ptr<SetRosterRequest> request(new SetRosterRequest(roster, iqRouter_));

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

+ request->send();

+

+ return;

+ }

+

+ RosterController(const JID& jid, boost::shared_ptr<XMPPRoster> xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_);

+/*

+ * 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/UIEvents/UIEvent.h"

+

+namespace Swift {

+

+class RemoveRosterItemUIEvent : public UIEvent {

+ public:

+ RemoveRosterItemUIEvent(const JID& jid) : jid_(jid) {};

+ virtual ~RemoveRosterItemUIEvent() {};

+ JID getJID() {return jid_;};

+ private:

+ JID jid_;

+

+};

+

+}

+ class Roster;

+// virtual TreeWidget *getTreeWidget() = 0;

+ virtual void setRosterModel(Roster* model) = 0;

+ class UIEventStream;

+ virtual ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream) = 0;

+ class Roster;

+ virtual void setRosterModel(Roster* roster) = 0;

+ virtual void setRosterModel(Roster* /*roster*/) {};

+ class Roster;

+ MockMainWindow() {};

+ virtual void setRosterModel(Roster* roster) {this->roster = roster;};

+ Roster* roster;

+

+ MockMainWindowFactory() {};

+ virtual MainWindow* createMainWindow(UIEventStream*) {last = new MockMainWindow();return last;};

+ MockMainWindow* last;

+#include "Swiften/Roster/Roster.h"

+#include "Swiften/Roster/GroupRosterItem.h"

+#include "Swiften/Roster/ContactRosterItem.h"

+#define CHILDREN mainWindow_->roster->getRoot()->getChildren()

+ mainWindowFactory_ = new MockMainWindowFactory();

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickResolver_, presenceOracle_, eventController_, uiEventStream_, router_);

+ mainWindow_ = mainWindowFactory_->last;

+ GroupRosterItem* groupChild(size_t i) {

+ return dynamic_cast<GroupRosterItem*>(CHILDREN[i]);

+ }

+

+ CPPUNIT_ASSERT_EQUAL(2, (int)CHILDREN.size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)CHILDREN.size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)groupChild(0)->getChildren().size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)CHILDREN.size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)groupChild(0)->getChildren().size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)CHILDREN.size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)groupChild(0)->getChildren().size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)CHILDREN.size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)groupChild(0)->getChildren().size());

+ CPPUNIT_ASSERT_EQUAL(String("name"), groupChild(0)->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(1, (int)CHILDREN.size());

+ CPPUNIT_ASSERT_EQUAL(1, (int)groupChild(0)->getChildren().size());

+ CPPUNIT_ASSERT_EQUAL(String("NewName"), groupChild(0)->getChildren()[0]->getDisplayName());

+ MockMainWindowFactory* mainWindowFactory_;

+ MockMainWindow* mainWindow_;

+#undef children

+ expandAll();

+ class RosterItem;

+ virtual void show(RosterItem* item) = 0;

+#include "Swiften/Roster/ContactRosterItem.h"

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

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

+void QtRosterContextMenu::show(RosterItem* item) {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ if (!contact) {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item_);

+ assert(contact);

+ eventStream_->send(boost::shared_ptr<UIEvent>(new RemoveRosterItemUIEvent(contact->getJID())));

+ class RosterItem;

+ void show(RosterItem* item);

+ RosterItem* item_;

+#include "Swiften/Roster/Roster.h"

+QtChatWindow::QtChatWindow(const QString &contact, UIEventStream* eventStream) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageWasSystem_(false), eventStream_(eventStream) {

+ treeWidget_ = new QtTreeWidget(eventStream_);

+void QtChatWindow::setRosterModel(Roster* roster) {

+ treeWidget_->setRosterModel(roster);

+ class UIEventStream;

+ QtChatWindow(const QString &contact, UIEventStream* eventStream);

+// TreeWidget *getTreeWidget();

+ void setRosterModel(Roster* roster);

+ UIEventStream* eventStream_;

+QtChatWindowFactory::QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs) {

+ChatWindow* QtChatWindowFactory::createChatWindow(const JID &contact,UIEventStream* eventStream) {

+ QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), eventStream);

+#pragma once

+ class UIEventStream;

+ QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs);

+ ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);

+QtMainWindow::QtMainWindow(UIEventStream* uiEventStream) : QWidget() {

+ treeWidget_ = new QtTreeWidget(uiEventStream_);

+void QtMainWindow::setRosterModel(Roster* roster) {

+ treeWidget_->setRosterModel(roster);

+}

+

+ QtMainWindow(UIEventStream* eventStream);

+ void setRosterModel(Roster* roster);

+QtMainWindowFactory::QtMainWindowFactory() {

+ lastWindow_ = new QtMainWindow(eventStream);

+ QtMainWindowFactory();

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

+ rosterWindowFactory_ = new QtMainWindowFactory();

+ mainController_ = new MainController(chatWindowFactory_, rosterWindowFactory_, loginWindowFactory_, eventWindowFactory_, settings_, application_, systemTray_, soundPlayer_, xmlConsoleWidgetFactory_, chatListWindowFactory_, options.count("latency-debug") > 0);

+#include "Swiften/Roster/ContactRosterItem.h"

+#include "Swift/Controllers/UIEvents/UIEventStream.h"

+#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

+QtTreeWidget::QtTreeWidget(UIEventStream* eventStream, QWidget* parent) : QTreeView(parent) {

+ eventStream_ = eventStream;

+ model_ = new RosterModel(this);

+ delegate_ = new RosterDelegate(this);

+ expandAll();

+// connect(model_, SIGNAL(itemExpanded(const QModelIndex&, bool)), this, SLOT(handleModelItemExpanded(const QModelIndex&, bool)));

+// connect(model_, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(handleDataChanged(const QModelIndex&, const QModelIndex&)));

+// connect(this, SIGNAL(expanded(const QModelIndex&)), this, SLOT(handleExpanded(const QModelIndex&)));

+// connect(this, SIGNAL(collapsed(const QModelIndex&)), this, SLOT(handleCollapsed(const QModelIndex&)));

+void QtTreeWidget::setRosterModel(Roster* roster) {

+ model_->setRoster(roster);

+ expandAll();

+}

+

+ RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ if (contact) {

+ eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(contact->getJID())));

+ RosterItem* item = index.isValid() ? static_cast<RosterItem*>(index.internalPointer()) : NULL;

+ if (item) {

+ contextMenu_->show(item);

+//void QtTreeWidget::handleExpanded(const QModelIndex& index) {

+// QtTreeWidgetItem* qtItem = static_cast<QtTreeWidgetItem*>(index.internalPointer());

+// if (qtItem) {

+// qtItem->setExpanded(true);

+// }

+//}

+

+//void QtTreeWidget::handleCollapsed(const QModelIndex& index) {

+// QtTreeWidgetItem* qtItem = static_cast<QtTreeWidgetItem*>(index.internalPointer());

+// if (qtItem) {

+// qtItem->setExpanded(false);

+// }

+//}

+

+//void QtTreeWidget::handleModelItemExpanded(const QModelIndex& index, bool shouldExpand) {

+// if (this->isExpanded(index) == shouldExpand) {

+// return;

+// }

+// //setExpanded(index, shouldExpand);

+// if (shouldExpand) {

+// expand(index);

+// emit expanded(index);

+// } else {

+// collapse(index);

+// emit collapsed(index);

+// }

+//}

+

+// void QtTreeWidget::handleDataChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/) {

+// //in our model, this is only thrown with topLeft == bottomRight

+// if (!topLeft.isValid()) {

+// return;

+// }

+// QtTreeWidgetItem* qtItem = static_cast<QtTreeWidgetItem*>(topLeft.internalPointer());

+// if (qtItem) {

+// setExpanded(topLeft, qtItem->isExpanded());

+// //qDebug() << "Item changed, passing expanded state to view: " << qtItem->isExpanded() << " giving an expanded state of " << isExpanded(topLeft);

+// }

+

+// }

+class UIEventStream;

+class QtTreeWidget : public QTreeView{

+ QtTreeWidget(UIEventStream* eventStream, QWidget* parent = 0);

+ void setRosterModel(Roster* roster);

+// void handleModelItemExpanded(const QModelIndex&, bool expanded);

+// void handleExpanded(const QModelIndex&);

+// void handleCollapsed(const QModelIndex&);

+// void handleDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);

+ UIEventStream* eventStream_;

+#include "Swiften/Roster/ContactRosterItem.h"

+#include "Swiften/Roster/GroupRosterItem.h"

+

+#include "QtTreeWidget.h"

+#include "RosterModel.h"

+RosterDelegate::RosterDelegate(QtTreeWidget* tree) {

+ tree_ = tree;

+ RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

+ if (dynamic_cast<GroupRosterItem*>(item)) {

+QSize RosterDelegate::contactSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const {

+ RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

+ if (dynamic_cast<GroupRosterItem*>(item)) {

+ if (index.isValid()) {

+ groupDelegate_->paint(painter, option, index.data(Qt::DisplayRole).toString(), index.data(ChildCountRole).toInt(), tree_->isExpanded(index));

+ class QtTreeWidget;

+ RosterDelegate(QtTreeWidget* tree);

+ QtTreeWidget* tree_;

+#include <boost/bind.hpp>

+

+#include <QColor>

+#include <QIcon>

+#include <qdebug.h>

+

+#include "Swiften/Elements/StatusShow.h"

+#include "Swiften/Roster/ContactRosterItem.h"

+#include "Swiften/Roster/GroupRosterItem.h"

+

+#include "QtSwiftUtil.h"

+#include "Swift/QtUI/Roster/QtTreeWidget.h"

+

+RosterModel::RosterModel(QtTreeWidget* view) : view_(view) {

+ roster_ = NULL;

+void RosterModel::setRoster(Roster* roster) {

+ roster_ = roster;

+ if (!roster_) return;

+ roster->onChildrenChanged.connect(boost::bind(&RosterModel::handleChildrenChanged, this, _1));

+ roster->onDataChanged.connect(boost::bind(&RosterModel::handleDataChanged, this, _1));

+ roster->onGroupAdded.connect(boost::bind(&RosterModel::handleGroupAdded, this, _1));

+ emit layoutChanged();

+void RosterModel::handleGroupAdded(GroupRosterItem* group) {

+ view_->setExpanded(index(group), true);

+}

+

+void RosterModel::handleChildrenChanged(GroupRosterItem* /*group*/) {

+ emit layoutChanged();

+}

+

+void RosterModel::handleDataChanged(RosterItem* item) {

+ if (modelIndex.isValid()) {

+ //emit itemExpanded(modelIndex, item->isExpanded());

+ emit dataChanged(modelIndex, modelIndex);

+ }

+int RosterModel::columnCount(const QModelIndex& /*parent*/) const {

+RosterItem* RosterModel::getItem(const QModelIndex& index) const {

+ return index.isValid() ? static_cast<RosterItem*>(index.internalPointer()) : NULL;

+}

+

+ RosterItem* item = getItem(index);

+ if (!item) return QVariant();

+

+ switch (role) {

+ case Qt::DisplayRole: return P2QSTRING(item->getDisplayName());

+ case Qt::TextColorRole: return getTextColor(item);

+ case Qt::BackgroundColorRole: return getBackgroundColor(item);

+ case Qt::ToolTipRole: return getToolTip(item);

+ case StatusTextRole: return getStatusText(item);

+ case AvatarRole: return getAvatar(item);

+ case PresenceIconRole: return getPresenceIcon(item);

+ case ChildCountRole: return getChildCount(item);

+ default: return QVariant();

+ }

+int RosterModel::getChildCount(RosterItem* item) const {

+ GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item);

+ return group ? group->getDisplayedChildren().size() : 0;

+QColor RosterModel::intToColor(int color) const {

+ return QColor(

+ ((color & 0xFF0000)>>16),

+ ((color & 0xFF00)>>8),

+ (color & 0xFF));

+QColor RosterModel::getTextColor(RosterItem* item) const {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ int color = 0;

+ if (contact) {

+ switch (contact->getStatusShow()) {

+ case StatusShow::Online: color = 0x000000; break;

+ case StatusShow::Away: color = 0x336699; break;

+ case StatusShow::XA: color = 0x336699; break;

+ case StatusShow::FFC: color = 0x000000; break;

+ case StatusShow::DND: color = 0x990000; break;

+ case StatusShow::None: color = 0x7F7F7F;break;

+ }

+ return intToColor(color);

+}

+

+QColor RosterModel::getBackgroundColor(RosterItem* item) const {

+ return dynamic_cast<ContactRosterItem*>(item) ? intToColor(0xFFFFFF) : intToColor(0x969696);

+}

+

+QString RosterModel::getToolTip(RosterItem* item) const {

+ return dynamic_cast<ContactRosterItem*>(item) ? P2QSTRING(item->getDisplayName()) + "\n" + getStatusText(item) : P2QSTRING(item->getDisplayName());

+}

+

+QIcon RosterModel::getAvatar(RosterItem* item) const {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ if (!contact) return QIcon();

+ String path = contact->getAvatarPath();

+ return path.isEmpty() ? QIcon() : QIcon(P2QSTRING(path));

+}

+QString RosterModel::getStatusText(RosterItem* item) const {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ if (!contact) return "";

+ return P2QSTRING(contact->getStatusText());

+}

+QIcon RosterModel::getPresenceIcon(RosterItem* item) const {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

+ if (!contact) return QIcon();

+ QString iconString;

+ switch (contact->getStatusShow()) {

+ case StatusShow::Online: iconString = "online";break;

+ case StatusShow::Away: iconString = "away";break;

+ case StatusShow::XA: iconString = "away";break;

+ case StatusShow::FFC: iconString = "online";break;

+ case StatusShow::DND: iconString = "dnd";break;

+ case StatusShow::None: iconString = "offline";break;

+ }

+ return QIcon(":/icons/" + iconString + ".png");

+}

+

+

+QModelIndex RosterModel::index(int row, int column, const QModelIndex& parent) const {

+ GroupRosterItem* parentItem;

+ if (!parent.isValid()) {

+ //top level

+ parentItem = roster_->getRoot();

+ } else {

+ parentItem = dynamic_cast<GroupRosterItem*>(getItem(parent));

+ if (!parentItem) return QModelIndex();

+ }

+ return (size_t)row < parentItem->getDisplayedChildren().size() ? createIndex(row, column, parentItem->getDisplayedChildren()[row]) : QModelIndex();

+}

+

+QModelIndex RosterModel::index(RosterItem* item) const {

+ GroupRosterItem* parent = item->getParent();

+ for (size_t i = 0; i < parent->getDisplayedChildren().size(); i++) {

+ if (parent->getDisplayedChildren()[i] == item) {

+ return createIndex(i, 0, item);

+ }

+ }

+ return QModelIndex();

+}

+

+QModelIndex RosterModel::parent(const QModelIndex& child) const {

+ if (!child.isValid()) {

+ return QModelIndex();

+ }

+

+ GroupRosterItem* parent = getItem(child)->getParent();

+ return (parent != roster_->getRoot()) ? index(parent) : QModelIndex();

+ if (!roster_) return 0;

+ RosterItem* item = parent.isValid() ? static_cast<RosterItem*>(parent.internalPointer()) : roster_->getRoot();

+ GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item);

+ int count = group ? group->getDisplayedChildren().size() : 0;

+ qDebug() << "rowCount = " << count << " where parent.isValid() == " << parent.isValid() << ", group == " << (group ? P2QSTRING(group->getDisplayName()) : "*contact*");

+ return count;

+#include "Swiften/Roster/Roster.h"

+ enum RosterRoles {

+ StatusTextRole = Qt::UserRole,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2,

+ StatusShowTypeRole = Qt::UserRole + 3,

+ ChildCountRole = Qt::UserRole + 4,

+ };

+ class QtTreeWidget;

+

+ class RosterModel : public QAbstractItemModel {

+ Q_OBJECT

+ public:

+ RosterModel(QtTreeWidget* view);

+ ~RosterModel();

+ void setRoster(Roster* swiftRoster);

+ int columnCount(const QModelIndex& parent = QModelIndex()) const;

+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

+ QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;

+ QModelIndex index(RosterItem* item) const;

+ QModelIndex parent(const QModelIndex& index) const;

+ int rowCount(const QModelIndex& parent = QModelIndex()) const;

+ private:

+ void handleDataChanged(RosterItem* item);

+ void handleChildrenChanged(GroupRosterItem* item);

+ void handleGroupAdded(GroupRosterItem* group);

+ RosterItem* getItem(const QModelIndex& index) const;

+ QColor intToColor(int color) const;

+ QColor getTextColor(RosterItem* item) const;

+ QColor getBackgroundColor(RosterItem* item) const;

+ QString getToolTip(RosterItem* item) const;

+ QIcon getAvatar(RosterItem* item) const;

+ QString getStatusText(RosterItem* item) const;

+ QIcon getPresenceIcon(RosterItem* item) const;

+ int getChildCount(RosterItem* item) const;

+ Roster* roster_;

+ QtTreeWidget* view_;

+ };

+# "Roster/QtTreeWidgetItem.cpp",

+ contact->clearPresence();

+ * Copyright (c) 2010 Kevin Smith

+ContactRosterItem::ContactRosterItem(const JID& jid, const String& name, GroupRosterItem* parent) : RosterItem(name, parent), jid_(jid) {

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

+String ContactRosterItem::getStatusText() const {

+ return shownPresence_ ? shownPresence_->getStatus() : "";

+ avatarPath_ = path;

+ onDataChanged();

+}

+const String& ContactRosterItem::getAvatarPath() const {

+ return avatarPath_;

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

+void ContactRosterItem::applyPresence(const String& resource, boost::shared_ptr<Presence> presence) {

+ if (offlinePresence_) {

+ offlinePresence_ = boost::shared_ptr<Presence>();

+ }

+ if (presence->getType() == Presence::Unavailable) {

+ if (presences_.find(resource) != presences_.end()) {

+ presences_.erase(resource);

+ }

+ if (presences_.size() > 0) {

+ offlinePresence_ = presence;

+ }

+ } else {

+ presences_[resource] = presence;

+ }

+ calculateShownPresence();

+ onDataChanged();

+ * Copyright (c) 2010 Kevin Smith

+#pragma once

+#include "Swiften/Elements/Presence.h"

+#include <map>

+ ContactRosterItem(const JID& jid, const String& name, GroupRosterItem* parent);

+ virtual ~ContactRosterItem();

+ StatusShow::Type getStatusShow() const;

+ StatusShow::Type getSimplifiedStatusShow() const;

+ String getStatusText() const;

+ const String& getAvatarPath() const;

+ void applyPresence(const String& resource, boost::shared_ptr<Presence> presence);

+ void clearPresence();

+ void calculateShownPresence();

+ String avatarPath_;

+ bool hidden_;

+ std::map<String, boost::shared_ptr<Presence> > presences_;

+ boost::shared_ptr<Presence> offlinePresence_;

+ boost::shared_ptr<Presence> shownPresence_;

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swiften/Roster/GroupRosterItem.h"

+

+#include <boost/bind.hpp>

+#include <iostream>

+

+namespace Swift {

+

+GroupRosterItem::GroupRosterItem(const String& name, GroupRosterItem* parent) : RosterItem(name, parent) {

+

+}

+

+GroupRosterItem::~GroupRosterItem() {

+

+}

+

+const std::vector<RosterItem*>& GroupRosterItem::getChildren() const {

+ return children_;

+}

+

+const std::vector<RosterItem*>& GroupRosterItem::getDisplayedChildren() const {

+// std::cout << "Fetching displayed children for " << getDisplayName() << " and found " << displayedChildren_.size() << std::endl;

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

+ }

+ onChildrenChanged();

+ onDataChanged();

+}

+

+/**

+ * 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;

+}

+

+void GroupRosterItem::sortDisplayed() {

+ std::stable_sort(displayedChildren_.begin(), displayedChildren_.end(), itemLessThan);

+}

+

+bool GroupRosterItem::itemLessThan(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());

+ }

+ onDataChanged();

+ 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()) {

+ onDataChanged();

+ onChildrenChanged();

+ }

+}

+

+

+}

+ * Copyright (c) 2010 Kevin Smith

+#pragma once

+#include <vector>

+ GroupRosterItem(const String& name, GroupRosterItem* parent);

+ virtual ~GroupRosterItem();

+ const std::vector<RosterItem*>& getChildren() const;

+ const std::vector<RosterItem*>& getDisplayedChildren() const;

+ void addChild(RosterItem* item);

+ ContactRosterItem* removeChild(const JID& jid);

+ void setDisplayed(RosterItem* item, bool displayed);

+ boost::signal<void ()> onChildrenChanged;

+ static bool itemLessThan(const RosterItem* left, const RosterItem* right);

+ void handleChildrenChanged(GroupRosterItem* group);

+ void sortDisplayed();

+ std::vector<RosterItem*> children_;

+ std::vector<RosterItem*> displayedChildren_;

+#include <iostream>

+Roster::Roster() {

+ root_ = new GroupRosterItem("Dummy-Root", NULL);

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

+ }

+GroupRosterItem* Roster::getRoot() {

+ return root_;

+ foreach (RosterItem *item, root_->getChildren()) {

+ if (group && group->getDisplayName() == groupName) {

+ GroupRosterItem* group = new GroupRosterItem(groupName, root_);

+ root_->addChild(group);

+// std::cout << "Added " << groupName << " to root" << std::endl;

+ group->onChildrenChanged.connect(boost::bind(&Roster::handleChildrenChanged, this, group));

+ group->onDataChanged.connect(boost::bind(&Roster::handleDataChanged, this, group));

+void Roster::handleDataChanged(RosterItem* item) {

+ onDataChanged(item);

+void Roster::handleChildrenChanged(GroupRosterItem* item) {

+ onChildrenChanged(item);

+}

+void Roster::addContact(const JID& jid, const String& name, const String& groupName) {

+ GroupRosterItem* group(getGroup(groupName));

+ ContactRosterItem *item = new ContactRosterItem(jid, name, group);

+ group->addChild(item);

+ itemMap_[jid.toBare()].push_back(item);

+ item->onDataChanged.connect(boost::bind(&Roster::handleDataChanged, this, item));

+ filterContact(item, group);

+

+ std::vector<ContactRosterItem*> items = itemMap_[jid.toBare()];

+ std::vector<ContactRosterItem*>::iterator it = items.begin();

+ while (it != items.end()) {

+ if (jid == (*it)->getJID()) {

+ it = items.erase(it);

+ if (items.size() == 0) {

+ itemMap_.erase(jid.toBare());

+ }

+ //Causes the delete

+ root_->removeChild(jid);

+ std::vector<RosterItem*> children = root_->getChildren();

+ std::vector<RosterItem*>::iterator it = children.begin();

+ while (it != children.end()) {

+ if (group && group->getDisplayName() == groupName) {

+ ContactRosterItem* deleted = group->removeChild(jid);

+ std::vector<ContactRosterItem*> items = itemMap_[jid.toBare()];

+ items.erase(std::remove(items.begin(), items.end(), deleted), items.end());

+ foreach (ContactRosterItem* item, itemMap_[jid.toBare()]) {

+ filterContact(item, item->getParent());

+ std::deque<RosterItem*> queue;

+ queue.push_back(root_);

+void Roster::filterContact(ContactRosterItem* contact, GroupRosterItem* group) {

+ int oldDisplayedSize = group->getDisplayedChildren().size();

+ hide &= (*filter)(contact);

+ }

+ group->setDisplayed(contact, filters_.size() == 0 || !hide);

+ int newDisplayedSize = group->getDisplayedChildren().size();

+// std::cout << ", new size = " << newDisplayedSize << std::endl;

+ if (oldDisplayedSize == 0 && newDisplayedSize > 0) {

+// std::cout << "Newly created" << std::endl;

+ onGroupAdded(group);

+ }

+}

+

+void Roster::filterGroup(GroupRosterItem* group) {

+ foreach (RosterItem* child, group->getChildren()) {

+ ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(child);

+ if (contact) {

+ filterContact(contact, group);

+ }

+ std::deque<RosterItem*> queue;

+ queue.push_back(root_);

+ filterGroup(group);

+class ContactRosterItem;

+ Roster();

+ void addFilter(RosterFilter *filter) {filters_.push_back(filter);filterAll();};

+ GroupRosterItem* getRoot();

+ std::vector<RosterFilter*> getFilters() {return filters_;};

+ boost::signal<void (GroupRosterItem*)> onChildrenChanged;

+ boost::signal<void (GroupRosterItem*)> onGroupAdded;

+ boost::signal<void (RosterItem*)> onDataChanged;

+ GroupRosterItem* getGroup(const String& groupName);

+ void handleDataChanged(RosterItem* item);

+ void handleChildrenChanged(GroupRosterItem* item);

+ void filterGroup(GroupRosterItem* item);

+ void filterContact(ContactRosterItem* contact, GroupRosterItem* group);

+ GroupRosterItem* root_;

+ std::map<JID, std::vector<ContactRosterItem*> > itemMap_;

+/*

+ * Copyright (c) 2010 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swiften/Roster/RosterItem.h"

+

+#include "Swiften/Roster/GroupRosterItem.h"

+

+namespace Swift {

+

+RosterItem::RosterItem(const String& name, GroupRosterItem* parent) : name_(name), 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_;

+}

+

+

+}

+

+ * Copyright (c) 2010 Kevin Smith

+#pragma once

+#include "Swiften/Base/String.h"

+namespace Swift {

+class GroupRosterItem;

+ 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_;

+ /**

+ * 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.

+ */

+ contact->setDisplayName(name_);

+#pragma once

+ contact->applyPresence(presence_->getFrom().getResource(), presence_);

+#include "Swiften/Roster/GroupRosterItem.h"

+ roster_ = new Roster();

+ CPPUNIT_ASSERT_EQUAL(2, (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"), ((GroupRosterItem*)roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(String("Cookie"), ((GroupRosterItem*)roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

+ CPPUNIT_ASSERT_EQUAL(String("Ernie"), ((GroupRosterItem*)roster_->getRoot()->getChildren()[1])->getChildren()[0]->getDisplayName());

+

+ "Roster/GroupRosterItem.cpp",

+ "Roster/RosterItem.cpp",