+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, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry), eventStream_(eventStream), userWantsReceipts_(userWantsReceipts), settings_(settings) {

+void ChatController::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool /* isIncoming */) {

+ HistoryMessage::Type type;

+ if (mucRegistry_->isMUC(fromJID.toBare()) || mucRegistry_->isMUC(toJID.toBare())) {

+ type = HistoryMessage::PrivateMessage;

+ }

+ else {

+ type = HistoryMessage::Chat;

+ }

+

+ if (historyController_) {

+ historyController_->addMessage(message, fromJID, toJID, type, timeStamp);

+ }

+}

+

+ class HistoryController;

+ 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, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry);

+ void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming);

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry) {

+

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

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ logMessage(body, selfJID_, toJID_, now, false);

+#endif

+

+ logMessage(body, from, selfJID_, timeStamp, true);

+#include <Swift/Controllers/HistoryController.h>

+#include <Swiften/MUC/MUCRegistry.h>

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry);

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) = 0;

+ HistoryController* historyController_;

+ MUCRegistry* mucRegistry_;

+ SettingsProvider* settings,

+ HistoryController* historyController) :

+ settings_(settings),

+ historyController_(historyController) {

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_);

+ MUCController* controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_);

+ class HistoryController;

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_);

+ HistoryController* historyController_;

+ XMPPRoster* roster,

+ HistoryController* historyController,

+ MUCRegistry* mucRegistry) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry), muc_(muc), nick_(nick), desiredNick_(nick), password_(password) {

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ if (lastActivity_ == boost::posix_time::not_a_date_time && historyController_) {

+ lastActivity_ = historyController_->getLastTimeStampFromMUC(selfJID_, toJID_);

+ muc_->joinWithContextSince(nick_, lastActivity_);

+#else

+ muc_->joinAs(nick_);

+#endif

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ addRecentLogs();

+#endif

+

+ checkDuplicates(message);

+void MUCController::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) {

+ // log only incoming messages

+ if (isIncoming && historyController_) {

+ historyController_->addMessage(message, fromJID, toJID, HistoryMessage::Groupchat, timeStamp);

+ }

+}

+

+void MUCController::addRecentLogs() {

+ if (!historyController_) {

+ return;

+ }

+

+ joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);

+

+ foreach (const HistoryMessage& message, joinContext_) {

+ bool senderIsSelf = nick_ == message.getFromJID().getResource();

+

+ // the chatWindow uses utc timestamps

+ addMessage(message.getMessage(), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, boost::shared_ptr<SecurityLabel>(new SecurityLabel()), std::string(avatarManager_->getAvatarPath(message.getFromJID()).string()), message.getTime() - boost::posix_time::hours(message.getOffset()));

+ }

+}

+

+void MUCController::checkDuplicates(boost::shared_ptr<Message> newMessage) {

+ std::string body = newMessage->getBody();

+ JID jid = newMessage->getFrom();

+ boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();

+

+ reverse_foreach (const HistoryMessage& message, joinContext_) {

+ boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());

+ if (time && time < messageTime) {

+ break;

+ }

+ if (time && time != messageTime) {

+ continue;

+ }

+ if (message.getFromJID() != jid) {

+ continue;

+ }

+ if (message.getMessage() != body) {

+ continue;

+ }

+

+ // Mark the message as unreadable

+ newMessage->setBody("");

+ }

+}

+

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry);

+ void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming);

+ void addRecentLogs();

+ void checkDuplicates(boost::shared_ptr<Message> newMessage);

+ std::vector<HistoryMessage> joinContext_;

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL);

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, NULL, NULL, mucRegistry_);

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swift/Controllers/HistoryController.h>

+#include <Swiften/History/HistoryStorage.h>

+#include <Swiften/History/HistoryMessage.h>

+#include <boost/date_time/c_local_time_adjustor.hpp>

+

