#include "Swiften/Chat/ChatStateNotifier.h"

#include "Swiften/Chat/ChatStateMessageSender.h"

#include "Swiften/Chat/ChatStateTracker.h"

#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

#include "Swift/Controllers/UIInterfaces/ChatWindowFactory.h"

#include "Swift/Controllers/NickResolver.h"

nickResolver_ = nickResolver;

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

chatStateTracker_->onChatStateChange.connect(boost::bind(&ChatWindow::setContactChatState, chatWindow_, _1));

String nick = nickResolver_->jidToNick(toJID_);

chatWindow_->setName(nick);

String startMessage("Starting chat with " + nick);

chatWindow_->addSystemMessage(startMessage);

chatWindow_->onUserTyping.connect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

chatWindow_->onUserCancelsTyping.connect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

}

ChatController::~ChatController() {

}

}

lastWasPresence_ = false;

chatStateNotifier_->userSentMessage();

}

String ChatController::senderDisplayNameFromMessage(const JID& from) {

return nickResolver_->jidToNick(from);

}

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

virtual ~ChatController();

virtual void setToJID(const JID& jid);

private:

void handlePresenceChange(boost::shared_ptr<Presence> newPresence, boost::shared_ptr<Presence> previousPresence);

String getStatusChangeString(boost::shared_ptr<Presence> presence);

bool isIncomingMessageFromMe(boost::shared_ptr<Message> message);

void preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent);

void preSendMessageRequest(boost::shared_ptr<Message>);

String senderDisplayNameFromMessage(const JID& from);

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message>) const;

private:

NickResolver* nickResolver_;

ChatStateTracker* chatStateTracker_;

bool isInMUC_;

bool lastWasPresence_;

};

}

#endif

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

}

stanzaChannel_->sendMessage(message);

}

void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog> catalog, const boost::optional<ErrorPayload>& error) {

chatWindow_->activate();

}

if (message.beginsWith("/me ")) {

} else {

}

}

#include <boost/optional.hpp>

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

#include "Swiften/Base/String.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Events/MessageEvent.h"

void activateChatWindow();

void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);

void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);

virtual void setEnabled(bool enabled);

virtual void setToJID(const JID& jid) {toJID_ = jid;};

protected:

ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController);

virtual String senderDisplayNameFromMessage(const JID& from) = 0;

virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message>) = 0;

virtual void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>) {};

#include <boost/bind.hpp>

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

#include "Swift/Controllers/EventController.h"

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

EventController* eventController_;

JID jid_;

StanzaChannel* stanzaChannel_;

ChatWindowFactory* chatWindowFactory_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

class ChatWindow {

public:

ChatWindow() {}

virtual ~ChatWindow() {};

virtual void addSystemMessage(const String& message) = 0;

virtual void addPresenceMessage(const String& message) = 0;

virtual void addErrorMessage(const String& message) = 0;

virtual void setRosterModel(Roster* model) = 0;

virtual void setTabComplete(TabComplete* completer) = 0;

virtual void replaceLastMessage(const String& message) = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

MockChatWindow() {};

virtual ~MockChatWindow();

virtual void addSystemMessage(const String& /*message*/) {};

virtual void addErrorMessage(const String& /*message*/) {};

virtual void addPresenceMessage(const String& /*message*/) {};

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

virtual void setTabComplete(TabComplete*) {};

virtual void replaceLastMessage(const Swift::String&) {};

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

namespace Swift {

if (isIncoming) {

if (appendToPrevious) {

content_ = theme->getIncomingNextContent();

}

}

content_.replace("%sender%", escape(sender));

content_.replace("%time%", "<span class='swift_time'>" + escape(time.toString("h:mm")) + "</span>");

content_.replace("%userIconPath%", escape(iconURI));

}

MessageSnippet::~MessageSnippet() {

namespace Swift {

class MessageSnippet : public ChatSnippet {

public:

virtual ~MessageSnippet();

const QString& getContent() const {

return content_;

}

}

bool QtChatView::isScrolledToBottom() const {

return webPage_->mainFrame()->scrollBarValue(Qt::Vertical) == webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical);

}

void replaceLastMessage(const QString& newMessage);

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

bool isScrolledToBottom() const;

signals:

void gotFocus();

emit titleUpdated();

}

}

if (isWidgetSelected()) {

onAllMessagesRead();

}

bool appendToPrevious = !previousMessageWasSystem_ && !previousMessageWasPresence_ && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_ && previousSenderName_ == P2QSTRING(senderName)));

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

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

previousMessageWasSystem_ = false;

previousMessageWasPresence_ = false;

}

int QtChatWindow::getCount() {

return unreadCount_;

}

}

void QtChatWindow::addErrorMessage(const String& errorMessage) {

#include "QtTabbable.h"

class QTextEdit;

class QLineEdit;

class QComboBox;

public:

QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream);

~QtChatWindow();

void addSystemMessage(const String& message);

void addPresenceMessage(const String& message);

void addErrorMessage(const String& errorMessage);

void setTabComplete(TabComplete* completer);

int getCount();

void replaceLastMessage(const String& message);

signals:

void geometryChanged();

private:

void updateTitleWithUnreadCount();

void tabComplete();

int unreadCount_;

bool contactIsTyping_;

bool inputClearing_;

UIEventStream* eventStream_;

bool inputEnabled_;

};

}

<file alias="icons/offline.png">../resources/icons/offline.png</file>

<file alias="icons/certificate.png">../resources/icons/certificate.png</file>

<file alias="icons/error.png">../resources/icons/error.png</file>

<file alias="icons/avatar.png">../resources/icons/avatar.png</file>

<file alias="icons/tray-standard.png">../resources/icons/tray-standard.png</file>

<file alias="icons/new-chat.png">../resources/icons/new-chat.png</file>

boost::signal<void ()> onConnected;

boost::signal<void (const String&)> onDataRead;

boost::signal<void (const String&)> onDataWritten;

private:

void handleConnectorFinished(boost::shared_ptr<Connection>, Connector::ref);

return true;

}

template<typename T> bool isRequestAtIndex(int index, const JID& jid, IQ::Type type) {

boost::shared_ptr<IQ> iqStanza = boost::dynamic_pointer_cast<IQ>(sentStanzas[index]);

return iqStanza && iqStanza->getType() == type && iqStanza->getTo() == jid && iqStanza->getPayload<T>();

virtual void sendMessage(boost::shared_ptr<Message>) = 0;

virtual void sendPresence(boost::shared_ptr<Presence>) = 0;

virtual bool isAvailable() = 0;

boost::signal<void (boost::shared_ptr<Message>)> onMessageReceived;

boost::signal<void (boost::shared_ptr<Presence>) > onPresenceReceived;

};

}