AvatarManager* avatarManager,

UIEventStream* uiEventStream,

bool useDelayForLatency,

TimerFactory* timerFactory,

EventController* eventController,

EntityCapsProvider* entityCapsProvider) :

ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password) {

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

events_ = uiEventStream;

roster_ = new Roster(false, true);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

chatWindow_->setName(muc->getJID().getNode());

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInvitePersonToThisMUCRequest.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1, _2));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

if (timerFactory) {

loginCheckTimer_ = boost::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

loginCheckTimer_->start();

}

chatWindow_->convertToMUC();

setOnline(true);

if (avatarManager_ != NULL) {

avatarChangedConnection_ = (avatarManager_->onAvatarChanged.connect(boost::bind(&MUCController::handleAvatarChanged, this, _1)));

}

handleBareJIDCapsChanged(muc->getJID());

}

MUCController::~MUCController() {

chatWindow_->setRosterModel(NULL);

delete roster_;

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

chatWindow_->setTabComplete(NULL);

delete completer_;

}

void MUCController::handleWindowOccupantSelectionChanged(ContactRosterItem* item) {

std::vector<ChatWindow::OccupantAction> actions;

if (item) {

actions.push_back(ChatWindow::Kick);

}

chatWindow_->setAvailableOccupantActions(actions);

}

void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {

switch (action) {

}

}

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

ChatWindow::Tristate support = ChatWindow::Yes;

bool any = false;

foreach (const std::string& nick, currentOccupants_) {

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

any = true;

} else {

support = ChatWindow::Maybe;

}

}

if (!any) {

support = ChatWindow::No;

}

chatWindow_->setCorrectionEnabled(support);

}

/**

* Join the MUC if not already in it.

*/

void MUCController::rejoin() {

if (parting_) {

joined_ = false;

parting_ = false;

if (password_) {

muc_->setPassword(*password_);

}

//FIXME: check for received activity

if (lastActivity_ == boost::posix_time::not_a_date_time) {

muc_->joinAs(nick_);

} else {

muc_->joinWithContextSince(nick_, lastActivity_);

eventStrings[i] = str(boost::format(eventString) % names);

}

}

for (size_t i = 0; i < populatedEvents.size(); i++) {

if (i > 0) {

if (i < populatedEvents.size() - 1) {

result += ", ";

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

result += eventStrings[populatedEvents[i]];

}

return result;

}

void MUCController::handleChangeSubjectRequest(const std::string& subject) {

muc_->changeSubject(subject);

}

void MUCController::handleConfigureRequest(Form::ref form) {

if (form) {

muc_->configureRoom(form);

}

else {

muc_->requestConfigurationForm();

}

}

void MUCController::handleConfigurationFailed(ErrorPayload::ref error) {

std::string errorMessage = getErrorMessage(error);

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Room configuration failed: %1%.")) % errorMessage);

chatWindow_->addErrorMessage(errorMessage);

}

void MUCController::handleConfigurationFormReceived(Form::ref form) {

chatWindow_->showRoomConfigurationForm(form);

}

void MUCController::handleConfigurationCancelled() {

muc_->cancelConfigureRoom();

}

void MUCController::handleDestroyRoomRequest() {

muc_->destroyRoom();

}

void MUCController::handleInvitePersonToThisMUCRequest(const JID& jid, const std::string& reason) {

muc_->invitePerson(jid, reason);

}

}

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

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

private:

void clearPresenceQueue();

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

void handleWindowOccupantSelectionChanged(ContactRosterItem* item);

void handleActionRequestedOnOccupant(ChatWindow::OccupantAction, ContactRosterItem* item);

void handleWindowClosed();

void handleAvatarChanged(const JID& jid);

void handleOccupantJoined(const MUCOccupant& occupant);

void handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason);

void handleOccupantPresenceChange(boost::shared_ptr<Presence> presence);

void handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant,const MUCOccupant::Role& oldRole);

void handleJoinComplete(const std::string& nick);

void handleJoinFailed(boost::shared_ptr<ErrorPayload> error);

void handleJoinTimeoutTick();

void handleChangeSubjectRequest(const std::string&);

std::string roleToGroupName(MUCOccupant::Role role);

std::string roleToSortName(MUCOccupant::Role role);

JID nickToJID(const std::string& nick);

std::string roleToFriendlyName(MUCOccupant::Role role);

void receivedActivity();

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

void updateJoinParts();

bool shouldUpdateJoinParts();

void dayTicked() {lastWasPresence_ = false;}

void processUserPart();

void handleBareJIDCapsChanged(const JID& jid);

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

void handleInvitePersonToThisMUCRequest(const JID& jid, const std::string& reason);

void handleConfigurationCancelled();

private:

MUC::ref muc_;

UIEventStream* events_;

std::string nick_;

std::string desiredNick_;

Roster* roster_;

TabComplete* completer_;

bool parting_;

bool joined_;

bool lastWasPresence_;

bool shouldJoinOnReconnect_;

bool doneGettingHistory_;

boost::bsignals::scoped_connection avatarChangedConnection_;

boost::shared_ptr<Timer> loginCheckTimer_;

std::set<std::string> currentOccupants_;

std::vector<NickJoinPart> joinParts_;

boost::posix_time::ptime lastActivity_;

boost::optional<std::string> password_;

};

}