+namespace Swift {

+

+HistoryController::HistoryController(HistoryStorage* localHistoryStorage) : localHistory_(localHistoryStorage) {

+}

+

+HistoryController::~HistoryController() {

+}

+

+void HistoryController::addMessage(const std::string& message, const JID& fromJID, const JID& toJID, HistoryMessage::Type type, const boost::posix_time::ptime& timeStamp) {

+ // note: using localtime timestamps

+ boost::posix_time::ptime localTime = boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local(timeStamp);

+ int offset = (localTime - timeStamp).hours();

+

+ HistoryMessage historyMessage(message, fromJID, toJID, type, localTime, offset);

+

+ localHistory_->addMessage(historyMessage);

+ onNewMessage(historyMessage);

+}

+

+std::vector<HistoryMessage> HistoryController::getMessagesFromDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const {

+ return localHistory_->getMessagesFromDate(selfJID, contactJID, type, date);

+}

+

+std::vector<HistoryMessage> HistoryController::getMUCContext(const JID& selfJID, const JID& mucJID, const boost::posix_time::ptime& timeStamp) const {

+ boost::posix_time::ptime localTime = boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local(timeStamp);

+ return getMessagesFromDate(selfJID, mucJID, HistoryMessage::Groupchat, localTime.date());

+}

+

+std::vector<HistoryMessage> HistoryController::getMessagesFromPreviousDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const {

+ return localHistory_->getMessagesFromPreviousDate(selfJID, contactJID, type, date);

+}

+

+std::vector<HistoryMessage> HistoryController::getMessagesFromNextDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const {

+ return localHistory_->getMessagesFromNextDate(selfJID, contactJID, type, date);

+}

+

+ContactsMap HistoryController::getContacts(const JID& selfJID, HistoryMessage::Type type, const std::string& keyword) const {

+ return localHistory_->getContacts(selfJID, type, keyword);

+}

+

+boost::posix_time::ptime HistoryController::getLastTimeStampFromMUC(const JID& selfJID, const JID& mucJID) {

+ return localHistory_->getLastTimeStampFromMUC(selfJID, mucJID);

+}

+

+}

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/JID/JID.h>

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

+#include <vector>

+#include <set>

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/History/HistoryMessage.h>

+#include <Swiften/History/HistoryStorage.h>

+

+namespace Swift {

+ class JID;

+

+ class HistoryController {

+ public:

+ HistoryController(HistoryStorage* localHistoryStorage);

+ ~HistoryController();

+

+ void addMessage(const std::string& message, const JID& fromJID, const JID& toJID, HistoryMessage::Type type, const boost::posix_time::ptime& timeStamp);

+ std::vector<HistoryMessage> getMessagesFromDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const;

+ std::vector<HistoryMessage> getMessagesFromPreviousDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const;

+ std::vector<HistoryMessage> getMessagesFromNextDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const;

+ ContactsMap getContacts(const JID& selfJID, HistoryMessage::Type type, const std::string& keyword = std::string()) const;

+ std::vector<HistoryMessage> getMUCContext(const JID& selfJID, const JID& mucJID, const boost::posix_time::ptime& timeStamp) const;

+

+ boost::posix_time::ptime getLastTimeStampFromMUC(const JID& selfJID, const JID& mucJID);

+

+ boost::signal<void (const HistoryMessage&)> onNewMessage;

+

+ private:

+ HistoryStorage* localHistory_;

+ bool remoteArchiveSupported_;

+ };

+}

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swift/Controllers/HistoryViewController.h>

+

+#include <Swift/Controllers/UIInterfaces/HistoryWindowFactory.h>

+#include <Swift/Controllers/UIEvents/RequestHistoryUIEvent.h>

+#include <Swift/Controllers/HistoryController.h>

+#include <Swiften/History/HistoryMessage.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swift/Controllers/Roster/SetPresence.h>

+#include <Swift/Controllers/Roster/SetAvatar.h>

+

