return message->getTimestamp();

}

if (historyController_) {

}

}

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_) {

}

}

delete localHistory_;

}

localHistory_->addMessage(historyMessage);

}

}

}

}

#include <Swiften/JID/JID.h>

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

#include <vector>

namespace Swift {

class HistoryManager;

HistoryController();

~HistoryController();

private:

HistoryManager* localHistory_;

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

#include <Swift/Controllers/HistoryController.h>

#include <Swiften/History/HistoryMessage.h>

namespace Swift {

HistoryViewController::HistoryViewController(

UIEventStream* uiEventStream,

HistoryController* historyController,

NickResolver* nickResolver,

AvatarManager* avatarManager,

HistoryWindowFactory* historyWindowFactory) :

uiEventStream_(uiEventStream),

historyController_(historyController),

nickResolver_(nickResolver),

roster_ = new Roster(false, true);

historyWindow_->setRosterModel(roster_);

}

}

}

void HistoryViewController::handleSelectedContactChanged(RosterItem* newContact) {

// FIXME: signal is triggerd twice.

if (newContact == NULL) {

return;

}

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

}

}

#include <boost/shared_ptr.hpp>

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

namespace Swift {

class HistoryWindowFactory;

class HistoryViewController {

public:

~HistoryViewController();

private:

void handleSelectedContactChanged(RosterItem* item);

private:

UIEventStream* uiEventStream_;

HistoryController* historyController_;

NickResolver* nickResolver_;

HistoryWindowFactory* historyWindowFactory_;

HistoryWindow* historyWindow_;

Roster* roster_;

};

}

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

client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

chatsManager_->setAvatarManager(client_->getAvatarManager());

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

namespace Swift {

class HistoryWindow {

public:

virtual ~HistoryWindow() {};

virtual void activate() = 0;

virtual void setRosterModel(Roster*) = 0;

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

};

#include <string>

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

namespace Swift {

conversationRoster_->setRosterModel(model);

}

}

void QtHistoryWindow::handleSomethingSelectedChanged(RosterItem* item) {

conversation_->resetView();

onSelectedContactChanged(item);

~QtHistoryWindow();

void activate();

void setRosterModel(Roster*);

private:

virtual void closeEvent(QCloseEvent* event);

#pragma once

#include <vector>

#include <Swiften/JID/JID.h>

#include <Swiften/History/HistoryMessage.h>

virtual void addMessage(const HistoryMessage& message) = 0;

};

}

const std::string& message,

const JID& fromJID,

const JID& toJID,

const boost::posix_time::ptime& time) :

message_(message),

fromJID_(fromJID),

toJID_(toJID),

time_(time) {

}

return toJID_;

}

boost::posix_time::ptime getTime() const {

return time_;

}

bool operator==(const HistoryMessage& o) const {

}

private:

std::string message_;

JID fromJID_;

JID toJID_;

boost::posix_time::ptime time_;

};

}

}

char* errorMessage;

if (result != SQLITE_OK) {

std::cerr << "SQL Error: " << errorMessage << std::endl;

sqlite3_free(errorMessage);

std::cerr << "SQL Error: " << errorMessage << std::endl;

sqlite3_free(errorMessage);

}

}

SQLiteHistoryManager::~SQLiteHistoryManager() {

}

void SQLiteHistoryManager::addMessage(const HistoryMessage& message) {

int secondsSinceEpoch = (message.getTime() - boost::posix_time::ptime(boost::gregorian::date(1970, 1, 1))).total_seconds();

"'" + getEscapedString(message.getMessage()) + "', " +

boost::lexical_cast<std::string>(getIDForJID(message.getFromJID().toBare())) + ", '" +

getEscapedString(message.getFromJID().getResource()) + "', " +

getEscapedString(message.getToJID().getResource()) + "', " +

boost::lexical_cast<std::string>(secondsSinceEpoch) + ")";

char* errorMessage;

int result = sqlite3_exec(db_, statement.c_str(), 0, 0, &errorMessage);

}

}

sqlite3_stmt* selectStatement;

boost::optional<int> selfID = getIDFromJID(selfJID.toBare());

return std::vector<HistoryMessage>();

}

int r = sqlite3_prepare(db_, selectQuery.c_str(), selectQuery.size(), &selectStatement, NULL);

if (r != SQLITE_OK) {

toJID = boost::optional<JID>(JID(toJID->getNode(), toJID->getDomain(), toResource));

}

// timestamp

boost::posix_time::ptime time(boost::gregorian::date(1970, 1, 1), boost::posix_time::seconds(secondsSinceEpoch));

r = sqlite3_step(selectStatement);

}

if (r != SQLITE_DONE) {

return result;

}

}

sqlite3_stmt* selectStatement;

int r = sqlite3_prepare(db_, query.c_str(), query.size(), &selectStatement, NULL);

}

r = sqlite3_step(selectStatement);

while (r == SQLITE_ROW) {

boost::optional<JID> contactJID(getJIDFromID(sqlite3_column_int(selectStatement, 0)));

if (contactJID) {

}

r = sqlite3_step(selectStatement);

}

if (r != SQLITE_DONE) {

std::cout << "Error: " << sqlite3_errmsg(db_) << std::endl;

}

sqlite3_finalize(selectStatement);

}

}

~SQLiteHistoryManager();

void addMessage(const HistoryMessage& message);

private:

int getIDForJID(const JID&);

int addJID(const JID&);

boost::optional<JID> getJIDFromID(int id) const;

boost::optional<int> getIDFromJID(const JID& jid) const;