#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Base/foreach.h>

#include <SwifTools/TabComplete.h>

#include <Swiften/Base/foreach.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

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

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

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

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

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

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/MUC/MUC.h>

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_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

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

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_->onOccupantAffiliationChanged.connect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));

void MUCController::handleConfigurationCancelled() {

muc_->cancelConfigureRoom();

}

void MUCController::handleDestroyRoomRequest() {

muc_->destroyRoom();

}

}

void MUCController::handleGetAffiliationsRequest() {

muc_->requestAffiliationList(MUCOccupant::Owner);

muc_->requestAffiliationList(MUCOccupant::Admin);

muc_->requestAffiliationList(MUCOccupant::Member);

muc_->requestAffiliationList(MUCOccupant::Outcast);

}

namespace Swift {

class StanzaChannel;

class IQRouter;

class ChatWindowFactory;

class Roster;

class AvatarManager;

class UIEventStream;

class TimerFactory;

class TabComplete;

enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

struct NickJoinPart {

NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {};

std::string nick;

JoinPart type;

};

void updateJoinParts();

bool shouldUpdateJoinParts();

void dayTicked() {clearPresenceQueue();}

void processUserPart();

void handleBareJIDCapsChanged(const JID& jid);

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

void handleConfigurationCancelled();

void handleOccupantRoleChangeFailed(ErrorPayload::ref, const JID&, MUCOccupant::Role);

void handleGetAffiliationsRequest();

void handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids);

void handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes);

private:

MUC::ref muc_;

UIEventStream* events_;

std::string nick_;

std::string desiredNick_;

Roster* roster_;

TabComplete* completer_;

bool parting_;

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

};

}

/*

* Copyright (c) 2010-2012 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/optional.hpp>

#include <boost/shared_ptr.hpp>

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

#include <vector>

#include <string>

#include <Swiften/Elements/SecurityLabelsCatalog.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCOccupant.h>

namespace Swift {

class AvatarManager;

class TreeWidget;

class Roster;

class TabComplete;

class RosterItem;

class ContactRosterItem;

class FileTransferController;

class ChatWindow {

public:

enum AckState {Pending, Received, Failed};

enum ReceiptState {ReceiptRequested, ReceiptReceived};

enum Tristate {Yes, No, Maybe};

enum OccupantAction {Kick, Ban, MakeModerator, MakeParticipant, MakeVisitor, AddContact};

enum RoomAction {ChangeSubject, Configure, Affiliations, Destroy, Invite};

enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};

*/

virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions) = 0;

/**

* A room configuration has been requested, show the form.

* If the form is cancelled, must emit onConfigurationFormCancelled().

*/

virtual void showRoomConfigurationForm(Form::ref) = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

boost::signal<void ()> onSendCorrectionMessageRequest;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

boost::signal<void ()> onAlertButtonClicked;

boost::signal<void (ContactRosterItem*)> onOccupantSelectionChanged;

boost::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;

boost::signal<void (const std::string&)> onChangeSubjectRequest;

boost::signal<void (Form::ref)> onConfigureRequest;

boost::signal<void ()> onDestroyRequest;

boost::signal<void ()> onConfigurationFormCancelled;

boost::signal<void ()> onGetAffiliationsRequest;

boost::signal<void (MUCOccupant::Affiliation, const JID&)> onSetAffiliationRequest;

boost::signal<void (const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes)> onChangeAffiliationsRequest;

boost::signal<void ()> onLogCleared;

// File transfer related

boost::signal<void (std::string /* id */)> onFileTransferCancel;

boost::signal<void (std::string /* id */, std::string /* description */)> onFileTransferStart;

virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {};

virtual void cancelAlert() {};

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

void setSubject(const std::string& /*subject*/) {}

virtual void showRoomConfigurationForm(Form::ref) {}

virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true) {};

virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}

virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {};

std::string name_;

std::string lastMessageBody_;

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

bool labelsEnabled_;

SecurityLabelsCatalog::Item label_;

};

}

#include "Swift/Controllers/Roster/ContactRosterItem.h"

#include "Roster/QtOccupantListWidget.h"

#include "SwifTools/Linkify.h"

#include "QtChatView.h"

#include "MessageSnippet.h"

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtSettingsProvider.h"

#include "QtScaledAvatarCache.h"

#include <Swiften/StringCodecs/Base64.h>

#include "SwifTools/TabComplete.h"

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

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

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

#include "QtChatWindowJSBridge.h"

#include <boost/cstdint.hpp>

msgBox.setText(tr("Are you sure you want to destroy the room?"));

msgBox.setInformativeText(tr("This will destroy the room."));

msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

msgBox.setDefaultButton(QMessageBox::No);

if (msgBox.exec() == QMessageBox::Yes) {

onDestroyRequest();

}

}

else if (result == invite) {

}

}

void QtChatWindow::handleAffiliationEditorAccepted() {

onChangeAffiliationsRequest(affiliationEditor_->getChanges());

}

void QtChatWindow::setAffiliations(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {

if (!affiliationEditor_) return;

}

QString qAvatarPath = "qrc:/icons/avatar.png";

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, false, appendToPrevious, theme_, id)));

previousMessageWasSelf_ = false;

previousSenderName_ = P2QSTRING(senderName);

previousMessageKind_ = PreviousMessageWasMUCInvite;

}

}

void flash();

QByteArray getSplitterState();

virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions);

void setSubject(const std::string& subject);

void showRoomConfigurationForm(Form::ref);

void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct = true);

void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&);

void setAvailableRoomActions(const std::vector<RoomAction> &actions);

static QString buildChatWindowButton(const QString& name, const QString& id, const QString& arg1 = QString(), const QString& arg2 = QString(), const QString& arg3 = QString());

public slots:

void handleChangeSplitterState(QByteArray state);

void handleFontResized(int fontSizeSteps);

void setAlert(const std::string& alertText, const std::string& buttonText = "");

void cancelAlert();

void setCorrectionEnabled(Tristate enabled);

"QtContactEditWidget.cpp",

"ChatSnippet.cpp",

"MessageSnippet.cpp",

"SystemMessageSnippet.cpp",

"QtElidingLabel.cpp",

"QtFormWidget.cpp",

"QtFormResultItemModel.cpp",

"QtLineEdit.cpp",

"QtJoinMUCWindow.cpp",

"Roster/RosterModel.cpp",

"Roster/QtTreeWidget.cpp",

# "Roster/QtTreeWidgetItem.cpp",

"Roster/RosterDelegate.cpp",

"Roster/GroupItemDelegate.cpp",

"Roster/DelegateCommons.cpp",

"Roster/QtRosterWidget.cpp",

"Roster/QtOccupantListWidget.cpp",

"EventViewer/EventModel.cpp",