+namespace Swift {

+ static const std::string category[] = { "Contacts", "MUC", "Contacts" };

+

+HistoryViewController::HistoryViewController(

+ const JID& selfJID,

+ UIEventStream* uiEventStream,

+ HistoryController* historyController,

+ NickResolver* nickResolver,

+ AvatarManager* avatarManager,

+ PresenceOracle* presenceOracle,

+ HistoryWindowFactory* historyWindowFactory) :

+ selfJID_(selfJID),

+ uiEventStream_(uiEventStream),

+ historyController_(historyController),

+ nickResolver_(nickResolver),

+ avatarManager_(avatarManager),

+ presenceOracle_(presenceOracle),

+ historyWindowFactory_(historyWindowFactory),

+ historyWindow_(NULL),

+ selectedItem_(NULL),

+ currentResultDate_(boost::gregorian::not_a_date_time) {

+ uiEventStream_->onUIEvent.connect(boost::bind(&HistoryViewController::handleUIEvent, this, _1));

+

+ roster_ = new Roster(false, true);

+}

+

+HistoryViewController::~HistoryViewController() {

+ uiEventStream_->onUIEvent.disconnect(boost::bind(&HistoryViewController::handleUIEvent, this, _1));

+ if (historyWindow_) {

+ historyWindow_->onSelectedContactChanged.disconnect(boost::bind(&HistoryViewController::handleSelectedContactChanged, this, _1));

+ historyWindow_->onReturnPressed.disconnect(boost::bind(&HistoryViewController::handleReturnPressed, this, _1));

+ historyWindow_->onScrollReachedTop.disconnect(boost::bind(&HistoryViewController::handleScrollReachedTop, this, _1));

+ historyWindow_->onScrollReachedBottom.disconnect(boost::bind(&HistoryViewController::handleScrollReachedBottom, this, _1));

+ historyWindow_->onPreviousButtonClicked.disconnect(boost::bind(&HistoryViewController::handlePreviousButtonClicked, this));

+ historyWindow_->onNextButtonClicked.disconnect(boost::bind(&HistoryViewController::handleNextButtonClicked, this));

+ historyWindow_->onCalendarClicked.disconnect(boost::bind(&HistoryViewController::handleCalendarClicked, this, _1));

+ historyController_->onNewMessage.disconnect(boost::bind(&HistoryViewController::handleNewMessage, this, _1));

+

+ presenceOracle_->onPresenceChange.disconnect(boost::bind(&HistoryViewController::handlePresenceChanged, this, _1));

+ avatarManager_->onAvatarChanged.disconnect(boost::bind(&HistoryViewController::handleAvatarChanged, this, _1));

+

+ delete historyWindow_;

+ }

+ delete roster_;

+}

+

+void HistoryViewController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

+ boost::shared_ptr<RequestHistoryUIEvent> event = boost::dynamic_pointer_cast<RequestHistoryUIEvent>(rawEvent);

+ if (event != NULL) {

+ if (historyWindow_ == NULL) {

+ historyWindow_ = historyWindowFactory_->createHistoryWindow(uiEventStream_);

+ historyWindow_->onSelectedContactChanged.connect(boost::bind(&HistoryViewController::handleSelectedContactChanged, this, _1));

+ historyWindow_->onReturnPressed.connect(boost::bind(&HistoryViewController::handleReturnPressed, this, _1));

+ historyWindow_->onScrollReachedTop.connect(boost::bind(&HistoryViewController::handleScrollReachedTop, this, _1));

+ historyWindow_->onScrollReachedBottom.connect(boost::bind(&HistoryViewController::handleScrollReachedBottom, this, _1));

+ historyWindow_->onPreviousButtonClicked.connect(boost::bind(&HistoryViewController::handlePreviousButtonClicked, this));

+ historyWindow_->onNextButtonClicked.connect(boost::bind(&HistoryViewController::handleNextButtonClicked, this));

+ historyWindow_->onCalendarClicked.connect(boost::bind(&HistoryViewController::handleCalendarClicked, this, _1));

+ historyController_->onNewMessage.connect(boost::bind(&HistoryViewController::handleNewMessage, this, _1));

+

+ presenceOracle_->onPresenceChange.connect(boost::bind(&HistoryViewController::handlePresenceChanged, this, _1));

+ avatarManager_->onAvatarChanged.connect(boost::bind(&HistoryViewController::handleAvatarChanged, this, _1));

+

+ historyWindow_->setRosterModel(roster_);

+ }

+

+ // populate roster by doing an empty search

+ handleReturnPressed(std::string());

+

+ historyWindow_->activate();

+ }

+}

+

+void HistoryViewController::handleSelectedContactChanged(RosterItem* newContact) {

+ // FIXME: signal is triggerd twice.

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

+

+ if (contact && selectedItem_ != contact) {

+ selectedItem_ = contact;

+ historyWindow_->resetConversationView();

+ }

+ else {

+ return;

+ }

+

+ JID contactJID = contact->getJID();

+

+ std::vector<HistoryMessage> messages;

+ for (int it = HistoryMessage::Chat; it <= HistoryMessage::PrivateMessage; it++) {

+ HistoryMessage::Type type = static_cast<HistoryMessage::Type>(it);

+

+ if (contacts_[type].count(contactJID)) {

+ currentResultDate_ = *contacts_[type][contactJID].rbegin();

+ selectedItemType_ = type;

+ messages = historyController_->getMessagesFromDate(selfJID_, contactJID, type, currentResultDate_);

+ }

+ }

+

+ historyWindow_->setDate(currentResultDate_);

+

+ foreach (const HistoryMessage& message, messages) {

+ addNewMessage(message, false);

+ }

+}

