1 files changed, 34 insertions, 10 deletions
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index 7e47f4d..0635496 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -21,70 +21,71 @@
 #include "SwifTools/TabComplete.h"
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include "QtFileTransferJSBridge.h"
 
 #include <boost/cstdint.hpp>
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <QLabel>
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QApplication>
 #include <QBoxLayout>
 #include <QCloseEvent>
 #include <QComboBox>
 #include <QFileInfo>
 #include <QLineEdit>
 #include <QSplitter>
 #include <QString>
 #include <QTextEdit>
 #include <QTime>
 #include <QUrl>
 #include <QPushButton>
 #include <QFileDialog>
 #include <QMenu>
 
 #include <QDebug>
 
 namespace Swift {
 QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageWasSystem_(false), previousMessageWasPresence_(false), previousMessageWasFileTransfer_(false), eventStream_(eventStream) {
 	unreadCount_ = 0;
 	inputEnabled_ = true;
 	completer_ = NULL;
+	affiliationEditor_ = NULL;
 	theme_ = theme;
 	isCorrection_ = false;
 	correctionEnabled_ = Maybe;
 	updateTitleWithUnreadCount();
 	QtSettingsProvider settings;
 
 #ifdef SWIFT_EXPERIMENTAL_FT
 	setAcceptDrops(true);
 #endif
 
 	alertStyleSheet_ = "background: rgb(255, 255, 153); color: black";
 
 	QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);
 	layout->setContentsMargins(0,0,0,0);
 	layout->setSpacing(2);
 
 	alertWidget_ = new QWidget(this);
 	QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget_);
 	layout->addWidget(alertWidget_);
 	alertLabel_ = new QLabel(this);
 	alertLayout->addWidget(alertLabel_);
 	alertButton_ = new QPushButton(this);
 	connect (alertButton_, SIGNAL(clicked()), this, SLOT(handleAlertButtonClicked()));
 	alertLayout->addWidget(alertButton_);
 	QPalette palette = alertWidget_->palette();
 	palette.setColor(QPalette::Window, QColor(Qt::yellow));
 	palette.setColor(QPalette::WindowText, QColor(Qt::black));
 	alertWidget_->setStyleSheet(alertStyleSheet_);
 	alertLabel_->setStyleSheet(alertStyleSheet_);
 	alertWidget_->hide();
 
 	QBoxLayout* subjectLayout = new QBoxLayout(QBoxLayout::LeftToRight);
 	subject_ = new QLineEdit(this);
 	subjectLayout->addWidget(subject_);
 	setSubject("");
