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)

: ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController) {

isInMUC_ = isInMUC;

chatStateNotifier_ = new ChatStateNotifier();

chatStateMessageSender_ = new ChatStateMessageSender(chatStateNotifier_, stanzaChannel, contact);

chatStateTracker_ = new ChatStateTracker();

}

chatStateNotifier_->receivedMessageFromContact(message->getPayload<ChatState>());

chatStateTracker_->handleMessageReceived(message);

}

void ChatController::preSendMessageRequest(boost::shared_ptr<Message> message) {

void ChatController::postSendMessage(const String& body) {

addMessage(body, "me", true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel() : boost::optional<SecurityLabel>(), String(avatarManager_->getAvatarPath(selfJID_).string()), boost::posix_time::microsec_clock::universal_time());

chatStateNotifier_->userSentMessage();

}

chatStateTracker_->handlePresenceChange(newPresence, previousPresence);

String newStatusChangeString = getStatusChangeString(newPresence);

if (!previousPresence || newStatusChangeString != getStatusChangeString(previousPresence)) {

}

}

ChatStateMessageSender* chatStateMessageSender_;

ChatStateTracker* chatStateTracker_;

bool isInMUC_;

};

}

#endif

#include "Swiften/Network/Timer.h"

#include "Swiften/Network/TimerFactory.h"

#include "SwifTools/TabComplete.h"

#include "Swiften/Base/foreach.h"

#include "Swift/Controllers/EventController.h"

ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController), muc_(new MUC(stanzaChannel, presenceSender, muc)), nick_(nick) {

parting_ = true;

joined_ = false;

events_ = uiEventStream;

roster_ = new Roster(false, true);

String joinMessage = "You have joined room " + toJID_.toString() + " as " + nick;

nick_ = nick;

chatWindow_->addSystemMessage(joinMessage);

setEnabled(true);

}

realJID = occupant.getRealJID().get();

}

currentOccupants_.insert(occupant.getNick());

roster_->addContact(jid, realJID, occupant.getNick(), roleToGroupName(occupant.getRole()));

if (joined_) {

String joinString = occupant.getNick() + " has joined the room";

}

joinString += ".";

}

if (avatarManager_ != NULL) {

handleAvatarChanged(jid, "dummy");

}

}

String MUCController::roleToFriendlyName(MUCOccupant::Role role) {

switch (role) {

case MUCOccupant::Moderator: return "moderator";

}

void MUCController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

boost::shared_ptr<Message> message = messageEvent->getStanza();

if (joined_ && messageTargetsMe(message) && !message->getPayload<Delay>()) {

eventController_->handleIncomingEvent(messageEvent);

}

}

void MUCController::handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType, const String& reason) {

currentOccupants_.erase(occupant.getNick());

completer_->removeWord(occupant.getNick());

String partMessage = (occupant.getNick() != nick_) ? occupant.getNick() + " has left the room" : "You have left the room";

partMessage += " (" + reason + ")";

}

partMessage += ".";

if (occupant.getNick() != nick_) {

roster_->removeContact(JID(toJID_.getNode(), toJID_.getDomain(), occupant.getNick()));

} else {

parting_ = true;

setEnabled(false);

}

return message->getTimestampFrom(toJID_);

}

}

class TimerFactory;

class TabComplete;

class MUCController : public ChatControllerBase {

public:

MUCController(const JID& self, const JID &muc, const String &nick, StanzaChannel* stanzaChannel, PresenceSender* presenceSender, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController);

boost::signal<void ()> onUserLeft;

virtual void setEnabled(bool enabled);

void rejoin();

protected:

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

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

private:

void handleWindowClosed();

void handleAvatarChanged(const JID& jid, const String&);

void handleOccupantJoined(const MUCOccupant& occupant);

String roleToFriendlyName(MUCOccupant::Role role);

void receivedActivity();

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

private:

MUC* muc_;

UIEventStream* events_;

TabComplete* completer_;

bool parting_;

bool joined_;

boost::bsignals::scoped_connection avatarChangedConnection_;

boost::shared_ptr<Timer> loginCheckTimer_;

std::set<String> currentOccupants_;

};

}

File("UnitTest/XMPPRosterControllerTest.cpp"),

File("UnitTest/PreviousStatusStoreTest.cpp"),

File("Chat/UnitTest/ChatsManagerTest.cpp"),

File("UnitTest/MockChatWindow.cpp"),

])

virtual void setInputEnabled(bool enabled) = 0;

virtual void setRosterModel(Roster* model) = 0;

virtual void setTabComplete(TabComplete* completer) = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

virtual void setInputEnabled(bool /*enabled*/) {};

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

virtual void setTabComplete(TabComplete*) {};

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

}

}

/* FIXME: must be queued */

}

}

void QtChatView::copySelectionToClipboard() {

Q_ASSERT(ok);

viewReady_ = true;

addQueuedSnippets();

}

}

QtChatView(QtChatTheme* theme, QWidget* parent);

void addMessage(boost::shared_ptr<ChatSnippet> snippet);

bool isScrolledToBottom() const;

signals:

emit geometryChanged();

}

}

void setRosterModel(Roster* roster);

void setTabComplete(TabComplete* completer);

int getCount();

signals:

void geometryChanged();