+

+void HistoryViewController::handleNewMessage(const HistoryMessage& message) {

+ JID contactJID = message.getFromJID().toBare() == selfJID_ ? message.getToJID() : message.getFromJID();

+

+ JID displayJID;

+ if (message.getType() == HistoryMessage::PrivateMessage) {

+ displayJID = contactJID;

+ }

+ else {

+ displayJID = contactJID.toBare();

+ }

+

+ // check current conversation

+ if (selectedItem_ && selectedItem_->getJID() == displayJID) {

+ if (historyWindow_->getLastVisibleDate() == message.getTime().date()) {

+ addNewMessage(message, false);

+ }

+ }

+

+ // check if the new message matches the query

+ if (message.getMessage().find(historyWindow_->getSearchBoxText()) == std::string::npos) {

+ return;

+ }

+

+ // update contacts

+ if (!contacts_[message.getType()].count(displayJID)) {

+ roster_->addContact(displayJID, displayJID, nickResolver_->jidToNick(displayJID), category[message.getType()], avatarManager_->getAvatarPath(displayJID).string());

+ }

+

+ contacts_[message.getType()][displayJID].insert(message.getTime().date());

+}

+

+void HistoryViewController::addNewMessage(const HistoryMessage& message, bool addAtTheTop) {

+ bool senderIsSelf = message.getFromJID().toBare() == selfJID_;

+ std::string avatarPath = avatarManager_->getAvatarPath(message.getFromJID()).string();

+

+ std::string nick = message.getType() != HistoryMessage::Groupchat ? nickResolver_->jidToNick(message.getFromJID()) : message.getFromJID().getResource();

+ historyWindow_->addMessage(message.getMessage(), nick, senderIsSelf, avatarPath, message.getTime(), addAtTheTop);

+}

+

+void HistoryViewController::handleReturnPressed(const std::string& keyword) {

+ reset();

+

+ for (int it = HistoryMessage::Chat; it <= HistoryMessage::PrivateMessage; it++) {

+ HistoryMessage::Type type = static_cast<HistoryMessage::Type>(it);

+

+ contacts_[type] = historyController_->getContacts(selfJID_, type, keyword);

+

+ for (ContactsMap::const_iterator contact = contacts_[type].begin(); contact != contacts_[type].end(); contact++) {

+ const JID& jid = contact->first;

+ std::string nick;

+ if (type == HistoryMessage::PrivateMessage) {

+ nick = jid.toString();

+ }

+ else {

+ nick = nickResolver_->jidToNick(jid);

+ }

+ roster_->addContact(jid, jid, nick, category[type], avatarManager_->getAvatarPath(jid).string());

+

+ Presence::ref presence = getPresence(jid, type == HistoryMessage::Groupchat);

+

+ if (presence.get()) {

+ roster_->applyOnItem(SetPresence(presence, JID::WithoutResource), jid);

+ }

+ }

+ }

+}

+

+void HistoryViewController::handleScrollReachedTop(const boost::gregorian::date& date) {

+ if (!selectedItem_) {

+ return;

+ }

+

+ std::vector<HistoryMessage> messages = historyController_->getMessagesFromPreviousDate(selfJID_, selectedItem_->getJID(), selectedItemType_, date);

+

+ foreach (const HistoryMessage& message, messages) {

+ addNewMessage(message, true);

+ }

+ historyWindow_->resetConversationViewTopInsertPoint();

+}

+

+void HistoryViewController::handleScrollReachedBottom(const boost::gregorian::date& date) {

+ if (!selectedItem_) {

+ return;

+ }

+

+ std::vector<HistoryMessage> messages = historyController_->getMessagesFromNextDate(selfJID_, selectedItem_->getJID(), selectedItemType_, date);

+

+ foreach (const HistoryMessage& message, messages) {

+ addNewMessage(message, false);

+ }

+}

+

+void HistoryViewController::handleNextButtonClicked() {

+ if (!selectedItem_) {

+ return;

+ }

+

+ std::set<boost::gregorian::date>::iterator date = contacts_[selectedItemType_][selectedItem_->getJID()].find(currentResultDate_);

+

+ if (*date == *contacts_[selectedItemType_][selectedItem_->getJID()].rbegin()) {

+ return;

+ }

+

+ historyWindow_->resetConversationView();

+ currentResultDate_ = *(++date);

+ std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

+ historyWindow_->setDate(currentResultDate_);

+

+ foreach (const HistoryMessage& message, messages) {

+ addNewMessage(message, false);

+ }

+}