@@ -133,72 +134,72 @@ QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventSt
 	input_->setAcceptRichText(false);
 	inputBarLayout->addWidget(input_);
 	correctingLabel_ = new QLabel(tr("Correcting"), this);
 	inputBarLayout->addWidget(correctingLabel_);
 	correctingLabel_->hide();
 	layout->addLayout(inputBarLayout);
 
 	inputClearing_ = false;
 	contactIsTyping_ = false;
 
 	connect(input_, SIGNAL(unhandledKeyPressEvent(QKeyEvent*)), this, SLOT(handleKeyPressEvent(QKeyEvent*)));
 	connect(input_, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
 	connect(input_, SIGNAL(textChanged()), this, SLOT(handleInputChanged()));
 	setFocusProxy(input_);
 	logRosterSplitter_->setFocusProxy(input_);
 	midBar->setFocusProxy(input_);
 	messageLog_->setFocusProxy(input_);
 	connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(qAppFocusChanged(QWidget*, QWidget*)));
 	connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));
 	resize(400,300);
 	connect(messageLog_, SIGNAL(fontResized(int)), this, SIGNAL(fontResized(int)));
 
 	treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QtChatWindow::handleOccupantSelectionChanged, this, _1));
 	treeWidget_->onOccupantActionSelected.connect(boost::bind(boost::ref(onOccupantActionSelected), _1, _2));
 
 	fileTransferJS = new QtFileTransferJSBridge();
 	messageLog_->addToJSEnvironment("filetransfer", fileTransferJS);
 	connect(fileTransferJS, SIGNAL(setDescription(QString)), this, SLOT(handleFileTransferSetDescription(QString)));
 	connect(fileTransferJS, SIGNAL(sendRequest(QString)), this, SLOT(handleFileTransferStart(QString)));
 	connect(fileTransferJS, SIGNAL(acceptRequest(QString, QString)), this, SLOT(handleFileTransferAccept(QString, QString)));
 	connect(fileTransferJS, SIGNAL(cancel(QString)), this, SLOT(handleFileTransferCancel(QString)));
 }
 
 QtChatWindow::~QtChatWindow() {
 	delete fileTransferJS;
-	if (mucConfigurationWindow) {
-		delete mucConfigurationWindow.data();
+	if (mucConfigurationWindow_) {
+		delete mucConfigurationWindow_.data();
 	}
 }
 
 
 void QtChatWindow::handleOccupantSelectionChanged(RosterItem* item) {
 	onOccupantSelectionChanged(dynamic_cast<ContactRosterItem*>(item));
 }
 
 void QtChatWindow::handleFontResized(int fontSizeSteps) {
 	messageLog_->resizeFont(fontSizeSteps);
 }
 
 void QtChatWindow::handleAlertButtonClicked() {
 	onAlertButtonClicked();
 }
 
 void QtChatWindow::setAlert(const std::string& alertText, const std::string& buttonText) {
 	alertLabel_->setText(alertText.c_str());
 	if (buttonText.empty()) {
 		alertButton_->hide();
 	} else {
 		alertButton_->setText(buttonText.c_str());
 		alertButton_->show();
 	}
 	alertWidget_->show();
 }
 
 void QtChatWindow::cancelAlert() {
 	alertWidget_->hide();
 }
 
 void QtChatWindow::setTabComplete(TabComplete* completer) {
 	completer_ = completer;
 }
 
@@ -309,102 +310,107 @@ void QtChatWindow::setAvailableSecurityLabels(const std::vector<SecurityLabelsCa
 	int i = 0;
 	int defaultIndex = 0;
 	foreach (SecurityLabelsCatalog::Item label, labels) {
 		std::string selector = label.getSelector();
 		std::string displayMarking = label.getLabel() ? label.getLabel()->getDisplayMarking() : "";
 		QString labelName = selector.empty() ? displayMarking.c_str() : selector.c_str();
 		labelsWidget_->addItem(labelName, QVariant(i));
 		if (label.getIsDefault()) {
 			defaultIndex = i;
 		}
 		i++;
 	}
 	labelsWidget_->setCurrentIndex(defaultIndex);
 }
 
 
 void QtChatWindow::setSecurityLabelsError() {
 	labelsWidget_->setEnabled(false);
 }
 
 void QtChatWindow::setSecurityLabelsEnabled(bool enabled) {
 	if (enabled) {
 		labelsWidget_->setEnabled(true);
 		labelsWidget_->show();
 	} else {
 		labelsWidget_->hide();
 	}
 }
 
 void QtChatWindow::setCorrectionEnabled(Tristate enabled) {
 	correctionEnabled_ = enabled;
 }
 
 SecurityLabelsCatalog::Item QtChatWindow::getSelectedSecurityLabel() {
 	assert(labelsWidget_->isEnabled());
-	assert(labelsWidget_->currentIndex() >= 0 && labelsWidget_->currentIndex() < availableLabels_.size());
+	assert(labelsWidget_->currentIndex() >= 0 && static_cast<size_t>(labelsWidget_->currentIndex()) < availableLabels_.size());
 	return availableLabels_[labelsWidget_->currentIndex()];
 }
 
 void QtChatWindow::closeEvent(QCloseEvent* event) {
 	event->accept();
 	emit windowClosing();
 	onClosed();
 }
 
 void QtChatWindow::convertToMUC() {
 	setAcceptDrops(false);
 	treeWidget_->show();
 	subject_->show();
 	actionButton_->show();
 }
 
 void QtChatWindow::qAppFocusChanged(QWidget* /*old*/, QWidget* /*now*/) {
 	if (isWidgetSelected()) {
 		lastLineTracker_.setHasFocus(true);
 		input_->setFocus();
 		onAllMessagesRead();
 	}
 	else {
 		lastLineTracker_.setHasFocus(false);
 	}
 }
 
 void QtChatWindow::setInputEnabled(bool enabled) {
 	inputEnabled_ = enabled;
-	if (!enabled && mucConfigurationWindow) {
-		delete mucConfigurationWindow.data();
+	if (!enabled) {
+		if (mucConfigurationWindow_) {
+			delete mucConfigurationWindow_.data();
+		}
+		if (affiliationEditor_) {
+			delete affiliationEditor_.data();
+		}
 	}
 }
 
 void QtChatWindow::showEvent(QShowEvent* event) {
 	emit windowOpening();
 	QWidget::showEvent(event);
 }
 
 void QtChatWindow::setUnreadMessageCount(int count) {
 	if (unreadCount_ != count) {
 		unreadCount_ = count;
 		updateTitleWithUnreadCount();
 		emit countUpdated();
 	}
 }
 
 void QtChatWindow::setContactChatState(ChatState::ChatStateType state) {
 	contactIsTyping_ = (state == ChatState::Composing);
 	emit titleUpdated();
 }
 
 QtTabbable::AlertType QtChatWindow::getWidgetAlertState() {
 	if (contactIsTyping_) {
 		return ImpendingActivity;
 	}
 	if (unreadCount_ > 0) {
 		return WaitingActivity;
 	}
 	return NoActivity;
 }
 
 void QtChatWindow::setName(const std::string& name) {
 	contact_ = P2QSTRING(name);
 	updateTitleWithUnreadCount();
 }
@@ -672,94 +678,112 @@ void QtChatWindow::moveEvent(QMoveEvent*) {
 	emit geometryChanged();
 }
 
 void QtChatWindow::dragEnterEvent(QDragEnterEvent *event) {
 	if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() == 1) {
 		// TODO: check whether contact actually supports file transfer
 		event->acceptProposedAction();
 	}
 }
 
 void QtChatWindow::dropEvent(QDropEvent *event) {
 	if (event->mimeData()->urls().size() == 1) {
 		onSendFileRequest(Q2PSTRING(event->mimeData()->urls().at(0).toLocalFile()));
 	} else {
 		addSystemMessage("Sending of multiple files at once isn't supported at this time.");
 	}
 }
 
 void QtChatWindow::replaceLastMessage(const std::string& message) {
 	messageLog_->replaceLastMessage(P2QSTRING(Linkify::linkify(message)));
 }
 
 void QtChatWindow::setAvailableOccupantActions(const std::vector<OccupantAction>& actions) {
 	treeWidget_->setAvailableOccupantActions(actions);
 }
 
 void QtChatWindow::setSubject(const std::string& subject) {
 	//subject_->setVisible(!subject.empty());
 	subject_->setText(P2QSTRING(subject));
 }
 
 void QtChatWindow::handleActionButtonClicked() {
 	QMenu contextMenu;
 	QAction* changeSubject = contextMenu.addAction(tr("Change subject"));
 	QAction* configure = contextMenu.addAction(tr("Configure room"));
+	QAction* affiliations = contextMenu.addAction(tr("Edit affiliations"));
 	QAction* destroy = contextMenu.addAction(tr("Destroy room"));
 	QAction* invite = contextMenu.addAction(tr("Invite person to this room"));
 	QAction* result = contextMenu.exec(QCursor::pos());
 	if (result == changeSubject) {
 		bool ok;
 		QString subject = QInputDialog::getText(this, tr("Change room subject"), tr("New subject:"), QLineEdit::Normal, subject_->text(), &ok);
 		if (ok) {
 			onChangeSubjectRequest(Q2PSTRING(subject));
 		}
 	}
 	else if (result == configure) {
 		onConfigureRequest(Form::ref());
 	}
+	else if (result == affiliations) {
+		if (!affiliationEditor_) {
+			onGetAffiliationsRequest();
+			affiliationEditor_ = new QtAffiliationEditor(this);
+			connect(affiliationEditor_, SIGNAL(accepted()), this, SLOT(handleAffiliationEditorAccepted()));
+		}
+		affiliationEditor_->show();
+	}
 	else if (result == destroy) {
 		onDestroyRequest();
 	}
 	else if (result == invite) {
 		bool ok;
 		QString jid = QInputDialog::getText(this, tr("Enter person's address"), tr("Address:"), QLineEdit::Normal, "", &ok);
 		if (ok) {
 			onInvitePersonToThisMUCRequest(JID(Q2PSTRING(jid)), "");
 		}
 	}
 }
 
+void QtChatWindow::handleAffiliationEditorAccepted() {
+	onChangeAffiliationsRequest(affiliationEditor_->getChanges());
+}
+
+void QtChatWindow::setAffiliations(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {
+	if (!affiliationEditor_) return;
+	affiliationEditor_->setAffiliations(affiliation, jids);
+}
+
 void QtChatWindow::showRoomConfigurationForm(Form::ref form) {
-	if (mucConfigurationWindow) {
-		delete mucConfigurationWindow.data();
+	if (mucConfigurationWindow_) {
+		delete mucConfigurationWindow_.data();
 	}
-	mucConfigurationWindow = new QtMUCConfigurationWindow(form);
-	mucConfigurationWindow->onFormComplete.connect(boost::bind(boost::ref(onConfigureRequest), _1));
-	mucConfigurationWindow->onFormCancelled.connect(boost::bind(boost::ref(onConfigurationFormCancelled)));
+	mucConfigurationWindow_ = new QtMUCConfigurationWindow(form);
+	mucConfigurationWindow_->onFormComplete.connect(boost::bind(boost::ref(onConfigureRequest), _1));
+	mucConfigurationWindow_->onFormCancelled.connect(boost::bind(boost::ref(onConfigurationFormCancelled)));
 }
 
 void QtChatWindow::addMUCInvitation(const JID& jid, const std::string& reason, const std::string& password) {
 	bool accepted = false;
 	QMessageBox msgBox;
 	msgBox.setText(QString("You have been invited to the room %1 by %2.").arg(P2QSTRING(jid.toString())).arg(contact_));
 	QString reasonString;
 	if (!reason.empty()) {
 		reasonString = QString("\"%1\"").arg(P2QSTRING(reason));
 	}
 	msgBox.setInformativeText(QString("Accept invitation from %1 to enter %2?\n%3").arg(contact_).arg(P2QSTRING(jid.toString())).arg(reasonString));
 	msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
 	msgBox.setDefaultButton(QMessageBox::Yes);
 	int ret = msgBox.exec();
 	switch (ret) {
 	   case QMessageBox::Yes:
 	       accepted = true;
 	       break;
 	   default:
 	       break;
 	 }
 	if (accepted) {
 		eventStream_->send(boost::make_shared<JoinMUCUIEvent>(jid));
 	}
 }
 
 }