7 files changed, 68 insertions, 57 deletions
diff --git a/Swift/Controllers/Chat/UserSearchController.cpp b/Swift/Controllers/Chat/UserSearchController.cpp
index 91de670..30c3c77 100644
--- a/Swift/Controllers/Chat/UserSearchController.cpp
+++ b/Swift/Controllers/Chat/UserSearchController.cpp
@@ -1,32 +1,32 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/UserSearchController.h>
 
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/String.h>
 #include <Swiften/Disco/DiscoServiceWalker.h>
 #include <Swiften/Disco/GetDiscoInfoRequest.h>
 #include <Swiften/Disco/GetDiscoItemsRequest.h>
 #include <Swiften/Presence/PresenceOracle.h>
 #include <Swiften/VCards/VCardManager.h>
 
 #include <Swift/Controllers/ContactEditController.h>
 #include <Swift/Controllers/ContactSuggester.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/ProfileSettingsProvider.h>
 #include <Swift/Controllers/Roster/RosterController.h>
 #include <Swift/Controllers/UIEvents/RequestAddUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatWithUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/UserSearchWindow.h>
 #include <Swift/Controllers/UIInterfaces/UserSearchWindowFactory.h>
 
@@ -56,71 +56,71 @@ UserSearchController::~UserSearchController() {
         window_->onJIDAddRequested.disconnect(boost::bind(&UserSearchController::handleJIDAddRequested, this, _1));
         window_->onJIDEditFieldChanged.disconnect(boost::bind(&UserSearchController::handleJIDEditingFinished, this, _1));
         delete window_;
     }
     presenceOracle_->onPresenceChange.disconnect(boost::bind(&UserSearchController::handlePresenceChanged, this, _1));
     avatarManager_->onAvatarChanged.disconnect(boost::bind(&UserSearchController::handleAvatarChanged, this, _1));
     vcardManager_->onVCardChanged.disconnect(boost::bind(&UserSearchController::handleVCardChanged, this, _1, _2));
     uiEventStream_->onUIEvent.disconnect(boost::bind(&UserSearchController::handleUIEvent, this, _1));
 }
 
 UserSearchWindow* UserSearchController::getUserSearchWindow() {
     initializeUserWindow();
     assert(window_);
     return window_;
 }
 
 void UserSearchController::setCanInitiateImpromptuMUC(bool supportsImpromptu) {
     if (!window_) {
         initializeUserWindow();
     }
     if (window_) {
         window_->setCanStartImpromptuChats(supportsImpromptu);
     } // Else doesn't support search
 }
 
 void UserSearchController::handleUIEvent(std::shared_ptr<UIEvent> event) {
     bool handle = false;
     std::shared_ptr<RequestAddUserDialogUIEvent> addUserRequest = std::shared_ptr<RequestAddUserDialogUIEvent>();
     auto inviteToMUCRequest = RequestInviteToMUCUIEvent::ref();
     switch (type_) {
-        case AddContact:
+        case Type::AddContact:
             if ((addUserRequest = std::dynamic_pointer_cast<RequestAddUserDialogUIEvent>(event))) {
                 handle = true;
             }
             break;
-        case StartChat:
+        case Type::StartChat:
             if (std::dynamic_pointer_cast<RequestChatWithUserDialogUIEvent>(event)) {
                 handle = true;
             }
             break;
-        case InviteToChat:
+        case Type::InviteToChat:
             if ((inviteToMUCRequest = std::dynamic_pointer_cast<RequestInviteToMUCUIEvent>(event))) {
                 handle = true;
             }
             break;
     }
     if (handle) {
         initializeUserWindow();
         window_->show();
         window_->addSavedServices(savedDirectories_);
         if (addUserRequest) {
             const std::string& name = addUserRequest->getPredefinedName();
             const JID& jid = addUserRequest->getPredefinedJID();
             if (!name.empty() && jid.isValid()) {
                 window_->prepopulateJIDAndName(jid, name);
             }
         }
         else if (inviteToMUCRequest) {
             window_->setCanSupplyDescription(!inviteToMUCRequest->isImpromptu());
             window_->setJIDs(inviteToMUCRequest->getInvites());
             window_->setOriginator(inviteToMUCRequest->getOriginator());
         }
         return;
     }
 }
 
 void UserSearchController::handleFormRequested(const JID& service) {
     window_->setSearchError(false);
     window_->setServerSupportsSearch(true);
 
     //Abort a previous search if is active
@@ -214,61 +214,61 @@ void UserSearchController::handleJIDEditingFinished(const JID& jid) {
         if (rosterController_->getItem(jid)) {
             window_->setWarning(QT_TRANSLATE_NOOP("", "This contact is already on your contact list."));
         }
         else if (jid.getNode().empty()) {
             window_->setWarning(QT_TRANSLATE_NOOP("", "Part of the address you have entered is missing. An address has a structure of 'user@example.com'."));
         }
         else {
             window_->setWarning(boost::optional<std::string>());
         }
     }
     else {
         window_->setWarning(QT_TRANSLATE_NOOP("", "The address you have entered is invalid."));
     }
 }
 
 void UserSearchController::handleContactSuggestionsRequested(std::string text) {
     const std::vector<JID> existingJIDs = window_->getJIDs();
     std::vector<Contact::ref> suggestions = contactSuggester_->getSuggestions(text, false);
     /* do not suggest contacts that have already been added to the chat list */
     std::vector<Contact::ref>::iterator i = suggestions.begin();
     while (i != suggestions.end()) {
         bool found = false;
         for (const auto& jid : existingJIDs) {
             if ((*i)->jid == jid) {
                 found = true;
                 break;
             }
         }
 
         // remove contact suggestions which are already on the contact list in add-contact-mode
-        if (type_ == AddContact) {
+        if (type_ == Type::AddContact) {
             if (!found && !!rosterController_->getItem((*i)->jid)) {
                 found = true;
             }
         }
 
         if (found) {
             i = suggestions.erase(i);
         } else {
             i++;
         }
     }
     window_->setContactSuggestions(suggestions);
 }
 
 void UserSearchController::handleVCardChanged(const JID& jid, VCard::ref vcard) {
     if (jid == suggestionsJID_) {
         window_->setNameSuggestions(ContactEditController::nameSuggestionsFromVCard(vcard));
         suggestionsJID_ = JID();
     }
     handleJIDUpdateRequested(std::vector<JID>(1, jid));
 }
 
 void UserSearchController::handleAvatarChanged(const JID& jid) {
     handleJIDUpdateRequested(std::vector<JID>(1, jid));
 }
 
 void UserSearchController::handlePresenceChanged(Presence::ref presence) {
     handleJIDUpdateRequested(std::vector<JID>(1, presence->getFrom().toBare()));
 }
 
@@ -300,70 +300,70 @@ Contact::ref UserSearchController::convertJIDtoContact(const JID& jid) {
         contact->name = rosterItem->getName();
     } else {
         VCard::ref vcard = vcardManager_->getVCard(jid);
         if (vcard && !vcard->getFullName().empty()) {
             contact->name = vcard->getFullName();
         } else {
             contact->name = jid.toString();
         }
     }
 
     // presence lookup
     Presence::ref presence = presenceOracle_->getAccountPresence(jid);
     if (presence) {
         contact->statusType = presence->getShow();
     } else {
         contact->statusType = StatusShow::None;
     }
 
     // avatar lookup
     contact->avatarPath = avatarManager_->getAvatarPath(jid);
     return contact;
 }
 
 void UserSearchController::handleDiscoWalkFinished() {
     window_->setServerSupportsSearch(false);
     endDiscoWalker();
 }
 
 void UserSearchController::initializeUserWindow() {
     if (!window_) {
-        UserSearchWindow::Type windowType = UserSearchWindow::AddContact;
+        auto windowType = UserSearchWindow::Type::AddContact;
         switch(type_) {
-            case AddContact:
-                windowType = UserSearchWindow::AddContact;
+            case Type::AddContact:
+                windowType = UserSearchWindow::Type::AddContact;
                 break;
-            case StartChat:
-                windowType = UserSearchWindow::ChatToContact;
+            case Type::StartChat:
+                windowType = UserSearchWindow::Type::ChatToContact;
                 break;
-            case InviteToChat:
-                windowType = UserSearchWindow::InviteToChat;
+            case Type::InviteToChat:
+                windowType = UserSearchWindow::Type::InviteToChat;
                 break;
         }
 
         window_ = factory_->createUserSearchWindow(windowType, uiEventStream_, rosterController_->getGroups());
         if (!window_) {
             // UI Doesn't support user search
             return;
         }
         window_->onNameSuggestionRequested.connect(boost::bind(&UserSearchController::handleNameSuggestionRequest, this, _1));
         window_->onFormRequested.connect(boost::bind(&UserSearchController::handleFormRequested, this, _1));
         window_->onSearchRequested.connect(boost::bind(&UserSearchController::handleSearch, this, _1, _2));
         window_->onContactSuggestionsRequested.connect(boost::bind(&UserSearchController::handleContactSuggestionsRequested, this, _1));
         window_->onJIDUpdateRequested.connect(boost::bind(&UserSearchController::handleJIDUpdateRequested, this, _1));
         window_->onJIDAddRequested.connect(boost::bind(&UserSearchController::handleJIDAddRequested, this, _1));
         window_->onJIDEditFieldChanged.connect(boost::bind(&UserSearchController::handleJIDEditingFinished, this, _1));
         window_->setSelectedService(JID(jid_.getDomain()));
         window_->clear();
     }
 }
 
 void UserSearchController::loadSavedDirectories() {
     savedDirectories_.clear();
     for (auto&& stringItem : String::split(settings_->getStringSetting(SEARCHED_DIRECTORIES), '\n')) {
         if(!stringItem.empty()) {
             savedDirectories_.push_back(JID(stringItem));
         }
     }
 }
 
 void UserSearchController::addToSavedDirectories(const JID& jid) {
diff --git a/Swift/Controllers/Chat/UserSearchController.h b/Swift/Controllers/Chat/UserSearchController.h
index 4658301..49bb63c 100644
--- a/Swift/Controllers/Chat/UserSearchController.h
+++ b/Swift/Controllers/Chat/UserSearchController.h
@@ -1,82 +1,82 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include <boost/signals2.hpp>
 
 #include <Swiften/Elements/DiscoInfo.h>
 #include <Swiften/Elements/DiscoItems.h>
 #include <Swiften/Elements/ErrorPayload.h>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/Elements/SearchPayload.h>
 #include <Swiften/Elements/VCard.h>
 #include <Swiften/JID/JID.h>
 
 #include <Swift/Controllers/Contact.h>
 
 namespace Swift {
     class UIEventStream;
     class UIEvent;
     class UserSearchWindow;
     class UserSearchWindowFactory;
     class IQRouter;
     class DiscoServiceWalker;
     class RosterController;
     class VCardManager;
     class ContactSuggester;
     class AvatarManager;
     class PresenceOracle;
     class ProfileSettingsProvider;
 
     class UserSearchResult {
         public:
             UserSearchResult(const JID& jid, const std::map<std::string, std::string>& fields) : jid_(jid), fields_(fields) {}
             const JID& getJID() const {return jid_;}
             const std::map<std::string, std::string>& getFields() const {return fields_;}
         private:
             JID jid_;
             std::map<std::string, std::string> fields_;
     };
 
     class UserSearchController {
         public:
-            enum Type {AddContact, StartChat, InviteToChat};
+            enum class Type {AddContact, StartChat, InviteToChat};
             UserSearchController(Type type, const JID& jid, UIEventStream* uiEventStream, VCardManager* vcardManager, UserSearchWindowFactory* userSearchWindowFactory, IQRouter* iqRouter, RosterController* rosterController, ContactSuggester* contactSuggester, AvatarManager* avatarManager, PresenceOracle* presenceOracle, ProfileSettingsProvider* settings);
             ~UserSearchController();
 
             UserSearchWindow* getUserSearchWindow();
             void setCanInitiateImpromptuMUC(bool supportsImpromptu);
 
         private:
             void handleUIEvent(std::shared_ptr<UIEvent> event);
             void handleFormRequested(const JID& service);
             void handleDiscoServiceFound(const JID& jid, std::shared_ptr<DiscoInfo> info);
             void handleDiscoWalkFinished();
             void handleFormResponse(std::shared_ptr<SearchPayload> items, ErrorPayload::ref error);
             void handleSearch(std::shared_ptr<SearchPayload> fields, const JID& jid);
             void handleSearchResponse(std::shared_ptr<SearchPayload> results, ErrorPayload::ref error);
             void handleNameSuggestionRequest(const JID& jid);
             void handleContactSuggestionsRequested(std::string text);
             void handleVCardChanged(const JID& jid, VCard::ref vcard);
             void handleAvatarChanged(const JID& jid);
             void handlePresenceChanged(Presence::ref presence);
             void handleJIDUpdateRequested(const std::vector<JID>& jids);
             void handleJIDAddRequested(const std::vector<JID>& jids);
             void handleJIDEditingFinished(const JID& jid);
             Contact::ref convertJIDtoContact(const JID& jid);
             void endDiscoWalker();
             void initializeUserWindow();
 
             void loadSavedDirectories();
             void addToSavedDirectories(const JID& jid);
 
         private:
diff --git a/Swift/Controllers/MainController.cpp b/Swift/Controllers/MainController.cpp
index e64b23d..b22e467 100644
--- a/Swift/Controllers/MainController.cpp
+++ b/Swift/Controllers/MainController.cpp
@@ -339,101 +339,101 @@ void MainController::handleConnected() {
 
     if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {
         purgeCachedCredentials();
     }
 
     bool freshLogin = rosterController_ == nullptr;
     myStatusLooksOnline_ = true;
     if (freshLogin) {
         profileController_ = new ProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);
         showProfileController_ = new ShowProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);
         ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());
         fileTransferListController_->setFileTransferOverview(ftOverview_);
         rosterController_ = new RosterController(boundJID_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), client_->getClientBlockListManager(), client_->getVCardManager());
         rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));
         rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));
         rosterController_->getWindow()->onShowCertificateRequest.connect(boost::bind(&MainController::handleShowCertificateRequest, this));
 
         blockListController_ = new BlockListController(client_->getClientBlockListManager(), uiEventStream_, uiFactory_, eventController_);
 
         contactEditController_ = new ContactEditController(rosterController_, client_->getVCardManager(), uiFactory_, uiEventStream_);
         whiteboardManager_ = new WhiteboardManager(uiFactory_, uiEventStream_, client_->getNickResolver(), client_->getWhiteboardSessionManager());
 
         /* Doing this early as an ordering fix. Various things later will
          * want to have the user's nick available and this means it will
          * be before they receive stanzas that need it (e.g. bookmarks).*/
         client_->getVCardManager()->requestOwnVCard();
 
         contactSuggesterWithoutRoster_ = new ContactSuggester();
         contactSuggesterWithRoster_ = new ContactSuggester();
 