+

+void HistoryViewController::handlePreviousButtonClicked() {

+ if (!selectedItem_) {

+ return;

+ }

+

+ std::set<boost::gregorian::date>::iterator date = contacts_[selectedItemType_][selectedItem_->getJID()].find(currentResultDate_);

+

+ if (date == contacts_[selectedItemType_][selectedItem_->getJID()].begin()) {

+ return;

+ }

+

+ historyWindow_->resetConversationView();

+ currentResultDate_ = *(--date);

+ std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

+ historyWindow_->setDate(currentResultDate_);

+

+ foreach (const HistoryMessage& message, messages) {

+ addNewMessage(message, false);

+ }

+}

+

+void HistoryViewController::reset() {

+ roster_->removeAll();

+ contacts_.clear();

+ selectedItem_ = NULL;

+ historyWindow_->resetConversationView();

+}

+

+void HistoryViewController::handleCalendarClicked(const boost::gregorian::date& date) {

+ if (!selectedItem_) {

+ return;

+ }

+

+ boost::gregorian::date newDate;

+ if (contacts_[selectedItemType_][selectedItem_->getJID()].count(date)) {

+ newDate = date;

+ }

+ else if (date < currentResultDate_) {

+ foreach(const boost::gregorian::date& current, contacts_[selectedItemType_][selectedItem_->getJID()]) {

+ if (current > date) {

+ newDate = current;

+ break;

+ }

+ }

+ }

+ else {

+ reverse_foreach(const boost::gregorian::date& current, contacts_[selectedItemType_][selectedItem_->getJID()]) {

+ if (current < date) {

+ newDate = current;

+ break;

+ }

+ }

+ }

+

+ historyWindow_->setDate(newDate);

+ if (newDate == currentResultDate_) {

+ return;

+ }

+ currentResultDate_ = newDate;

+ historyWindow_->resetConversationView();

+

+ std::vector<HistoryMessage> messages = historyController_->getMessagesFromDate(selfJID_, selectedItem_->getJID(), selectedItemType_, currentResultDate_);

+ historyWindow_->setDate(currentResultDate_);

+

+ foreach (const HistoryMessage& message, messages) {

+ addNewMessage(message, false);

+ }

+}

+

+void HistoryViewController::handlePresenceChanged(Presence::ref presence) {

+ JID jid = presence->getFrom();

+

+ if (contacts_[HistoryMessage::Chat].count(jid.toBare())) {

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

+ return;

+ }

+

+ if (contacts_[HistoryMessage::Groupchat].count(jid.toBare())) {

+ Presence::ref availablePresence = boost::make_shared<Presence>(Presence());

+ availablePresence->setFrom(jid.toBare());

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

+ }

+

+ if (contacts_[HistoryMessage::PrivateMessage].count(jid)) {

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

+ }

+}

+

+void HistoryViewController::handleAvatarChanged(const JID& jid) {

+ std::string path = avatarManager_->getAvatarPath(jid).string();

+ roster_->applyOnItems(SetAvatar(jid, path));

+}

+

+Presence::ref HistoryViewController::getPresence(const JID& jid, bool isMUC) {

+ if (jid.isBare() && !isMUC) {

+ return presenceOracle_->getHighestPriorityPresence(jid);

+ }

+

+ std::vector<Presence::ref> mucPresence = presenceOracle_->getAllPresence(jid.toBare());

+

+ if (isMUC && !mucPresence.empty()) {

+ Presence::ref presence = boost::make_shared<Presence>(Presence());

+ presence->setFrom(jid);

+ return presence;

+ }

+

+ foreach (Presence::ref presence, mucPresence) {

+ if (presence.get() && presence->getFrom() == jid) {

+ return presence;

+ }

+ }

+

+ return Presence::create();

+}

+

+}

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <boost/bind.hpp>

+#include <boost/shared_ptr.hpp>

+

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

+#include <Swiften/JID/JID.h>

+#include <Swiften/Presence/PresenceOracle.h>

+#include <Swiften/History/HistoryStorage.h>

+#include <set>

+

