Fix attempting to start impromptu chat when impromptu not supported.

Test-Information: Connect to a server where impromptu is NOT supported. Confirm that adding multiple users by dragging or typing into the JID box is not allowed. Connect to a server where impromptu is supported. Confirm that it is still possible to drag multiple users and add multiple users by typing into the JID box. Change-Id: Ibb4c1f7d6a5820f7ccf3629c1e0d30a441d9d159
author: Richard Maudsley <richard.maudsley@isode.com> 2014-06-30 10:42:05 (GMT)
committer: Swift Review <review@swift.im> 2014-07-09 12:53:37 (GMT)
commit: 1edfc36235cc67d303ceb2bcf0630affc509f2f7 (patch)
tree: 0ca86a9e5e0dbcd3876ce91b4bf4feec5321c9c9 /Swift
parent: 05d9e618e4c756e50b633448f0546614a645a13d (diff)
download: swift-contrib-1edfc36235cc67d303ceb2bcf0630affc509f2f7.zip
swift-contrib-1edfc36235cc67d303ceb2bcf0630affc509f2f7.tar.bz2
4 files changed, 17 insertions, 8 deletions
diff --git a/Swift/QtUI/UserSearch/QtContactListWidget.cpp b/Swift/QtUI/UserSearch/QtContactListWidget.cpp
index 4adc929..6504f3e 100644
--- a/Swift/QtUI/UserSearch/QtContactListWidget.cpp
+++ b/Swift/QtUI/UserSearch/QtContactListWidget.cpp
@@ -1,97 +1,101 @@
 /*
  * Copyright (c) 2013 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
  * Copyright (c) 2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swift/QtUI/UserSearch/QtContactListWidget.h>
 
 #include <Swift/QtUI/UserSearch/ContactListModel.h>
 #include <Swift/QtUI/UserSearch/ContactListDelegate.h>
 #include <Swift/QtUI/QtUISettingConstants.h>
 #include <Swift/Controllers/Settings/SettingsProvider.h>
 #include <Swift/QtUI/QtVCardWidget/QtRemovableItemDelegate.h>
 
 #include <QHeaderView>
 
 namespace Swift {
 
 QtContactListWidget::QtContactListWidget(QWidget* parent, SettingsProvider* settings) : QTreeView(parent), settings_(settings), limited_(false) {
 	contactListModel_ = new ContactListModel(true);
 	setModel(contactListModel_);
 
 	connect(contactListModel_, SIGNAL(onListChanged(std::vector<Contact::ref>)), this, SIGNAL(onListChanged(std::vector<Contact::ref>)));
 	connect(contactListModel_, SIGNAL(onJIDsDropped(std::vector<JID>)), this, SIGNAL(onJIDsAdded(std::vector<JID>)));
 
 	setSelectionMode(QAbstractItemView::SingleSelection);
 	setSelectionBehavior(QAbstractItemView::SelectRows);
 	setUniformRowHeights(true);
 
 	setAlternatingRowColors(true);
 	setIndentation(0);
 	setHeaderHidden(true);
 	setExpandsOnDoubleClick(false);
 	setItemsExpandable(false);
 	setEditTriggers(QAbstractItemView::DoubleClicked);
 
 	contactListDelegate_ = new ContactListDelegate(settings->getSetting(QtUISettingConstants::COMPACT_ROSTER));
 	removableItemDelegate_ = new QtRemovableItemDelegate(style());
 
 	setItemDelegateForColumn(0, contactListDelegate_);
 	setItemDelegateForColumn(1, removableItemDelegate_);
 
 	header()->resizeSection(1, removableItemDelegate_->sizeHint(QStyleOptionViewItem(), QModelIndex()).width());
 
 	header()->setStretchLastSection(false);
 #if QT_VERSION >= 0x050000
 	header()->setSectionResizeMode(0, QHeaderView::Stretch);
 #else
 	header()->setResizeMode(0, QHeaderView::Stretch);
 #endif
 }
 
 QtContactListWidget::~QtContactListWidget() {
 	delete contactListDelegate_;
 	delete removableItemDelegate_;
 }
 
 void QtContactListWidget::setList(const std::vector<Contact::ref>& list) {
 	contactListModel_->setList(list);
 }
 
 std::vector<Contact::ref> QtContactListWidget::getList() const {
 	return contactListModel_->getList();
 }
 
 Contact::ref QtContactListWidget::getContact(const size_t i) {
 	return contactListModel_->getContact(i);
 }
 
 void QtContactListWidget::setMaximumNoOfContactsToOne(bool limited) {
 	limited_ = limited;
 }
 
+bool QtContactListWidget::isFull() const {
+	return limited_ && (getList().size() == 1);
+}
+
 void QtContactListWidget::updateContacts(const std::vector<Contact::ref>& contactUpdates) {
 	std::vector<Contact::ref> contacts = contactListModel_->getList();
 	foreach(const Contact::ref& contactUpdate, contactUpdates) {
 		for(size_t n = 0; n < contacts.size(); n++) {
 			if (contactUpdate->jid == contacts[n]->jid) {
 				contacts[n] = contactUpdate;
 				break;
 			}
 		}
 	}
 	contactListModel_->setList(contacts);
 }
 
 void QtContactListWidget::handleSettingsChanged(const std::string&) {
 	contactListDelegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));
 }
 
 }
diff --git a/Swift/QtUI/UserSearch/QtContactListWidget.h b/Swift/QtUI/UserSearch/QtContactListWidget.h
index 601d320..112f3ee 100644
--- a/Swift/QtUI/UserSearch/QtContactListWidget.h
+++ b/Swift/QtUI/UserSearch/QtContactListWidget.h
@@ -1,62 +1,63 @@
 /*
  * Copyright (c) 2013 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
  * Copyright (c) 2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <vector>
 
 #include <QTreeView>
 
 #include <Swift/Controllers/Contact.h>
 #include <Swiften/Base/Log.h>
 
 #include <QDragEnterEvent>
 #include <QDragMoveEvent>
 #include <QDropEvent>
 
 namespace Swift {
 
 class ContactListDelegate;
 class ContactListModel;
 class SettingsProvider;
 class QtRemovableItemDelegate;
 
 class QtContactListWidget : public QTreeView {
 	Q_OBJECT
 public:
 	QtContactListWidget(QWidget* parent, SettingsProvider* settings);
 	virtual ~QtContactListWidget();
 
 	void setList(const std::vector<Contact::ref>& list);
 	std::vector<Contact::ref> getList() const;
 	Contact::ref getContact(const size_t i);
 	void setMaximumNoOfContactsToOne(bool limited);
+	bool isFull() const;
 
 public slots:
 	void updateContacts(const std::vector<Contact::ref>& contactUpdates);
 
 signals:
 	void onListChanged(std::vector<Contact::ref> list);
 	void onJIDsAdded(const std::vector<JID>& jids);
 
 private:
 	void handleSettingsChanged(const std::string&);
 
 private:
 	SettingsProvider* settings_;
 	ContactListModel* contactListModel_;
 	ContactListDelegate* contactListDelegate_;
 	QtRemovableItemDelegate* removableItemDelegate_;
 	bool limited_;
 };
 
 }
diff --git a/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp b/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp
index 597c88b..8ea49c4 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp
+++ b/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp
@@ -1,98 +1,100 @@
 /*
  * Copyright (c) 2013 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
  * Copyright (c) 2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h"
 
 #include <QMessageBox>
 #include <QMimeData>
 #include <QUrl>
 
 #include "Swift/QtUI/QtSwiftUtil.h"
 #include <Swift/Controllers/Settings/SettingsProvider.h>
 #include <Swift/QtUI/UserSearch/QtContactListWidget.h>
 #include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>
 
 namespace Swift {
 
 QtUserSearchFirstMultiJIDPage::QtUserSearchFirstMultiJIDPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {
 	setupUi(this);
 	setTitle(title);
 	QString introText = "";
 	switch (type) {
 		case UserSearchWindow::AddContact:
 			introText = tr("Add another user to your contact list");
 			break;
 		case UserSearchWindow::ChatToContact:
 			introText = tr("Chat to another user");
 			break;
 		case UserSearchWindow::InviteToChat:
 			introText = tr("Invite contact to chat");
 			break;
 	}
 
 	setSubTitle(QString(tr("%1. If you know their address you can enter it directly, or you can search for them.")).arg(introText));
 
 	contactList_ = new QtContactListWidget(this, settings);
 	horizontalLayout_5->addWidget(contactList_);
 
 	jid_ = new QtSuggestingJIDInput(this, settings);
 	horizontalLayout_6->insertWidget(0, jid_);
 
 	connect(contactList_, SIGNAL(onListChanged(std::vector<Contact::ref>)), this, SLOT(emitCompletenessCheck()));
 	connect(jid_, SIGNAL(editingDone()), this, SLOT(handleEditingDone()));
 
 	setAcceptDrops(true);
 }
 
 bool QtUserSearchFirstMultiJIDPage::isComplete() const {
 	return !contactList_->getList().empty();
 }
 
 void QtUserSearchFirstMultiJIDPage::reset() {
 	reason_->clear();
 }
 
 void QtUserSearchFirstMultiJIDPage::emitCompletenessCheck() {
 	emit completeChanged();
 }
 
 void QtUserSearchFirstMultiJIDPage::handleEditingDone() {
 	addContactButton_->setFocus();
 }
 
 void QtUserSearchFirstMultiJIDPage::dragEnterEvent(QDragEnterEvent *event) {
 	if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid-list")
 		|| event->mimeData()->hasFormat("application/vnd.swift.contact-jid-muc")) {
-			event->acceptProposedAction();
+			if (!contactList_->isFull()) {
+				event->acceptProposedAction();
+			}
 	}
 }
 
 void QtUserSearchFirstMultiJIDPage::dropEvent(QDropEvent *event) {
 	if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid-list")) {
 		QByteArray dataBytes = event->mimeData()->data("application/vnd.swift.contact-jid-list");
 		QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);
 		std::vector<JID> jids;
 		while (!dataStream.atEnd()) {
 			QString jidString;
 			dataStream >> jidString;
 			jids.push_back(Q2PSTRING(jidString));
 		}
 		onJIDsDropped(jids);
 	} else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid-muc")) {
 		QMessageBox* messageBox = new QMessageBox(this);
 		messageBox->setText(tr("You can't invite a room to chat."));
 		messageBox->setWindowTitle(tr("Error inviting room to chat"));
 		messageBox->show();
 	}
 }
 
 }
diff --git a/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp b/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
index 40b4e28..260ccfe 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
+++ b/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
@@ -1,586 +1,588 @@
 /*
  * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "Swift/QtUI/UserSearch/QtUserSearchWindow.h"
 
 #include <QItemDelegate>
 #include <QModelIndex>
 #include <QWizardPage>
 #include <QMovie>
 #include <boost/bind.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
 #include <Swiften/Base/foreach.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/AddContactUIEvent.h>
 #include <Swift/Controllers/UIEvents/CreateImpromptuMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/QtUI/UserSearch/UserSearchModel.h>
 #include <Swift/QtUI/UserSearch/UserSearchDelegate.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtFormResultItemModel.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchFieldsPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchResultsPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchDetailsPage.h>
 #include <Swift/QtUI/UserSearch/QtContactListWidget.h>
 
 #include <Swiften/Base/Log.h>
 
 namespace Swift {
 
 QtUserSearchWindow::QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider) : eventStream_(eventStream), type_(type), model_(NULL), firstMultiJIDPage_(NULL), settings_(settingsProvider), searchNext_(false), supportsImpromptu_(false) {
 	setupUi(this);
 #ifndef Q_OS_MAC
 	setWindowIcon(QIcon(":/logo-icon-16.png"));
 #endif
 	QString title;
 	switch(type) {
 		case AddContact:
 			title = tr("Add Contact");
 			break;
 		case ChatToContact:
 			title = tr("Chat to Users");
 			break;
 		case InviteToChat:
 			title = tr("Add Users to Chat");
 			break;
 	}
 	setWindowTitle(title);
 
 	delegate_ = new UserSearchDelegate();
 
 	setFirstPage(title);
 	setSecondPage();
 	setThirdPage();
 
 	detailsPage_ = new QtUserSearchDetailsPage(groups);
 	setPage(4, detailsPage_);
 
 	connect(this, SIGNAL(currentIdChanged(int)), this, SLOT(handleCurrentChanged(int)));
 	connect(this, SIGNAL(accepted()), this, SLOT(handleAccepted()));
 	clear();
 }
 
 QtUserSearchWindow::~QtUserSearchWindow() {
 	delete model_;
 }
 
 void QtUserSearchWindow::handleCurrentChanged(int page) {
 	searchNext_ = false;
 	if (firstMultiJIDPage_) {
 		firstMultiJIDPage_->reset();
 	}
 	resultsPage_->emitCompletenessCheck();
 	if (page == 1 && lastPage_ == 3) {
 		addSearchedJIDToList(getContactJID());
 		setSecondPage();
 	}
 	else if (page == 2 && lastPage_ == 1) {
 		setError("");
 		/* next won't be called if JID is selected */
 		JID server = getServerToSearch();
 		clearForm();
 		onFormRequested(server);
 		setThirdPage();
 	}
 	else if (page == 3 && lastPage_ == 2) {
 		JID server = getServerToSearch();
 		handleSearch();
 
 		if (type_ == AddContact) {
 			bool remote = firstPage_->byRemoteSearch_->isChecked();
 			firstPage_->byRemoteSearch_->setChecked(remote);
 			firstPage_->service_->setEditText(P2QSTRING(server.toString()));
 		} else {
 			bool remote = firstMultiJIDPage_->byRemoteSearch_->isChecked();
 			setFirstPage();
 			firstMultiJIDPage_->byRemoteSearch_->setChecked(remote);
 			firstMultiJIDPage_->service_->setEditText(P2QSTRING(server.toString()));
 		}
 	}
 	else if (page == 4) {
 		detailsPage_->clear();
 		detailsPage_->setJID(getContactJID());
 		onNameSuggestionRequested(getContactJID());
 	}
 	lastPage_ = page;
 }
 
 JID QtUserSearchWindow::getServerToSearch() {
 	if (type_ == AddContact) {
 		return firstPage_->byRemoteSearch_->isChecked() ? JID(Q2PSTRING(firstPage_->service_->currentText().trimmed())) : myServer_;
 	} else {
 		return firstMultiJIDPage_->byRemoteSearch_->isChecked() ? JID(Q2PSTRING(firstMultiJIDPage_->service_->currentText().trimmed())) : myServer_;
 	}
 }
 
 void QtUserSearchWindow::handleAccepted() {
 	JID jid;
 	std::vector<JID> jids;
 	switch(type_) {
 		case AddContact:
 			jid = getContactJID();
 			eventStream_->send(boost::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));
 			break;
 		case ChatToContact:
 			if (contactVector_.size() == 1) {
 				boost::shared_ptr<UIEvent> event(new RequestChatUIEvent(contactVector_[0]->jid));
 				eventStream_->send(event);
 				break;
 			}
 
 			foreach(Contact::ref contact, contactVector_) {
 				jids.push_back(contact->jid);
 			}
 
 			eventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(jids, JID(), Q2PSTRING(firstMultiJIDPage_->reason_->text())));
 			break;
 		case InviteToChat:
 			foreach(Contact::ref contact, contactVector_) {
 				jids.push_back(contact->jid);
 			}
 			eventStream_->send(boost::make_shared<InviteToMUCUIEvent>(roomJID_, jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));
 			break;
 	}
 }
 
 void QtUserSearchWindow::handleContactSuggestionRequested(const QString& text) {
 	std::string stdText = Q2PSTRING(text);
 	onContactSuggestionsRequested(stdText);
 }
 
 void QtUserSearchWindow::addContact() {
 	if (!!firstMultiJIDPage_->jid_->getContact()) {
 		contactVector_.push_back(firstMultiJIDPage_->jid_->getContact());
 	}
 	firstMultiJIDPage_->contactList_->setList(contactVector_);
 	firstMultiJIDPage_->emitCompletenessCheck();
 	if (type_ == ChatToContact) {
 		firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));
 	}
 }
 
 int QtUserSearchWindow::nextId() const {
 	if (type_ == AddContact) {
 		switch (currentId()) {
 			case 1: return firstPage_->byJID_->isChecked() ? (type_ == AddContact ? 4 : -1) : 2;
 			case 2: return 3;
 			case 3: return type_ == AddContact ? 4 : -1;
 			case 4: return -1;
 			default: return -1;
 		}
 	} else {
 		switch (currentId()) {
 			case 1: return searchNext_ ? 2 : -1;
 			case 2: return 3;
 			case 3: return 1;
 			case 4: return -1;
 			default: return -1;
 		}
 	}
 }
 
 void QtUserSearchWindow::handleFirstPageRadioChange() {
 	if (firstPage_->byJID_->isChecked()) {
 		firstPage_->jid_->setText("");
 		firstPage_->jid_->setEnabled(true);
 		firstPage_->service_->setEnabled(false);
 		restart();
 	}
 	else if (firstPage_->byRemoteSearch_->isChecked()) {
 		firstPage_->service_->setEditText("");
 		firstPage_->jid_->setEnabled(false);
 		firstPage_->service_->setEnabled(true);
 		//firstPage_->jid_->setText("");
 		restart();
 	}
 	else {
 		firstPage_->jid_->setEnabled(false);
 		firstPage_->service_->setEnabled(false);
 		restart();
 	}
 }
 
 void QtUserSearchWindow::handleSearch() {
 	boost::shared_ptr<SearchPayload> search(new SearchPayload());
 	if (fieldsPage_->getFormWidget()) {
 		search->setForm(fieldsPage_->getFormWidget()->getCompletedForm());
 	} else {
 		if (fieldsPage_->nickInput_->isEnabled()) {
 			search->setNick(Q2PSTRING(fieldsPage_->nickInput_->text()));
 		}
 		if (fieldsPage_->firstInput_->isEnabled()) {
 			search->setFirst(Q2PSTRING(fieldsPage_->firstInput_->text()));
 		}
 		if (fieldsPage_->lastInput_->isEnabled()) {
 			search->setLast(Q2PSTRING(fieldsPage_->lastInput_->text()));
 		}
 		if (fieldsPage_->emailInput_->isEnabled()) {
 			search->setEMail(Q2PSTRING(fieldsPage_->emailInput_->text()));
 		}
 	}
 	onSearchRequested(search, getServerToSearch());
 }
 
 JID QtUserSearchWindow::getContactJID() const {
 	JID jid;
 
 	bool useSearchResult;
 	if (type_ == AddContact) {
 		useSearchResult = !firstPage_->byJID_->isChecked();
 	} else {
 		useSearchResult = true;
 	}
 
 	if (useSearchResult) {
 		if (dynamic_cast<UserSearchModel*>(model_)) {
 			UserSearchResult* userItem = static_cast<UserSearchResult*>(resultsPage_->results_->currentIndex().internalPointer());
 			if (userItem) { /* Remember to leave this if we change to dynamic cast */
 				jid = userItem->getJID();
 			}
 		} else {
 			int row = resultsPage_->results_->currentIndex().row();
 
 			Form::FormItem item = dynamic_cast<QtFormResultItemModel*>(model_)->getForm()->getItems().at(row);
 			JID fallbackJid;
 			foreach(FormField::ref field, item) {
 				if (field->getType() == FormField::JIDSingleType) {
 					jid = JID(field->getJIDSingleValue());
 					break;
 				}
 				if (field->getName() == "jid") {
 					fallbackJid = field->getValues()[0];
 				}
 			}
 			if (!jid.isValid()) {
 				jid = fallbackJid;
 			}
 		}
 	}
 	else {
 		jid = JID(Q2PSTRING(firstPage_->jid_->text().trimmed()));
 	}
 	return jid;
 }
 
 void QtUserSearchWindow::addSearchedJIDToList(const JID& jid) {
-	Contact::ref contact = boost::make_shared<Contact>(jid, jid.toString(), StatusShow::None, "");
-	contactVector_.push_back(contact);
-	firstMultiJIDPage_->contactList_->setList(contactVector_);
-	firstMultiJIDPage_->emitCompletenessCheck();
-	if (type_ == ChatToContact) {
-		firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));
-	}
+	std::vector<JID> jids;
+	jids.push_back(jid);
+	handleJIDsAdded(jids);
 }
 
 void QtUserSearchWindow::show() {
 	clear();
 	QWidget::show();
 }
 
 void QtUserSearchWindow::addSavedServices(const std::vector<JID>& services) {
 	if (type_ == AddContact) {
 		firstPage_->service_->clear();
 		foreach (JID jid, services) {
 			firstPage_->service_->addItem(P2QSTRING(jid.toString()));
 		}
 		firstPage_->service_->clearEditText();
 	} else {
 		firstMultiJIDPage_->service_->clear();
 		foreach (JID jid, services) {
 			firstMultiJIDPage_->service_->addItem(P2QSTRING(jid.toString()));
 		}
 		firstMultiJIDPage_->service_->clearEditText();
 	}
 }
 
 void QtUserSearchWindow::setSearchFields(boost::shared_ptr<SearchPayload> fields) {
 	fieldsPage_->fetchingThrobber_->hide();
 	fieldsPage_->fetchingThrobber_->movie()->stop();
 	fieldsPage_->fetchingLabel_->hide();
 
 	fieldsPage_->instructionsLabel_->setText(fields->getInstructions() ? P2QSTRING(fields->getInstructions().get()) : "Enter search terms");
 	if (fields->getForm()) {
 		fieldsPage_->setFormWidget(new QtFormWidget(fields->getForm(), fieldsPage_));
 	} else {
 		fieldsPage_->setFormWidget(NULL);
 		bool enabled[8] = {fields->getNick(), fields->getNick(), fields->getFirst(), fields->getFirst(), fields->getLast(), fields->getLast(), fields->getEMail(), fields->getEMail()};
 		QWidget* legacySearchWidgets[8] = {fieldsPage_->nickInputLabel_, fieldsPage_->nickInput_, fieldsPage_->firstInputLabel_, fieldsPage_->firstInput_, fieldsPage_->lastInputLabel_, fieldsPage_->lastInput_, fieldsPage_->emailInputLabel_, fieldsPage_->emailInput_};
 		for (int i = 0; i < 8; i++) {
 			legacySearchWidgets[i]->setVisible(enabled[i]);
 			legacySearchWidgets[i]->setEnabled(enabled[i]);
 		}
 	}
 	fieldsPage_->emitCompletenessCheck();
 }
 
 void QtUserSearchWindow::setNameSuggestions(const std::vector<std::string>& suggestions) {
 	if (detailsPage_) {
 		detailsPage_->setNameSuggestions(suggestions);
 	}
 }
 
 void QtUserSearchWindow::prepopulateJIDAndName(const JID& jid, const std::string& name) {
 	firstPage_->jid_->setText(P2QSTRING(jid.toBare().toString()));
 	detailsPage_->setJID(jid);
 	lastPage_ = 1;
 	restart();
 	next();
 	detailsPage_->setName(name);
 }
 
 void QtUserSearchWindow::setContactSuggestions(const std::vector<Contact::ref>& suggestions) {
 	if (type_ == AddContact) {
 		firstPage_->jid_->setSuggestions(suggestions);
 	} else {
 		firstMultiJIDPage_->jid_->setSuggestions(suggestions);
 	}
 }
 
 void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {
 	foreach(JID jid, jids) {
 		addSearchedJIDToList(jid);
 	}
 	onJIDUpdateRequested(jids);
 }
 
 void QtUserSearchWindow::setRoomJID(const JID& roomJID) {
 	roomJID_ = roomJID;
 }
 
 std::string QtUserSearchWindow::getReason() const {
 	return Q2PSTRING(firstMultiJIDPage_->reason_->text());
 }
 
 std::vector<JID> QtUserSearchWindow::getJIDs() const {
 	std::vector<JID> jids;
 	foreach (Contact::ref contact, contactVector_) {
 		jids.push_back(contact->jid);
 	}
 	return jids;
 }
 
 void QtUserSearchWindow::setCanStartImpromptuChats(bool supportsImpromptu) {
 	supportsImpromptu_ = supportsImpromptu;
 	if (type_ == ChatToContact) {
 		firstMultiJIDPage_->contactList_->setMaximumNoOfContactsToOne(!supportsImpromptu_);
 	}
 }
 
 void QtUserSearchWindow::updateContacts(const std::vector<Contact::ref>& contacts) {
 	if (type_ != AddContact) {
 		firstMultiJIDPage_->contactList_->updateContacts(contacts);
 	}
 }
 
 void QtUserSearchWindow::addContacts(const std::vector<Contact::ref>& contacts) {
 	if (type_ != AddContact) {
 		/* prevent duplicate JIDs from appearing in the contact list */
 		foreach (Contact::ref newContact, contacts) {
 			bool found = false;
 			foreach (Contact::ref oldContact, contactVector_) {
 				if (newContact->jid == oldContact->jid) {
 					found = true;
 					break;
 				}
 			}
 			if (!found) {
 				contactVector_.push_back(newContact);
 			}
 		}
+		if (!supportsImpromptu_ && contactVector_.size() > 1) {
+			contactVector_.resize(1); /* can't chat with more than one user */
+		}
 		firstMultiJIDPage_->contactList_->setList(contactVector_);
 		firstMultiJIDPage_->emitCompletenessCheck();
+		if (type_ == ChatToContact) {
+			firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? true : (contactVector_.size() < 1));
+		}
 	}
 }
 
 void QtUserSearchWindow::setCanSupplyDescription(bool allowed) {
 	firstMultiJIDPage_->label->setVisible(allowed);
 	firstMultiJIDPage_->reason_->setVisible(allowed);
 }
 
 void QtUserSearchWindow::handleAddViaSearch() {
 	searchNext_ = true;
 	next();
 }
 
 void QtUserSearchWindow::handleListChanged(std::vector<Contact::ref> list) {
 	contactVector_ = list;
 	if (type_ == ChatToContact) {
 		firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));
 	}
 }
 
 void QtUserSearchWindow::handleJIDsAdded(std::vector<JID> jids) {
 	onJIDAddRequested(jids);
 }
 
 void QtUserSearchWindow::setResults(const std::vector<UserSearchResult>& results) {
 	UserSearchModel *newModel = new UserSearchModel();
 	newModel->setResults(results);
 	resultsPage_->results_->setModel(newModel);
 	resultsPage_->results_->setItemDelegate(delegate_);
 	resultsPage_->results_->setHeaderHidden(true);
 	delete model_;
 	model_ = newModel;
 	resultsPage_->setNoResults(model_->rowCount() == 0);
 	resultsPage_->emitCompletenessCheck();
 }
 
 void QtUserSearchWindow::setResultsForm(Form::ref results) {
 	QtFormResultItemModel *newModel = new QtFormResultItemModel(this);
 	newModel->setForm(results);
 	resultsPage_->results_->setModel(newModel);
 	resultsPage_->results_->setItemDelegate(new QItemDelegate());
 	resultsPage_->results_->setHeaderHidden(false);
 #if QT_VERSION >= 0x050000
 	resultsPage_->results_->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
 #else
 	resultsPage_->results_->header()->setResizeMode(QHeaderView::ResizeToContents);
 #endif
 	delete model_;
 	model_ = newModel;
 	resultsPage_->setNoResults(model_->rowCount() == 0);
 	resultsPage_->emitCompletenessCheck();
 }
 
 void QtUserSearchWindow::setSelectedService(const JID& jid) {
 	myServer_ = jid;
 }
 
 void QtUserSearchWindow::setFirstPage(QString title) {
 	if (page(1) != 0) {
 		removePage(1);
 	}
 	if (type_ == AddContact) {
 		firstPage_ = new QtUserSearchFirstPage(type_, title.isEmpty() ? firstPage_->title() : title, settings_);
 		connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));
 		connect(firstPage_->byJID_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));
 		connect(firstPage_->byLocalSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));
 		connect(firstPage_->byRemoteSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));
 #if QT_VERSION >= 0x040700
 		firstPage_->jid_->setPlaceholderText(tr("alice@wonderland.lit"));
 #endif
 		firstPage_->service_->setEnabled(false);
 		setPage(1, firstPage_);
 	} else {
 		firstMultiJIDPage_ = new QtUserSearchFirstMultiJIDPage(type_, title.isEmpty() ? firstMultiJIDPage_->title() : title, settings_);
 		connect(firstMultiJIDPage_->addContactButton_, SIGNAL(clicked()), this, SLOT(addContact()));
 		connect(firstMultiJIDPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));
 		firstMultiJIDPage_->jid_->onUserSelected.connect(boost::bind(&QtUserSearchWindow::addSearchedJIDToList, this, _1));
 		connect(firstMultiJIDPage_->addViaSearchButton_, SIGNAL(clicked()), this, SLOT(handleAddViaSearch()));
 		connect(firstMultiJIDPage_->contactList_, SIGNAL(onListChanged(std::vector<Contact::ref>)), this, SLOT(handleListChanged(std::vector<Contact::ref>)));
 		connect(firstMultiJIDPage_->contactList_, SIGNAL(onJIDsAdded(std::vector<JID>)), this, SLOT(handleJIDsAdded(std::vector<JID>)));
 		connect(firstMultiJIDPage_, SIGNAL(onJIDsDropped(std::vector<JID>)), this, SLOT(handleJIDsAdded(std::vector<JID>)));
 		setPage(1, firstMultiJIDPage_);
 	}
 }
 
 void QtUserSearchWindow::setSecondPage() {
 	if (page(2) != 0) {
 		removePage(2);
 	}
 	fieldsPage_ = new QtUserSearchFieldsPage();
 	fieldsPage_->fetchingThrobber_->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));
 	fieldsPage_->fetchingThrobber_->movie()->stop();
 	setPage(2, fieldsPage_);
 }
 
 void QtUserSearchWindow::setThirdPage() {
 	if (page(3) != 0) {
 		removePage(3);
 	}
 	resultsPage_ = new QtUserSearchResultsPage();
 
 #ifdef SWIFT_PLATFORM_MACOSX
 	resultsPage_->results_->setAlternatingRowColors(true);
 #endif
 	if (type_ == AddContact) {
 		connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));
 	}
 	else {
 		connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));
 	}
 	setPage(3, resultsPage_);
 }
 
 void QtUserSearchWindow::clearForm() {
 	fieldsPage_->fetchingThrobber_->show();
 	fieldsPage_->fetchingThrobber_->movie()->start();
 	fieldsPage_->fetchingLabel_->show();
 	QWidget* legacySearchWidgets[8] = {fieldsPage_->nickInputLabel_, fieldsPage_->nickInput_, fieldsPage_->firstInputLabel_, fieldsPage_->firstInput_, fieldsPage_->lastInputLabel_, fieldsPage_->lastInput_, fieldsPage_->emailInputLabel_, fieldsPage_->emailInput_};
 	for (int i = 0; i < 8; i++) {
 		legacySearchWidgets[i]->hide();
 		if (QLineEdit* edit = qobject_cast<QLineEdit*>(legacySearchWidgets[i])) {
 			edit->clear();
 		}
 	}
 	fieldsPage_->emitCompletenessCheck();
 }
 
 void QtUserSearchWindow::clear() {
 	QString howText;
 	if (type_ == AddContact) {
 		firstPage_->errorLabel_->setVisible(false);
 		howText = QString(tr("How would you like to find the user to add?"));
 		firstPage_->howLabel_->setText(howText);
 		firstPage_->byJID_->setChecked(true);
 		handleFirstPageRadioChange();
 	} else {
 		contactVector_.clear();
 		firstMultiJIDPage_->contactList_->setList(contactVector_);
 		firstMultiJIDPage_->errorLabel_->setVisible(false);
 		if (type_ == ChatToContact) {
 			howText = QString(tr("Who would you like to chat to?"));
 		} else if (type_ == InviteToChat) {
 			howText = QString(tr("Who do you want to invite to the chat?"));
 		}
 		firstMultiJIDPage_->howLabel_->setText(howText);
 	}
 	clearForm();
 	resultsPage_->results_->setModel(NULL);
 	delete model_;
 	model_ = NULL;
 	restart();
 	lastPage_ = 1;
 }
 
 void QtUserSearchWindow::setError(const QString& error) {
 	if (error.isEmpty()) {
 		if (type_ == AddContact) {
 			firstPage_->errorLabel_->hide();
 		} else {
 			firstMultiJIDPage_->errorLabel_->hide();
 		}
 	}
 	else {
 		if (type_ == AddContact) {
 			firstPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));
 			firstPage_->errorLabel_->show();
 		} else {
 			firstMultiJIDPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));
 			firstMultiJIDPage_->errorLabel_->show();
 		}
 		restart();
 		lastPage_ = 1;
 	}
 }
 
 void QtUserSearchWindow::setSearchError(bool error) {
 	if (error) {
 		setError(tr("Error while searching"));
 	}
 }
 
 void QtUserSearchWindow::setServerSupportsSearch(bool support) {
 	if (!support) {
 		setError(tr("This server doesn't support searching for users."));
 	}
 }
 
 }
author	Richard Maudsley <richard.maudsley@isode.com>	2014-06-30 10:42:05 (GMT)
committer	Swift Review <review@swift.im>	2014-07-09 12:53:37 (GMT)
commit	1edfc36235cc67d303ceb2bcf0630affc509f2f7 (patch)
tree	0ca86a9e5e0dbcd3876ce91b4bf4feec5321c9c9 /Swift
parent	05d9e618e4c756e50b633448f0546614a645a13d (diff)
download	swift-contrib-1edfc36235cc67d303ceb2bcf0630affc509f2f7.zip swift-contrib-1edfc36235cc67d303ceb2bcf0630affc509f2f7.tar.bz2