+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,

+ content_ = "<span class='date" + time.date().toString(Qt::ISODate) + "'>" + content_ + "</span>";

+QtChatView::QtChatView(QtChatTheme* theme, QWidget* parent, bool disableAutoScroll) : QWidget(parent), fontSizeSteps_(0), disableAutoScroll_(disableAutoScroll) {

+ connect(webPage_, SIGNAL(scrollRequested(int, int, const QRect&)), SLOT(handleScrollRequested(int, int, const QRect&)));

+void QtChatView::addMessageBottom(boost::shared_ptr<ChatSnippet> snippet) {

+void QtChatView::addMessageTop(boost::shared_ptr<ChatSnippet> snippet) {

+ // save scrollbar maximum value

+ if (!topMessageAdded_) {

+ scrollBarMaximum_ = webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical);

+ }

+ topMessageAdded_ = true;

+

+ QWebElement continuationElement = firstElement_.findFirst("#insert");

+

+ bool insert = snippet->getAppendToPrevious();

+ bool fallback = continuationElement.isNull();

+

+ boost::shared_ptr<ChatSnippet> newSnippet = (insert && fallback) ? snippet->getContinuationFallbackSnippet() : snippet;

+ QWebElement newElement = snippetToDOM(newSnippet);

+

+ if (insert && !fallback) {

+ Q_ASSERT(!continuationElement.isNull());

+ continuationElement.replace(newElement);

+ } else {

+ continuationElement.removeFromDocument();

+ topInsertPoint_.prependOutside(newElement);

+ }

+

+ firstElement_ = newElement;

+

+ if (lastElement_.isNull()) {

+ lastElement_ = firstElement_;

+ }

+

+ if (fontSizeSteps_ != 0) {

+ double size = 1.0 + 0.2 * fontSizeSteps_;

+ QString sizeString(QString().setNum(size, 'g', 3) + "em");

+ const QWebElementCollection spans = firstElement_.findAll("span.swift_resizable");

+ foreach (QWebElement span, spans) {

+ span.setStyleProperty("font-size", sizeString);

+ }

+ }

+}

+

+ isAtBottom_ = webPage_->mainFrame()->scrollBarValue(Qt::Vertical) >= (webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical) - 1);

+ if (topMessageAdded_) {

+ // adjust new scrollbar position

+ int newMaximum = webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical);

+ webPage_->mainFrame()->setScrollBarValue(Qt::Vertical, newMaximum - scrollBarMaximum_);

+ topMessageAdded_ = false;

+ }

+

+ if (isAtBottom_ && !disableAutoScroll_) {

+ firstElement_ = lastElement_;

+ topMessageAdded_ = false;

+ scrollBarMaximum_ = 0;

+

+ resetTopInsertPoint();

+ scrollToBottom();

+

+void QtChatView::handleScrollRequested(int, int dy, const QRect&) {

+ rememberScrolledToBottom();

+

+ int pos = webPage_->mainFrame()->scrollBarValue(Qt::Vertical) - dy;

+ emit scrollRequested(pos);

+

+ if (pos == 0) {

+ emit scrollReachedTop();

+ }

+ else if (pos == webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical)) {

+ emit scrollReachedBottom();

+ }

+}

+

+int QtChatView::getSnippetPositionByDate(const QDate& date) {

+ QWebElement message = webPage_->mainFrame()->documentElement().findFirst(".date" + date.toString(Qt::ISODate));

+

+ return message.geometry().top();

+}

+

+void QtChatView::resetTopInsertPoint() {

+ QWebElement continuationElement = firstElement_.findFirst("#insert");

+ continuationElement.removeFromDocument();

+ firstElement_ = QWebElement();

+

+ topInsertPoint_.removeFromDocument();

+ QWebElement chatElement = document_.findFirst("#Chat");

+ topInsertPoint_ = chatElement.clone();

+ topInsertPoint_.setOuterXml("<div id='swift_insert'/>");

+ chatElement.prependInside(topInsertPoint_);

+}

+

+class QDate;

+ QtChatView(QtChatTheme* theme, QWidget* parent, bool disableAutoScroll = false);

+ void addMessageTop(boost::shared_ptr<ChatSnippet> snippet);

+ void addMessageBottom(boost::shared_ptr<ChatSnippet> snippet);