+namespace Swift {

+ class HistoryWindowFactory;

+ class HistoryWindow;

+ class Roster;

+ class RosterItem;

+ class ContactRosterItem;

+ class HistoryController;

+ class NickResolver;

+ class AvatarManager;

+

+ class HistoryViewController {

+ public:

+ HistoryViewController(const JID& selfJID, UIEventStream* uiEventStream, HistoryController* historyController, NickResolver* nickResolver, AvatarManager* avatarManager, PresenceOracle* presenceOracle, HistoryWindowFactory* historyWindowFactory);

+ ~HistoryViewController();

+

+ private:

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+ void handleSelectedContactChanged(RosterItem* item);

+ void handleNewMessage(const HistoryMessage& message);

+ void handleReturnPressed(const std::string& keyword);

+ void handleScrollReachedTop(const boost::gregorian::date& date);

+ void handleScrollReachedBottom(const boost::gregorian::date& date);

+ void handlePreviousButtonClicked();

+ void handleNextButtonClicked();

+ void handleCalendarClicked(const boost::gregorian::date& date);

+ void handlePresenceChanged(Presence::ref presence);

+ void handleAvatarChanged(const JID& jid);

+

+ void addNewMessage(const HistoryMessage& message, bool addAtTheTop);

+ void reset();

+ Presence::ref getPresence(const JID& jid, bool isMUC);

+

+ private:

+ JID selfJID_;

+ UIEventStream* uiEventStream_;

+ HistoryController* historyController_;

+ NickResolver* nickResolver_;

+ AvatarManager* avatarManager_;

+ PresenceOracle* presenceOracle_;

+ HistoryWindowFactory* historyWindowFactory_;

+ HistoryWindow* historyWindow_;

+ Roster* roster_;

+

+ std::map<HistoryMessage::Type, ContactsMap> contacts_;

+ ContactRosterItem* selectedItem_;

+ HistoryMessage::Type selectedItemType_;

+ boost::gregorian::date currentResultDate_;

+ };

+}

+#include <Swift/Controllers/HistoryController.h>

+#include <Swift/Controllers/HistoryViewController.h>

+ historyViewController_ = NULL;

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ delete historyController_;

+ historyController_ = NULL;

+ delete historyViewController_;

+ historyViewController_ = NULL;

+#endif

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ historyController_ = new HistoryController(storages_->getHistoryStorage());

+ historyViewController_ = new HistoryViewController(jid_, uiEventStream_, historyController_, client_->getNickResolver(), client_->getAvatarManager(), client_->getPresenceOracle(), uiFactory_);

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_);

+#else

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, NULL);

+#endif

+ class HistoryViewController;

+ class HistoryController;

+ HistoryViewController* historyViewController_;

+ HistoryController* historyController_;

+ "HistoryViewController.cpp",

+ "HistoryController.cpp",

+#include <Swiften/History/SQLiteHistoryStorage.h>

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ historyStorage = new SQLiteHistoryStorage((baseDir / "history.db").string());

+#endif

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ delete historyStorage;

+#endif

+HistoryStorage* FileStorages::getHistoryStorage() const {

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ return historyStorage;

+#else

+ return NULL;

+#endif

+}

+

+ class HistoryStorage;

+ virtual HistoryStorage* getHistoryStorage() const;

+ HistoryStorage* historyStorage;

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+ class RequestHistoryUIEvent : public UIEvent {

+ };

+}

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+ class HistoryWindow {

+ public:

+ virtual ~HistoryWindow() {};

+

+ virtual void activate() = 0;

+ virtual void setRosterModel(Roster*) = 0;

+ virtual void addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, const std::string& avatarPath, const boost::posix_time::ptime& time, bool addAtTheTop) = 0;

+ virtual void resetConversationView() = 0;

+ virtual void resetConversationViewTopInsertPoint() = 0; // this is a temporary fix used in adding messages at the top

+ virtual void setDate(const boost::gregorian::date& date) = 0;

+

+ virtual std::string getSearchBoxText() = 0;

+ virtual boost::gregorian::date getLastVisibleDate() = 0;

+

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

+ boost::signal<void (const std::string&)> onReturnPressed;

+ boost::signal<void (const boost::gregorian::date&)> onScrollReachedTop;

+ boost::signal<void (const boost::gregorian::date&)> onScrollReachedBottom;

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

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

+ boost::signal<void (const boost::gregorian::date&)> onCalendarClicked;

+ };

+}

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIInterfaces/HistoryWindow.h>

+

+namespace Swift {

+ class UIEventStream;

+ class HistoryWindowFactory {

+ public:

+ virtual ~HistoryWindowFactory() {};

+ virtual HistoryWindow* createHistoryWindow(UIEventStream* eventStream) = 0;

+ };

+}

+#include <Swift/Controllers/UIInterfaces/HistoryWindowFactory.h>

+ public HistoryWindowFactory,