setToJID(from);

}

}

chatStateTracker_->handleMessageReceived(message);

}

void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

}

void ChatController::postSendMessage(const std::string& body, boost::shared_ptr<Stanza> sentStanza) {

}

lastWasPresence_ = false;

chatStateNotifier_->userSentMessage();

NickResolver* nickResolver_;

ChatStateNotifier* chatStateNotifier_;

ChatStateTracker* chatStateTracker_;

bool isInMUC_;

bool lastWasPresence_;

std::string lastStatusChangeString_;

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) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory) {

chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

createDayChangeTimer();

}

ChatControllerBase::~ChatControllerBase() {

chatWindow_->setUnreadMessageCount(0);

}

if (!stanzaChannel_->isAvailable() || body.empty()) {

return;

}

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

message->addPayload(boost::shared_ptr<Delay>(new Delay(now, selfJID_)));

}

stanzaChannel_->sendMessage(message);

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

onActivity(message->getBody());

JID from = message->getFrom();

std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

continue;

}

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

if (messageTimeStamp) {

timeStamp = *messageTimeStamp;

}

onActivity(body);

}

chatWindow_->show();

chatWindow_->setUnreadMessageCount(unreadMessages_.size());

#include "Swiften/Elements/ErrorPayload.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Queries/IQRouter.h"

namespace Swift {

class IQRouter;

virtual void dayTicked() {};

private:

void createDayChangeTimer();

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);

ChatWindow* chatWindow_;

JID toJID_;

bool labelsEnabled_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

bool useDelayForLatency_;

virtual void addSystemMessage(const std::string& message) = 0;

virtual void addPresenceMessage(const std::string& message) = 0;

virtual void addErrorMessage(const std::string& message) = 0;

virtual void setContactChatState(ChatState::ChatStateType state) = 0;

virtual void setName(const std::string& name) = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

};

}

#endif

virtual void setRosterModel(Roster* /*roster*/) {};

virtual void setTabComplete(TabComplete*) {};

virtual void replaceLastMessage(const std::string&) {};

void setAckState(const std::string& /*id*/, AckState /*state*/) {};

virtual void flash() {};

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

std::string name_;

std::string lastMessageBody_;

public:

ChatSnippet(bool appendToPrevious);

virtual ~ChatSnippet();

virtual const QString& getContent() const = 0;

virtual QString getContinuationElementID() const { return ""; }

bool getAppendToPrevious() const {

return appendToPrevious_;

}

static QString escape(const QString& original) {

QString result(original);

result.replace("%message%", "&#37;message&#37;");

return result;

}

protected:

void setContinuationFallbackSnippet(boost::shared_ptr<ChatSnippet> continuationFallback) {

continuationFallback_ = continuationFallback;

}

private:

bool appendToPrevious_;

boost::shared_ptr<ChatSnippet> continuationFallback_;

replace.setInnerXml(ChatSnippet::escape(note));

}

void QtChatView::copySelectionToClipboard() {

if (!webPage_->selectedText().isEmpty()) {

webPage_->triggerAction(QWebPage::Copy);

void addLastSeenLine();

void replaceLastMessage(const QString& newMessage);

void replaceLastMessage(const QString& newMessage, const QString& note);

void rememberScrolledToBottom();

void setAckXML(const QString& id, const QString& xml);

signals:

void gotFocus();

inputEnabled_ = true;

completer_ = NULL;

theme_ = theme;

updateTitleWithUnreadCount();

QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);

void QtChatWindow::handleKeyPressEvent(QKeyEvent* event) {

int key = event->key();

Qt::KeyboardModifiers modifiers = event->modifiers();

if (key == Qt::Key_W && modifiers == Qt::ControlModifier) {

close();

} else if (

emit requestActiveTab();

} else if (key == Qt::Key_Tab) {

tabComplete();

} else {

messageLog_->handleKeyPressEvent(event);

}

previousMessageWasPresence_ = false;

}

void QtChatWindow::addPresenceMessage(const std::string& message) {

if (isWidgetSelected()) {

onAllMessagesRead();

return;

}

messageLog_->scrollToBottom();

inputClearing_ = true;

input_->clear();

inputClearing_ = false;

void addSystemMessage(const std::string& message);

void addPresenceMessage(const std::string& message);

void addErrorMessage(const std::string& errorMessage);

void show();

void activate();

void setUnreadMessageCount(int count);

bool contactIsTyping_;

LastLineTracker lastLineTracker_;

QString contact_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QtTreeWidget* treeWidget_;

TabComplete* completer_;

std::vector<SecurityLabelsCatalog::Item> availableLabels_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

bool previousMessageWasPresence_;

|| (key == Qt::Key_Tab && modifiers == Qt::ControlModifier)

|| (key == Qt::Key_A && modifiers == Qt::AltModifier)

|| (key == Qt::Key_Tab)

) {

emit unhandledKeyPressEvent(event);

}