1 files changed, 25 insertions, 1 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index e413d92..30e85ad 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -45,117 +45,122 @@ MUCController::MUCController (
 		const JID& self,
 		MUC::ref muc,
 		const boost::optional<std::string>& password,
 		const std::string &nick, 
 		StanzaChannel* stanzaChannel, 
 		IQRouter* iqRouter, 
 		ChatWindowFactory* chatWindowFactory, 
 		PresenceOracle* presenceOracle,
 		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));
+	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_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));
 	muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));
 	muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));
+	muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));
 	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;
 	/* FIXME: all of these should be conditional */
 	if (item) {
 		actions.push_back(ChatWindow::Kick);
+		actions.push_back(ChatWindow::Ban);
 		actions.push_back(ChatWindow::MakeModerator);
 		actions.push_back(ChatWindow::MakeParticipant);
 		actions.push_back(ChatWindow::MakeVisitor);
 	}
 	chatWindow_->setAvailableOccupantActions(actions);
 }
 
 void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {
 	switch (action) {
 		case ChatWindow::Kick: muc_->kickOccupant(item->getJID());break;
+		case ChatWindow::Ban: muc_->changeAffiliation(item->getJID(), MUCOccupant::Outcast);break;
 		case ChatWindow::MakeModerator: muc_->changeOccupantRole(item->getJID(), MUCOccupant::Moderator);break;
 		case ChatWindow::MakeParticipant: muc_->changeOccupantRole(item->getJID(), MUCOccupant::Participant);break;
 		case ChatWindow::MakeVisitor: muc_->changeOccupantRole(item->getJID(), MUCOccupant::Visitor);break;
 	}
 }
 
 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) {
@@ -169,71 +174,71 @@ void MUCController::rejoin() {
 bool MUCController::isJoined() {
 	return joined_;
 }
 
 const std::string& MUCController::getNick() {
 	return nick_;
 }
 
 void MUCController::handleJoinTimeoutTick() {
 	receivedActivity();
 	chatWindow_->addSystemMessage(str(format(QT_TRANSLATE_NOOP("", "Room %1% is not responding. This operation may never complete.")) % toJID_.toString()));
 }
 
 void MUCController::receivedActivity() {
 	if (loginCheckTimer_) {
 		loginCheckTimer_->stop();
 	}
 }
 
 void MUCController::handleJoinFailed(boost::shared_ptr<ErrorPayload> error) {
 	receivedActivity();
 	std::string errorMessage = QT_TRANSLATE_NOOP("", "Unable to enter this room");
 	std::string rejoinNick;
 	if (error) {
 		switch (error->getCondition()) {
 		case ErrorPayload::Conflict:
 			rejoinNick = nick_ + "_";
 			errorMessage = str(format(QT_TRANSLATE_NOOP("", "Unable to enter this room as %1%, retrying as %2%")) % nick_ % rejoinNick);
 			break;
 		case ErrorPayload::JIDMalformed: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "No nickname specified");
 			break;
 		case ErrorPayload::NotAuthorized: 
 			errorMessage += ": ";
-			errorMessage += QT_TRANSLATE_NOOP("", "A password needed");
+			errorMessage += QT_TRANSLATE_NOOP("", "A password is needed");
 			break;
 		case ErrorPayload::RegistrationRequired: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "Only members may enter"); 
 			break;
 		case ErrorPayload::Forbidden: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "You are banned from the room"); 
 			break;
 		case ErrorPayload::ServiceUnavailable: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "The room is full");
 			break;
 		case ErrorPayload::ItemNotFound: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "The room does not exist");
 			break;
 			
 		default: break;
 		}
 	}
 	errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't join room: %1%.")) % errorMessage);
 	chatWindow_->addErrorMessage(errorMessage);
 	if (!rejoinNick.empty()) {
 		nick_ = rejoinNick;
 		parting_ = true;
 		rejoin();
 	}
 }
 
 void MUCController::handleJoinComplete(const std::string& nick) {
 	receivedActivity();
 	joined_ = true;
 	std::string joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have entered room %1% as %2%.")) % toJID_.toString() % nick);
 	nick_ = nick;
@@ -598,36 +603,55 @@ void MUCController::handleConfigureRequest(Form::ref 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::handleOccupantRoleChangeFailed(ErrorPayload::ref error, const JID&, MUCOccupant::Role) {
 	std::string errorMessage = getErrorMessage(error);
 	errorMessage = str(format(QT_TRANSLATE_NOOP("", "Occupant role change 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 MUCController::handleGetAffiliationsRequest() {
+	muc_->requestAffiliationList(MUCOccupant::Owner);
+	muc_->requestAffiliationList(MUCOccupant::Admin);
+	muc_->requestAffiliationList(MUCOccupant::Member);
+	muc_->requestAffiliationList(MUCOccupant::Outcast);
+}
+
+typedef std::pair<MUCOccupant::Affiliation, JID> AffiliationChangePair;
+
+void MUCController::handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes) {
+	foreach (const AffiliationChangePair& change, changes) {
+		muc_->changeAffiliation(change.second, change.first);
+	}
+}
+
+void MUCController::handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {
+	chatWindow_->setAffiliations(affiliation, jids);
+}
+
 }