theirPresence = presenceOracle->getLastPresence(contact);

} else {

startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());

}

Idle::ref idle;

if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {

if (isInMUC_) {

presence = presenceOracle_->getLastPresence(jid);

} else {

}

chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);

handleBareJIDCapsChanged(toJID_);

}

void ChatController::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

}

return;

}

if (!newPresence) {

newPresence = boost::make_shared<Presence>();

newPresence->setType(Presence::Unavailable);

if (avatarManager_) {

fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);

}

fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;

}

return fixedChat;

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);

}

// presence lookup

if (presence) {

contact->statusType = presence->getShow();

} else {

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

foreach(const XMPPRosterItem& rosterItem, rosterItems) {

Contact::ref contact = boost::make_shared<Contact>(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");

contact->avatarPath = avatarManager_->getAvatarPath(contact->jid);

results.push_back(contact);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/date_time/posix_time/posix_time.hpp>

#include <Swiften/Base/DateTime.h>

#include <Swiften/Elements/Idle.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

}

StatusShow::Type ContactRosterItem::getStatusShow() const {

}

StatusShow::Type ContactRosterItem::getSimplifiedStatusShow() const {

case StatusShow::Online: return StatusShow::Online;

case StatusShow::Away: return StatusShow::Away;

case StatusShow::XA: return StatusShow::Away;

}

std::string ContactRosterItem::getStatusText() const {

}

std::string ContactRosterItem::getIdleText() const {

if (!idle || idle->getSince().is_not_a_date_time()) {

return "";

} else {

}

std::string ContactRosterItem::getOfflineSinceText() const {

return dateTimeToLocalString(*delay);

}

}

typedef std::pair<std::string, boost::shared_ptr<Presence> > StringPresencePair;

void ContactRosterItem::clearPresence() {

onDataChanged();

}

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

onDataChanged();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <set>

#include <string>

#include <boost/bind.hpp>

#include <boost/date_time/posix_time/ptime.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

void setDisplayJID(const JID& jid);

const JID& getDisplayJID() const;

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

const std::vector<std::string>& getGroups() const;

/** Only used so a contact can know about the groups it's in*/

void addGroup(const std::string& group);

void removeGroup(const std::string& group);

MUCOccupant::Role getMUCRole() const;

void setMUCRole(const MUCOccupant::Role& role);

JID displayJID_;

boost::posix_time::ptime lastAvailableTime_;

boost::filesystem::path avatarPath_;

std::vector<std::string> groups_;

MUCOccupant::Role mucRole_;

MUCOccupant::Affiliation mucAffiliation_;

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

xmppRoster_->onRosterCleared.connect(boost::bind(&RosterController::handleRosterCleared, this));

subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&RosterController::handleSubscriptionRequest, this, _1, _2));

uiEventConnection_ = uiEventStream->onUIEvent.connect(boost::bind(&RosterController::handleUIEvent, this, _1));

vcardManager_->onOwnVCardChanged.connect(boost::bind(&RosterController::handleOwnVCardChanged, this, _1));

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

return;

}

}

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

ownContact_->applyPresence(std::string(), presence);

mainWindow_->setMyContactRosterItem(ownContact_);

}

}

boost::optional<XMPPRosterItem> RosterController::getItem(const JID& jid) const {

groups.push_back("testGroup1");

JID from("test@testdomain.com");

xmppRoster_->addContact(from, "name", groups, RosterItemPayload::Both);

Presence::ref lowPresence(new Presence());

lowPresence->setFrom(withResource(from, "bob"));

lowPresence->setPriority(2);

lowPresence->setStatus("Not here");

Presence::ref highPresence(new Presence());

highPresence->setFrom(withResource(from, "bert"));

highPresence->setPriority(10);

Presence::ref highPresenceOffline(new Presence());

highPresenceOffline->setFrom(withResource(from, "bert"));

highPresenceOffline->setType(Presence::Unavailable);

stanzaChannel_->onPresenceReceived(lowPresence);

stanzaChannel_->onPresenceReceived(highPresence);

stanzaChannel_->onPresenceReceived(highPresenceOffline);

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(lowPresence->getStatus(), item->getStatusText());

stanzaChannel_->onPresenceReceived(lowPresenceOffline);

item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

/* A verification that if the test fails, it's the RosterController, not the PresenceOracle. */

CPPUNIT_ASSERT_EQUAL(StatusShow::None, item->getStatusShow());

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), item->getStatusText());

}