/*

* Copyright (c) 2010-2012 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/Controllers/Chat/ChatController.h"

#include <boost/bind.hpp>

#include <stdio.h>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Chat/ChatStateNotifier.h>

#include <Swiften/Chat/ChatStateTracker.h>

#include <Swiften/Client/StanzaChannel.h>

me = true;

}

} else if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {

me = true;

}

if (!me) {

return;

}

if (!newPresence) {

newPresence->setType(Presence::Unavailable);

}

lastShownStatus_ = newPresence->getShow();

chatStateTracker_->handlePresenceChange(newPresence);

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

std::string newStatusChangeString = getStatusChangeString(newPresence);

if (newStatusChangeString != lastStatusChangeString_) {

if (lastWasPresence_) {

*/

#include "Swift/Controllers/Chat/ChatControllerBase.h"

#include <sstream>

#include <map>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

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

#include <boost/algorithm/string.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/String.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

if (labelsEnabled_) {

SecurityLabelsCatalog::Item labelItem = chatWindow_->getSelectedSecurityLabel();

if (labelItem.getLabel()) {

message->addPayload(labelItem.getLabel());

}

}

preSendMessageRequest(message);

if (useDelayForLatency_) {

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

}

if (isCorrectionMessage) {

message->addPayload(boost::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

}

message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

stanzaChannel_->sendMessage(message);

postSendMessage(message->getBody(), boost::dynamic_pointer_cast<Stanza>(message));

onActivity(message->getBody());

}

* Copyright (c) 2010-2011 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/Controllers/Chat/ChatsManager.h"

#include <boost/bind.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Base/foreach.h>

#include <Swift/Controllers/Chat/ChatController.h>

#include <Swift/Controllers/Chat/ChatControllerBase.h>

#include <Swift/Controllers/Chat/MUCSearchController.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

#include <Swift/Controllers/Chat/MUCController.h>

#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

settings_(settings) {

timerFactory_ = timerFactory;

eventController_ = eventController;

stanzaChannel_ = stanzaChannel;

iqRouter_ = iqRouter;

chatWindowFactory_ = chatWindowFactory;

nickResolver_ = nickResolver;

presenceOracle_ = presenceOracle;

avatarManager_ = NULL;

presenceSender_ = presenceSender;

uiEventStream_ = uiEventStream;

mucBookmarkManager_ = NULL;

profileSettings_ = profileSettings;

presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));

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

chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);

chatListWindow_->onMUCBookmarkActivated.connect(boost::bind(&ChatsManager::handleMUCBookmarkActivated, this, _1));

iqRouter_ = new IQRouter(iqChannel_);

capsProvider_ = new DummyCapsProvider();

eventController_ = new EventController();

chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, NULL, mucRegistry_);

presenceOracle_ = new PresenceOracle(stanzaChannel_);

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

uiEventStream_ = new UIEventStream();

entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

profileSettings_ = new ProfileSettingsProvider("a", settings_);

}

/**

* Test that MUC PMs get opened in the right windows

*/

void testThreeMUCWindows() {

JID muc("testling@test.com");

ChatWindow* mucWindow = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc, uiEventStream_).Return(mucWindow);

std::string messageJIDString1("testling@test.com/1");

ChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

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

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

std::string messageJIDString2("testling@test.com/2");

ChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include <Swift/Controllers/Chat/UserSearchController.h>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swift/Controllers/ContactEditController.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIEvents/RequestChatWithUserDialogUIEvent.h>

&& identity.getType() == "user")) {

//isUserDirectory = true;

}

}

std::vector<std::string> features = info->getFeatures();

supports55 = std::find(features.begin(), features.end(), DiscoInfo::JabberSearchFeature) != features.end();

if (/*isUserDirectory && */supports55) { //FIXME: once M-Link correctly advertises directoryness.

/* Abort further searches.*/

endDiscoWalker();

searchRequest->onResponse.connect(boost::bind(&UserSearchController::handleFormResponse, this, _1, _2));

searchRequest->send();

}

}

void UserSearchController::handleFormResponse(boost::shared_ptr<SearchPayload> fields, ErrorPayload::ref error) {

if (error || !fields) {

window_->setServerSupportsSearch(false);

return;

void MainController::sendPresence(boost::shared_ptr<Presence> presence) {

rosterController_->getWindow()->setMyStatusType(presence->getShow());

rosterController_->getWindow()->setMyStatusText(presence->getStatus());

systemTrayController_->setMyStatusType(presence->getShow());

notifier_->setTemporarilyDisabled(presence->getShow() == StatusShow::DND);

// Add information and send

if (!vCardPhotoHash_.empty()) {

}

client_->getPresenceSender()->sendPresence(presence);

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

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!statusTracker_) {

if (!offlineRequested_) {

setReconnectTimer();

}

if (lastDisconnectError_) {

message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % boost::lexical_cast<std::string>(timeBeforeNextReconnect_));

lastDisconnectError_->conclude();

} else {

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%.")) % jid_.getDomain() % message);

}

eventController_->handleIncomingEvent(lastDisconnectError_);

}

}

}

else if (!rosterController_) { //hasn't been logged in yet

loginWindow_->setIsLoggingIn(false);

}

}

sendPresence(statusTracker_->getNextPresence());

}

}

}

void MainController::handleNotificationClicked(const JID& jid) {

assert(chatsManager_);

if (clientInitialized_) {

if (client_->getMUCRegistry()->isMUC(jid)) {

}

else {

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(jid)));

}

}

}

void MainController::handleQuitRequest() {

if (client_ && client_->isActive()) {

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->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(std::string("Ernie"), children[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Bert"), children[1]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Bird"), children[2]->getDisplayName());

presence->setFrom(jid4c);

presence->setType(Presence::Unavailable);

roster_->removeContact(jid4c);

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

}

void testReSortLikeMUC() {

JID jid4a("a@b/c");

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/Controllers/StatusTracker.h"

namespace Swift {

StatusTracker::StatusTracker() {

isAutoAway_ = false;

}

boost::shared_ptr<Presence> StatusTracker::getNextPresence() {

boost::shared_ptr<Presence> presence;

if (isAutoAway_) {

presence->setShow(StatusShow::Away);

presence->setStatus(queuedPresence_->getStatus());

} else {

presence = queuedPresence_;

}

return presence;

}

void StatusTracker::setRequestedPresence(boost::shared_ptr<Presence> presence) {

isAutoAway_ = false;

queuedPresence_ = presence;

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

// }

}

bool StatusTracker::goAutoAway() {

if (queuedPresence_->getShow() != StatusShow::Online) {

return false;

}

isAutoAway_ = true;

return true;