+ int getSnippetPositionByDate(const QDate& date);

+

+ void scrollRequested(int pos);

+ void scrollReachedTop();

+ void scrollReachedBottom();

+ void resetTopInsertPoint();

+ void handleScrollRequested(int dx, int dy, const QRect& rectToScroll);

+ bool topMessageAdded_;

+ int scrollBarMaximum_;

+ QWebElement topInsertPoint_;

+ QWebElement firstElement_;

+ bool disableAutoScroll_;

+ messageLog_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

+ messageLog_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

+ messageLog_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet("<span class=\"error\">" + errorMessageHTML + "</span>", QDateTime::currentDateTime(), false, theme_)));

+ messageLog_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet(messageHTML, QDateTime::currentDateTime(), false, theme_)));

+ messageLog_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet(messageHTML, QDateTime::currentDateTime(), false, theme_)));

+ messageLog_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, false, appendToPrevious, theme_, id)));

+/*

+ * Copyright (c) 2012 Catalin Badea

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <QtHistoryWindow.h>

+#include <QtTabbable.h>

+

+#include <QtSwiftUtil.h>

+#include <MessageSnippet.h>

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

+#include <string>

+

+#include <boost/shared_ptr.hpp>

+

+#include <QTime>

+#include <QUrl>

+#include <QMenu>

+#include <QTextDocument>

+#include <QDateTime>

+#include <Swift/QtUI/QtScaledAvatarCache.h>

+#include <QLineEdit>

+

+#include <boost/smart_ptr/make_shared.hpp>

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

+

+namespace Swift {

+

+QtHistoryWindow::QtHistoryWindow(SettingsProvider* settings, UIEventStream* eventStream) :

+ previousTopMessageWasSelf_(false),

+ previousBottomMessageWasSelf_(false) {

+ ui_.setupUi(this);

+

+ theme_ = new QtChatTheme("");

+ idCounter_ = 0;

+

+ delete ui_.conversation_;

+ conversation_ = new QtChatView(theme_, this, true);

+ QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);

+ sizePolicy.setHorizontalStretch(80);

+ sizePolicy.setVerticalStretch(0);

+ conversation_->setSizePolicy(sizePolicy);

+

+ ui_.conversation_ = conversation_;

+ ui_.bottomLayout_->addWidget(conversation_);

+

+ delete ui_.conversationRoster_;

+ conversationRoster_ = new QtTreeWidget(eventStream, settings, this);

+ QSizePolicy sizePolicy2(QSizePolicy::Preferred, QSizePolicy::Expanding);

+ sizePolicy2.setVerticalStretch(80);

+ conversationRoster_->setSizePolicy(sizePolicy2);

+ ui_.conversationRoster_ = conversationRoster_;

+ ui_.bottomLeftLayout_->setDirection(QBoxLayout::BottomToTop);

+ ui_.bottomLeftLayout_->addWidget(conversationRoster_);

+

+ setWindowTitle(tr("History"));

+

+ conversationRoster_->onSomethingSelectedChanged.connect(boost::bind(&QtHistoryWindow::handleSomethingSelectedChanged, this, _1));

+ connect(conversation_, SIGNAL(scrollRequested(int)), this, SLOT(handleScrollRequested(int)));

+ connect(conversation_, SIGNAL(scrollReachedTop()), this, SLOT(handleScrollReachedTop()));

+ connect(conversation_, SIGNAL(scrollReachedBottom()), this, SLOT(handleScrollReachedBottom()));

+ connect(conversation_, SIGNAL(fontResized(int)), this, SLOT(handleFontResized(int)));

+ connect(ui_.searchBox_->lineEdit(), SIGNAL(returnPressed()), this, SLOT(handleReturnPressed()));

+ connect(ui_.calendarWidget_, SIGNAL(clicked(const QDate&)), this, SLOT(handleCalendarClicked(const QDate&)));

+ connect(ui_.calendarWidget_, SIGNAL(activated(const QDate&)), this, SLOT(handleCalendarClicked(const QDate&)));

+ connect(ui_.previousButton_, SIGNAL(clicked(bool)), this, SLOT(handlePreviousButtonClicked()));

+ connect(ui_.nextButton_, SIGNAL(clicked(bool)), this, SLOT(handleNextButtonClicked()));

+}

+

+QtHistoryWindow::~QtHistoryWindow() {

+ disconnect(conversation_, SIGNAL(scrollRequested(int)), this, SLOT(handleScrollRequested(int)));

+ disconnect(conversation_, SIGNAL(scrollReachedTop()), this, SLOT(handleScrollReachedTop()));

+ disconnect(conversation_, SIGNAL(scrollReachedBottom()), this, SLOT(handleScrollReachedBottom()));

+ disconnect(conversation_, SIGNAL(fontResized(int)), this, SLOT(handleFontResized(int)));

+ disconnect(ui_.searchBox_->lineEdit(), SIGNAL(returnPressed()), this, SLOT(handleReturnPressed()));

+ disconnect(ui_.calendarWidget_, SIGNAL(clicked(const QDate&)), this, SLOT(handleCalendarClicked(const QDate&)));

+ disconnect(ui_.calendarWidget_, SIGNAL(activated(const QDate&)), this, SLOT(handleCalendarClicked(const QDate&)));

+ disconnect(ui_.previousButton_, SIGNAL(clicked(bool)), this, SLOT(handlePreviousButtonClicked()));

+ disconnect(ui_.nextButton_, SIGNAL(clicked(bool)), this, SLOT(handleNextButtonClicked()));

+

+ delete theme_;

+ delete conversation_;

+ // TODO: delete ui_

+}

+

+void QtHistoryWindow::activate() {

+ emit wantsToActivate();

+}

+

+void QtHistoryWindow::showEvent(QShowEvent* event) {

+ emit windowOpening();

+ emit titleUpdated();

+ QWidget::showEvent(event);

+}

+

+void QtHistoryWindow::closeEvent(QCloseEvent* event) {

+ emit windowClosing();

+ event->accept();

+}

+

+void QtHistoryWindow::setRosterModel(Roster* model) {

+ conversationRoster_->setRosterModel(model);

+}

+

+void QtHistoryWindow::addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, const std::string& avatarPath, const boost::posix_time::ptime& time, bool addAtTheTop) {

+ QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());

+

+ QString messageHTML(P2QSTRING(message));

+ messageHTML = Qt::escape(messageHTML);

+ QString searchTerm = ui_.searchBox_->lineEdit()->text();

+ if (searchTerm.length()) {

+ messageHTML.replace(searchTerm, "<span style='background-color: yellow'>" + searchTerm + "</span>");

+ }

+

+ // note: time uses localtime

+ QDate date = QDate(time.date().year(), time.date().month(), time.date().day());

+ QTime dayTime = QTime(time.time_of_day().hours(), time.time_of_day().minutes(), time.time_of_day().seconds());

+ QDateTime qTime = QDateTime(date, dayTime);

+

+ std::string id = "id" + boost::lexical_cast<std::string>(idCounter_++);

+

+ QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

+

+ if (addAtTheTop) {

+ bool appendToPrevious = ((senderIsSelf && previousTopMessageWasSelf_) || (!senderIsSelf && !previousTopMessageWasSelf_&& previousTopSenderName_ == P2QSTRING(senderName)));

+ conversation_->addMessageTop(boost::shared_ptr<ChatSnippet>(new MessageSnippet(messageHTML, Qt::escape(P2QSTRING(senderName)), qTime, qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

+

+ previousTopMessageWasSelf_ = senderIsSelf;

+ previousTopSenderName_ = P2QSTRING(senderName);

+ }

+ else {

+ bool appendToPrevious = ((senderIsSelf && previousBottomMessageWasSelf_) || (!senderIsSelf && !previousBottomMessageWasSelf_&& previousBottomSenderName_ == P2QSTRING(senderName)));

+ conversation_->addMessageBottom(boost::shared_ptr<ChatSnippet>(new MessageSnippet(messageHTML, Qt::escape(P2QSTRING(senderName)), qTime, qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

+ previousBottomMessageWasSelf_ = senderIsSelf;

+ previousBottomSenderName_ = P2QSTRING(senderName);

+ }

+

+ // keep track of the days viewable in the chatView

+ if (!dates_.count(date)) {

+ dates_.insert(date);

+ }

+}

+

+void QtHistoryWindow::handleSomethingSelectedChanged(RosterItem* item) {

+ onSelectedContactChanged(item);

+}

+

+void QtHistoryWindow::resetConversationView() {

+ previousTopMessageWasSelf_ = false;

+ previousBottomMessageWasSelf_ = false;

+ previousTopSenderName_.clear();

+ previousBottomSenderName_.clear();

+

+ dates_.clear();

+ conversation_->resetView();

+}

+

+void QtHistoryWindow::handleScrollRequested(int pos) {

+ // first message starts with offset 5

+ if (pos < 5) {

+ pos = 5;

+ }

+

+ QDate currentDate;

+ foreach (const QDate& date, dates_) {

+ int snippetPosition = conversation_->getSnippetPositionByDate(date);

+ if (snippetPosition <= pos) {

+ currentDate = date;

+ }

+ }

+

+ if (ui_.calendarWidget_->selectedDate() != currentDate) {

+ ui_.calendarWidget_->setSelectedDate(currentDate);

+ }

+}

+

+void QtHistoryWindow::handleScrollReachedTop() {

+ if (dates_.empty()) {

+ return;

+ }

+

+ int year, month, day;

+ QDate firstDate = *dates_.begin();

+ firstDate.getDate(&year, &month, &day);

+ onScrollReachedTop(boost::gregorian::date(year, month, day));

+}

+

+void QtHistoryWindow::handleScrollReachedBottom() {

+ if (dates_.empty()) {

+ return;

+ }

+

+ int year, month, day;

+ QDate lastDate = *dates_.rbegin();

+ lastDate.getDate(&year, &month, &day);

+ onScrollReachedBottom(boost::gregorian::date(year, month, day));

+}

+

+void QtHistoryWindow::handleReturnPressed() {

+ onReturnPressed(ui_.searchBox_->lineEdit()->text().toStdString());

+}

+

+void QtHistoryWindow::handleCalendarClicked(const QDate& date) {

+ int year, month, day;

+ QDate tempDate = date; // getDate discards const qualifier

+ tempDate.getDate(&year, &month, &day);

+ onCalendarClicked(boost::gregorian::date(year, month, day));

+}

+

+void QtHistoryWindow::setDate(const boost::gregorian::date& date) {

+ ui_.calendarWidget_->setSelectedDate(QDate::fromJulianDay(date.julian_day()));

+}

+

+void QtHistoryWindow::handleNextButtonClicked() {

+ onNextButtonClicked();

+}

+

+void QtHistoryWindow::handlePreviousButtonClicked() {

+ onPreviousButtonClicked();

+}

+

+void QtHistoryWindow::handleFontResized(int fontSizeSteps) {

+ conversation_->resizeFont(fontSizeSteps);

+

+ emit fontResized(fontSizeSteps);

+}

+

+void QtHistoryWindow::resetConversationViewTopInsertPoint() {

+ previousTopMessageWasSelf_ = false;

+ previousTopSenderName_ = QString();

+ conversation_->resetTopInsertPoint();

+}

+

+std::string QtHistoryWindow::getSearchBoxText() {

+ return ui_.searchBox_->lineEdit()->text().toStdString();

+}

+

+boost::gregorian::date QtHistoryWindow::getLastVisibleDate() {

+ if (!dates_.empty()) {

+ QDate lastDate = *dates_.rbegin();

+ int year, month, day;

+ lastDate.getDate(&year, &month, &day);

+

+ return boost::gregorian::date(year, month, day);

+ }

+ return boost::gregorian::date(boost::gregorian::not_a_date_time);

+}

+

+}

+/*

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

+#include <Swift/QtUI/ui_QtHistoryWindow.h>

+#include <QtChatView.h>

+#include <QtTabbable.h>

+#include <Swift/QtUI/Roster/QtTreeWidget.h>

+#include <set>

+#include <QDate>

+

+namespace Swift {

+ class QtHistoryWindow : public QtTabbable, public HistoryWindow {

+ Q_OBJECT

+

+ public:

+ QtHistoryWindow(SettingsProvider*, UIEventStream*);

+ ~QtHistoryWindow();

+ void activate();

+ void setRosterModel(Roster*);

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

+ void resetConversationView();

+ void resetConversationViewTopInsertPoint();

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

+

+ void closeEvent(QCloseEvent* event);

+ void showEvent(QShowEvent* event);

+

+ std::string getSearchBoxText();

+ boost::gregorian::date getLastVisibleDate();

+

+ signals:

+ void fontResized(int);

+

+ public slots:

+ void handleFontResized(int fontSizeSteps);

+

+ protected slots:

+ void handleScrollRequested(int pos);

+ void handleScrollReachedTop();

+ void handleScrollReachedBottom();

+ void handleReturnPressed();

+ void handleCalendarClicked(const QDate& date);

+ void handlePreviousButtonClicked();

+ void handleNextButtonClicked();

+

+ private:

+ void handleSomethingSelectedChanged(RosterItem* item);

+

+ Ui::QtHistoryWindow ui_;

+ QtChatTheme* theme_;

+ QtChatView* conversation_;

+ QtTreeWidget* conversationRoster_;

+ std::set<QDate> dates_;

+ int idCounter_;

+ bool previousTopMessageWasSelf_;

+ QString previousTopSenderName_;

+ bool previousBottomMessageWasSelf_;

+ QString previousBottomSenderName_;

+ };

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtHistoryWindow</class>

+ <widget class="QWidget" name="QtHistoryWindow">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>608</width>

+ <height>522</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

+ <layout class="QGridLayout" name="gridLayout">

+ <item row="0" column="0">

+ <layout class="QHBoxLayout" name="topLayout_">

+ <item>

+ <widget class="QLabel" name="label_">

+ <property name="text">

+ <string>Search:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QComboBox" name="searchBox_">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Expanding" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="editable">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="nextButton_">

+ <property name="text">

+ <string>Next</string>

+ </property>

+ <property name="flat">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="previousButton_">

+ <property name="text">

+ <string>Previous</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item row="1" column="0">

+ <widget class="QSplitter" name="bottomLayout_">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <widget class="QWidget" name="layoutWidget">

+ <layout class="QVBoxLayout" name="bottomLeftLayout_" stretch="0,0">

+ <item>

+ <widget class="QWidget" name="conversationRoster_" native="true">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Expanding">

+ <horstretch>5</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QCalendarWidget" name="calendarWidget_">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Preferred" vsizetype="Minimum">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ <widget class="QWidget" name="conversation_" native="true">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Expanding" vsizetype="Preferred">

+ <horstretch>85</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ </widget>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

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

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ QAction* viewLogsAction = new QAction(tr("&View History…"), this);

+ connect(viewLogsAction, SIGNAL(triggered()), SLOT(handleViewLogsAction()));

+ actionsMenu->addAction(viewLogsAction);

+#endif

+void QtMainWindow::handleViewLogsAction() {

+ uiEventStream_->send(boost::make_shared<RequestHistoryUIEvent>());

+}

+

+ void handleViewLogsAction();

+#include <QtHistoryWindow.h>

+ historyFontSize_ = settings->getSetting(QtUISettingConstants::HISTORYWINDOW_FONT_SIZE);

+HistoryWindow* QtUIFactory::createHistoryWindow(UIEventStream* uiEventStream) {

+ QtHistoryWindow* window = new QtHistoryWindow(settings, uiEventStream);

+ tabs->addTab(window);

+ if (!tabs->isVisible()) {

+ tabs->show();

+ }

+

+ connect(window, SIGNAL(fontResized(int)), this, SLOT(handleHistoryWindowFontResized(int)));

+

+ window->handleFontResized(historyFontSize_);

+ window->show();

+ return window;

+}

+

+void QtUIFactory::handleHistoryWindowFontResized(int size) {

+ historyFontSize_ = size;

+ settings->storeSetting(QtUISettingConstants::HISTORYWINDOW_FONT_SIZE, size);

+}

+

+ class historyWindow_;

+ virtual HistoryWindow* createHistoryWindow(UIEventStream*);

+ void handleHistoryWindowFontResized(int);

+ int historyFontSize_;

+const SettingsProvider::Setting<int> QtUISettingConstants::HISTORYWINDOW_FONT_SIZE("historyWindowFontSize", 0);

+ static const SettingsProvider::Setting<int> HISTORYWINDOW_FONT_SIZE;

+ "QtHistoryWindow.cpp",

+myenv.Uic4("QtHistoryWindow.ui")

+ var target_scroll = (document.body.scrollHeight-window.innerHeight) - 1;

+

+html {

+ height: 101%;

+}