-        userSearchControllerInvite_ = new UserSearchController(UserSearchController::InviteToChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);
+        userSearchControllerInvite_ = new UserSearchController(UserSearchController::Type::InviteToChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);
 #ifdef SWIFT_EXPERIMENTAL_HISTORY
         historyController_ = new HistoryController(storages_->getHistoryStorage());
         historyViewController_ = new HistoryViewController(jid_, uiEventStream_, historyController_, client_->getNickResolver(), client_->getAvatarManager(), client_->getPresenceOracle(), uiFactory_);
         chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager());
 #else
         chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, nullptr, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager());
 #endif
         contactsFromRosterProvider_ = new ContactsFromXMPPRoster(client_->getRoster(), client_->getAvatarManager(), client_->getPresenceOracle());
         contactSuggesterWithoutRoster_->addContactProvider(chatsManager_);
         contactSuggesterWithRoster_->addContactProvider(chatsManager_);
         contactSuggesterWithRoster_->addContactProvider(contactsFromRosterProvider_);
         highlightEditorController_->setContactSuggester(contactSuggesterWithoutRoster_);
 
         client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));
         chatsManager_->setAvatarManager(client_->getAvatarManager());
 
         eventWindowController_ = new EventWindowController(eventController_, uiFactory_);
 
         loginWindow_->morphInto(rosterController_->getWindow());
 
         DiscoInfo discoInfo;
         discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));
         discoInfo.addFeature(DiscoInfo::ChatStatesFeature);
         discoInfo.addFeature(DiscoInfo::SecurityLabelsFeature);
         discoInfo.addFeature(DiscoInfo::MessageCorrectionFeature);
 #ifdef SWIFT_EXPERIMENTAL_FT
         discoInfo.addFeature(DiscoInfo::JingleFeature);
         discoInfo.addFeature(DiscoInfo::JingleFTFeature);
         discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);
         discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);
 #endif
 #ifdef SWIFT_EXPERIMENTAL_WB
         discoInfo.addFeature(DiscoInfo::WhiteboardFeature);
 #endif
         discoInfo.addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);
         client_->getDiscoManager()->setCapsNode(CLIENT_NODE);
         client_->getDiscoManager()->setDiscoInfo(discoInfo);
 
-        userSearchControllerChat_ = new UserSearchController(UserSearchController::StartChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);
-        userSearchControllerAdd_ = new UserSearchController(UserSearchController::AddContact, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithoutRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);
+        userSearchControllerChat_ = new UserSearchController(UserSearchController::Type::StartChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);
+        userSearchControllerAdd_ = new UserSearchController(UserSearchController::Type::AddContact, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithoutRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);
         adHocManager_ = new AdHocManager(JID(boundJID_.getDomain()), uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());
 
         chatsManager_->onImpromptuMUCServiceDiscovered.connect(boost::bind(&UserSearchController::setCanInitiateImpromptuMUC, userSearchControllerChat_, _1));
     }
     loginWindow_->setIsLoggingIn(false);
 
     client_->requestRoster();
 
     GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(boundJID_.getDomain()), client_->getIQRouter());
     discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));
     discoInfoRequest->send();
 
     client_->getVCardManager()->requestOwnVCard();
 
     rosterController_->setJID(boundJID_);
     rosterController_->setEnabled(true);
     rosterController_->getWindow()->setStreamEncryptionStatus(client_->isStreamEncrypted());
     profileController_->setAvailable(true);
     contactEditController_->setAvailable(true);
     /* Send presence later to catch all the incoming presences. */
     sendPresence(statusTracker_->getNextPresence());
 
     /* Enable chats last of all, so rejoining MUCs has the right sent presence */
     assert(chatsManager_);
     chatsManager_->setOnline(true);
     adHocManager_->setOnline(true);
 }
 
 void MainController::handleEventQueueLengthChange(int count) {
     dock_->setNumberOfPendingMessages(count);
diff --git a/Swift/Controllers/UIInterfaces/UserSearchWindow.h b/Swift/Controllers/UIInterfaces/UserSearchWindow.h
index 279f4f3..c13e376 100644
--- a/Swift/Controllers/UIInterfaces/UserSearchWindow.h
+++ b/Swift/Controllers/UIInterfaces/UserSearchWindow.h
@@ -1,53 +1,53 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include <boost/signals2.hpp>
 
 #include <Swiften/JID/JID.h>
 
 #include <Swift/Controllers/Chat/UserSearchController.h>
 #include <Swift/Controllers/Contact.h>
 
 namespace Swift {
 
     class UserSearchWindow {
         public:
-            enum Type {AddContact, ChatToContact, InviteToChat};
+            enum class Type {AddContact, ChatToContact, InviteToChat};
             virtual ~UserSearchWindow() {}
 
             virtual void clear() = 0;
             virtual void setResults(const std::vector<UserSearchResult>& results) = 0;
             virtual void setResultsForm(const Form::ref results) = 0;
             virtual void addSavedServices(const std::vector<JID>& services) = 0;
             virtual void setSelectedService(const JID& service) = 0;
             virtual void setServerSupportsSearch(bool support) = 0;
             virtual void setSearchError(bool support) = 0;
             virtual void setSearchFields(std::shared_ptr<SearchPayload> fields) = 0;
             virtual void setNameSuggestions(const std::vector<std::string>& suggestions) = 0;
             virtual void prepopulateJIDAndName(const JID& jid, const std::string& name) = 0;
             virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions) = 0;
             virtual void setJIDs(const std::vector<JID>&) = 0;
             virtual void setOriginator(const JID& originator) = 0;
             virtual void setRoomJID(const JID& roomJID) = 0;
             virtual std::string getReason() const = 0;
             virtual std::vector<JID> getJIDs() const = 0;
             virtual void setCanStartImpromptuChats(bool supportsImpromptu) = 0;
             virtual void updateContacts(const std::vector<Contact::ref>& contacts) = 0;
             virtual void addContacts(const std::vector<Contact::ref>& contacts) = 0;
             virtual void setCanSupplyDescription(bool allowed) = 0;
             virtual void setWarning(const boost::optional<std::string>& message) = 0;
 
             virtual void show() = 0;
 
             boost::signals2::signal<void (const JID&)> onFormRequested;
             boost::signals2::signal<void (std::shared_ptr<SearchPayload>, const JID&)> onSearchRequested;
             boost::signals2::signal<void (const JID&)> onNameSuggestionRequested;
             boost::signals2::signal<void (const std::string&)> onContactSuggestionsRequested;
diff --git a/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp b/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp
index 1327a8f..8656db7 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp
+++ b/Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.cpp
@@ -1,68 +1,68 @@
 /*
  * Copyright (c) 2013 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2014-2016 Isode Limited.
+ * Copyright (c) 2014-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>
 
 #include <QMessageBox>
 #include <QMimeData>
 #include <QUrl>
 
 #include <Swift/Controllers/Settings/SettingsProvider.h>
 
 #include <Swift/QtUI/QtSwiftUtil.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:
+        case UserSearchWindow::Type::AddContact:
             introText = tr("Add another user to your contact list");
             break;
-        case UserSearchWindow::ChatToContact:
+        case UserSearchWindow::Type::ChatToContact:
             introText = tr("Chat to another user");
             break;
-        case UserSearchWindow::InviteToChat:
+        case UserSearchWindow::Type::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() {
     jid_->clear();
     reason_->clear();
 }
 
 void QtUserSearchFirstMultiJIDPage::emitCompletenessCheck() {
     emit completeChanged();
 }
diff --git a/Swift/QtUI/UserSearch/QtUserSearchFirstPage.cpp b/Swift/QtUI/UserSearch/QtUserSearchFirstPage.cpp
index 5d0c9fa..24e79e4 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchFirstPage.cpp
+++ b/Swift/QtUI/UserSearch/QtUserSearchFirstPage.cpp
@@ -1,48 +1,48 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>
 
 #include <Swiften/Base/Log.h>
 
 #include <Swift/QtUI/QtSwiftUtil.h>
 
 namespace Swift {
 
 QtUserSearchFirstPage::QtUserSearchFirstPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {
     setupUi(this);
     setTitle(title);
-    setSubTitle(QString(tr("%1. If you know their address you can enter it directly, or you can search for them.")).arg(type == UserSearchWindow::AddContact ? tr("Add another user to your contact list") : tr("Chat to another user")));
+    setSubTitle(QString(tr("%1. If you know their address you can enter it directly, or you can search for them.")).arg(type == UserSearchWindow::Type::AddContact ? tr("Add another user to your contact list") : tr("Chat to another user")));
     jid_ = new QtSuggestingJIDInput(this, settings);
     horizontalLayout_2->addWidget(jid_);
     jidWarning_ = new QLabel(this);
     jidWarning_->setPixmap(QPixmap(":icons/warn.png"));
     jidWarning_->hide();
     horizontalLayout_2->addWidget(jidWarning_);
     setTabOrder(byJID_, jid_);
     setTabOrder(jid_, byLocalSearch_);
     setTabOrder(byLocalSearch_, byRemoteSearch_);
     connect(jid_, SIGNAL(textChanged(const QString&)), this, SLOT(emitCompletenessCheck()));
     connect(jid_, SIGNAL(editingDone()), this, SLOT(emitCompletenessCheck()));
     connect(service_->lineEdit(), SIGNAL(textChanged(const QString&)), this, SLOT(emitCompletenessCheck()));
 }
 
 bool QtUserSearchFirstPage::isComplete() const {
     bool complete = false;
     if (byJID_->isChecked()) {
         complete = JID(Q2PSTRING(jid_->text().trimmed())).isValid() && jidWarning_->toolTip().isEmpty();
     } else if (byLocalSearch_->isChecked()) {
         complete = true;
     } else if (byRemoteSearch_->isChecked()) {
         complete = JID(Q2PSTRING(service_->currentText().trimmed())).isValid();
     }
     return complete;
 }
 
 void QtUserSearchFirstPage::emitCompletenessCheck() {
     emit completeChanged();
 }
 
diff --git a/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp b/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
index f150557..e770186 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
+++ b/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
@@ -7,226 +7,237 @@
 #include <Swift/QtUI/UserSearch/QtUserSearchWindow.h>
 
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <QItemDelegate>
 #include <QModelIndex>
 #include <QMovie>
 #include <QWizardPage>
 
 #include <Swift/Controllers/UIEvents/AddContactUIEvent.h>
 #include <Swift/Controllers/UIEvents/CreateImpromptuMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 
 #include <Swift/QtUI/QtFormResultItemModel.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/UserSearch/QtContactListWidget.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchDetailsPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchFieldsPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>
 #include <Swift/QtUI/UserSearch/QtUserSearchResultsPage.h>
 #include <Swift/QtUI/UserSearch/UserSearchDelegate.h>
 #include <Swift/QtUI/UserSearch/UserSearchModel.h>
 
 namespace Swift {
 
-QtUserSearchWindow::QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider) : eventStream_(eventStream), type_(type), model_(nullptr), firstMultiJIDPage_(nullptr), settings_(settingsProvider), searchNext_(false), supportsImpromptu_(false) {
+QtUserSearchWindow::QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider) : eventStream_(eventStream), type_(type), model_(nullptr), firstPage_(nullptr), firstMultiJIDPage_(nullptr), settings_(settingsProvider), searchNext_(false), supportsImpromptu_(false) {
     setupUi(this);
 #ifndef Q_OS_MAC
 #ifdef  Q_OS_WIN32
     setWindowIcon(QIcon(":/logo-icon-16-win.png"));
 #else
     setWindowIcon(QIcon(":/logo-icon-16.png"));
 #endif
 #endif
     QString title;
     switch(type) {
-        case AddContact:
+        case Type::AddContact:
             title = tr("Add Contact");
             break;
-        case ChatToContact:
+        case Type::ChatToContact:
             title = tr("Chat to Users");
             break;
-        case InviteToChat:
+        case Type::InviteToChat:
             title = tr("Add Users to Chat");
             break;
     }
     setWindowTitle(title);
 
     delegate_ = new UserSearchDelegate(this);
 
     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 (type_ != AddContact) {
+
+    // Check preconditions per type.
+    if (type_ == Type::AddContact) {
+        assert(firstPage_);
+        assert(!firstMultiJIDPage_);
+    }
+    else {
+        assert(!firstPage_);
+        assert(firstMultiJIDPage_);
+    }
+
+    if (type_ != Type::AddContact) {
         firstMultiJIDPage_->reset();
     }
     resultsPage_->emitCompletenessCheck();
-    if (firstMultiJIDPage_ && page == 1 && lastPage_ == 3) {
+    if (type_ != Type::AddContact && page == 1 && lastPage_ == 3) {
         addSearchedJIDToList(getContact());
         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) {
+        if (type_ == 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);
             if (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) {
+    if (type_ == 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:
+        case Type::AddContact:
             jid = getContactJID();
             eventStream_->send(std::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));
             break;
-        case ChatToContact:
+        case Type::ChatToContact:
             if (contactVector_.size() == 1) {
                 std::shared_ptr<UIEvent> event(new RequestChatUIEvent(contactVector_[0]->jid));
                 eventStream_->send(event);
                 break;
             }
 
             for (Contact::ref contact : contactVector_) {
                 jids.push_back(contact->jid);
             }
 
             eventStream_->send(std::make_shared<CreateImpromptuMUCUIEvent>(jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));
             break;
-        case InviteToChat:
+        case Type::InviteToChat:
             for (Contact::ref contact : contactVector_) {
                 jids.push_back(contact->jid);
             }
             eventStream_->send(std::make_shared<InviteToMUCUIEvent>(originatorJID_, jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));
             break;
     }
 }
 
 void QtUserSearchWindow::handleContactSuggestionRequested(const QString& text) {
     std::string stdText = Q2PSTRING(text);
     onContactSuggestionsRequested(stdText);
 }
 
 void QtUserSearchWindow::addContact() {
     auto contactToAdd = firstMultiJIDPage_->jid_->getContact();
     if (!!contactToAdd) {
         contactVector_.push_back(contactToAdd);
         firstMultiJIDPage_->jid_->clear();
     }
 
     firstMultiJIDPage_->contactList_->setList(contactVector_);
     firstMultiJIDPage_->emitCompletenessCheck();
-    if (type_ == ChatToContact) {
+    if (type_ == Type::ChatToContact) {
         firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));
     }
 
     if (!!contactToAdd && contactToAdd->jid.isValid() && contactToAdd->statusType == StatusShow::None) {
         onJIDUpdateRequested({contactToAdd->jid});
     }
 }
 
 void QtUserSearchWindow::setWarning(const boost::optional<std::string>& message) {
     if (message) {
         firstPage_->jidWarning_->setToolTip(P2QSTRING((*message)));
         firstPage_->jidWarning_->setAccessibleDescription(P2QSTRING((*message)));
         firstPage_->jidWarning_->show();
     }
     else {
         firstPage_->jidWarning_->setToolTip("");
         firstPage_->jidWarning_->setAccessibleDescription("");
         firstPage_->jidWarning_->hide();
     }
     firstPage_->emitCompletenessCheck();
 }
 
 int QtUserSearchWindow::nextId() const {
-    if (type_ == AddContact) {
+    if (type_ == Type::AddContact) {
         switch (currentId()) {
-            case 1: return firstPage_->byJID_->isChecked() ? (type_ == AddContact ? 4 : -1) : 2;
+            case 1: return firstPage_->byJID_->isChecked() ? (type_ == Type::AddContact ? 4 : -1) : 2;
             case 2: return 3;
-            case 3: return type_ == AddContact ? 4 : -1;
+            case 3: return type_ == 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);
@@ -234,407 +245,407 @@ void QtUserSearchWindow::handleFirstPageRadioChange() {
         restart();
     }
 }
 
 void QtUserSearchWindow::handleSearch() {
     std::shared_ptr<SearchPayload> search(new SearchPayload());
     if (fieldsPage_->getFormWidget()) {
         search->setForm(fieldsPage_->getFormWidget()->getCompletedForm());
         search->getForm()->clearEmptyTextFields();
     } else {
         if (fieldsPage_->nickInput_->isEnabled() && !fieldsPage_->nickInput_->text().isEmpty()) {
             search->setNick(Q2PSTRING(fieldsPage_->nickInput_->text()));
         }
         if (fieldsPage_->firstInput_->isEnabled() && !fieldsPage_->firstInput_->text().isEmpty()) {
             search->setFirst(Q2PSTRING(fieldsPage_->firstInput_->text()));
         }
         if (fieldsPage_->lastInput_->isEnabled() && !fieldsPage_->lastInput_->text().isEmpty()) {
             search->setLast(Q2PSTRING(fieldsPage_->lastInput_->text()));
         }
         if (fieldsPage_->emailInput_->isEnabled() && !fieldsPage_->emailInput_->text().isEmpty()) {
             search->setEMail(Q2PSTRING(fieldsPage_->emailInput_->text()));
         }
     }
     onSearchRequested(search, getServerToSearch());
 }
 
 JID QtUserSearchWindow::getContactJID() const {
     JID jid;
 
     bool useSearchResult;
-    if (type_ == AddContact) {
+    if (type_ == 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 if (dynamic_cast<QtFormResultItemModel*>(model_)) {
             int row = resultsPage_->results_->currentIndex().row();
 
             Form::FormItem item = dynamic_cast<QtFormResultItemModel*>(model_)->getForm()->getItems().at(row);
             JID fallbackJid;
             for (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;
 }
 
 Contact::ref QtUserSearchWindow::getContact() const {
     return std::make_shared<Contact>("", getContactJID(), StatusShow::None, "");
 }
 
 void QtUserSearchWindow::addSearchedJIDToList(const Contact::ref& contact) {
     std::vector<JID> jids;
     jids.push_back(contact->jid);
     handleJIDsAdded(jids);
     firstMultiJIDPage_->jid_->clear();
 }
 
 void QtUserSearchWindow::handleOnSearchedJIDSelected(const Contact::ref& contact) {
     firstPage_->jid_->setText(P2QSTRING(contact->jid.toString()));
 }
 
 void QtUserSearchWindow::show() {
     clear();
-    if (type_ == AddContact) {
+    if (type_ == Type::AddContact) {
         setWarning(boost::optional<std::string>());
     }
     QWidget::show();
     raise();
 }
 
 void QtUserSearchWindow::addSavedServices(const std::vector<JID>& services) {
-    if (type_ == AddContact) {
+    if (type_ == Type::AddContact) {
         firstPage_->service_->clear();
         for (auto&& jid : services) {
             firstPage_->service_->addItem(P2QSTRING(jid.toString()));
         }
         firstPage_->service_->clearEditText();
     } else {
         firstMultiJIDPage_->service_->clear();
         for (auto&& jid : services) {
             firstMultiJIDPage_->service_->addItem(P2QSTRING(jid.toString()));
         }
         firstMultiJIDPage_->service_->clearEditText();
     }
 }
 
 void QtUserSearchWindow::setSearchFields(std::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(nullptr);
         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) {
+    if (type_ == Type::AddContact) {
         firstPage_->jid_->setSuggestions(suggestions);
     } else {
         firstMultiJIDPage_->jid_->setSuggestions(suggestions);
     }
 }
 
 void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {
     for (auto&& jid : jids) {
         addSearchedJIDToList(std::make_shared<Contact>("", jid, StatusShow::None, ""));
     }
     onJIDUpdateRequested(jids);
 }
 
 void QtUserSearchWindow::setOriginator(const JID& originator) {
     originatorJID_ = originator;
 }
 
 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;
     for (Contact::ref contact : contactVector_) {
         jids.push_back(contact->jid);
     }
     return jids;
 }
 
 void QtUserSearchWindow::setCanStartImpromptuChats(bool supportsImpromptu) {
     supportsImpromptu_ = supportsImpromptu;
-    if (type_ == ChatToContact) {
+    if (type_ == Type::ChatToContact) {
         firstMultiJIDPage_->contactList_->setMaximumNoOfContactsToOne(!supportsImpromptu_);
     }
 }
 
 void QtUserSearchWindow::updateContacts(const std::vector<Contact::ref>& contacts) {
-    if (type_ != AddContact) {
+    if (type_ != Type::AddContact) {
         firstMultiJIDPage_->contactList_->updateContacts(contacts);
     }
 }
 
 void QtUserSearchWindow::addContacts(const std::vector<Contact::ref>& contacts) {
-    if (type_ != AddContact) {
+    if (type_ != Type::AddContact) {
         /* prevent duplicate JIDs from appearing in the contact list */
         for (Contact::ref newContact : contacts) {
             bool found = false;
             for (Contact::ref oldContact : contactVector_) {
                 if (newContact->jid == oldContact->jid) {
                     found = true;
                     break;
                 }
             }
             if (!found) {
                 contactVector_.push_back(newContact);
             }
         }
-        if (type_ != InviteToChat && !supportsImpromptu_ && contactVector_.size() > 1) {
+        if (type_ != Type::InviteToChat && !supportsImpromptu_ && contactVector_.size() > 1) {
             contactVector_.resize(1); /* can't chat with more than one user */
         }
         firstMultiJIDPage_->contactList_->setList(contactVector_);
         firstMultiJIDPage_->emitCompletenessCheck();
-        if (type_ == ChatToContact) {
+        if (type_ == 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) {
+    if (type_ == 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::handleJIDEditingDone() {
     onJIDEditFieldChanged(JID(Q2PSTRING(firstPage_->jid_->text())));
 }
 
 void QtUserSearchWindow::setFirstPage(QString title) {
     if (page(1) != nullptr) {
         removePage(1);
     }
-    if (type_ == AddContact) {
+    if (type_ == Type::AddContact) {
         firstPage_ = new QtUserSearchFirstPage(type_, title.isEmpty() ? firstPage_->title() : title, settings_);
         connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));
         connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleJIDEditingDone()), Qt::UniqueConnection);
         firstPage_->jid_->onUserSelected.connect(boost::bind(&QtUserSearchWindow::handleOnSearchedJIDSelected, this, _1));
         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) != nullptr) {
         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) != nullptr) {
         removePage(3);
     }
     resultsPage_ = new QtUserSearchResultsPage();
 
 #ifdef SWIFT_PLATFORM_MACOSX
     resultsPage_->results_->setAlternatingRowColors(true);
 #endif
-    if (type_ == AddContact) {
+    if (type_ == 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 (auto&& legacySearchWidget : legacySearchWidgets) {
         legacySearchWidget->hide();
         if (QLineEdit* edit = qobject_cast<QLineEdit*>(legacySearchWidget)) {
             edit->clear();
         }
     }
     fieldsPage_->emitCompletenessCheck();
 }
 
 void QtUserSearchWindow::clear() {
     QString howText;
-    if (type_ == AddContact) {
+    if (type_ == 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) {
+        if (type_ == Type::ChatToContact) {
             howText = QString(tr("List of participants:"));
-        } else if (type_ == InviteToChat) {
+        } else if (type_ == Type::InviteToChat) {
             howText = QString(tr("Who do you want to invite to the chat?"));
         }
         firstMultiJIDPage_->howLabel_->setText(howText);
     }
     clearForm();
     resultsPage_->results_->setModel(nullptr);
     delete model_;
     model_ = nullptr;
     restart();
     lastPage_ = 1;
 }
 
 void QtUserSearchWindow::setError(const QString& error) {
     if (error.isEmpty()) {
-        if (type_ == AddContact) {
+        if (type_ == Type::AddContact) {
             firstPage_->errorLabel_->hide();
         } else {
             firstMultiJIDPage_->errorLabel_->hide();
         }
     }
     else {
-        if (type_ == AddContact) {
+        if (type_ == 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."));
     }
 }
 
 }