8 files changed, 36 insertions, 18 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 41a34b9..cd8fa0c 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -270,71 +270,71 @@ void ChatController::handleBlockingStateChanged() {
         } else {
             if (blockedContactAlert_) {
                 chatWindow_->removeAlert(*blockedContactAlert_);
                 blockedContactAlert_.reset();
             }
             chatWindow_->setBlockingState(ChatWindow::IsUnblocked);
 
             chatWindow_->onUserTyping.connect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));
             chatWindow_->onUserCancelsTyping.connect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));
         }
     }
 }
 
 void ChatController::handleBlockUserRequest() {
     if (isInMUC_) {
         eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_));
     } else {
         eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_.toBare()));
     }
 }
 
 void ChatController::handleUnblockUserRequest() {
     if (isInMUC_) {
         eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_));
     } else {
         eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_.toBare()));
     }
 }
 
 void ChatController::handleInviteToChat(const std::vector<JID>& droppedJIDs) {
-    std::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(toJID_.toBare(), droppedJIDs, RequestInviteToMUCUIEvent::Impromptu));
+    std::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(getToJID(), droppedJIDs, RequestInviteToMUCUIEvent::Impromptu));
     eventStream_->send(event);
 }
 
 void ChatController::handleWindowClosed() {
     onWindowClosed();
 }
 
 void ChatController::handleUIEvent(std::shared_ptr<UIEvent> event) {
     std::shared_ptr<InviteToMUCUIEvent> inviteEvent = std::dynamic_pointer_cast<InviteToMUCUIEvent>(event);
-    if (inviteEvent && inviteEvent->getRoom() == toJID_.toBare()) {
+    if (inviteEvent && inviteEvent->getOriginator() == getToJID()) {
         onConvertToMUC(detachChatWindow(), inviteEvent->getInvites(), inviteEvent->getReason());
     }
 }
 
 void ChatController::handleIncomingOwnMessage(std::shared_ptr<Message> message) {
     if (!message->getBody().get_value_or("").empty()) {
         postSendMessage(message->getBody().get_value_or(""), message);
         handleStanzaAcked(message);
     }
 }
 
 void ChatController::postSendMessage(const std::string& body, std::shared_ptr<Stanza> sentStanza) {
     std::shared_ptr<Replace> replace = sentStanza->getPayload<Replace>();
     if (replace) {
         eraseIf(unackedStanzas_, PairSecondEquals<std::shared_ptr<Stanza>, std::string>(myLastMessageUIID_));
         replaceMessage(chatMessageParser_->parseMessageBody(body, "", true), myLastMessageUIID_, boost::posix_time::microsec_clock::universal_time());
     } else {
         myLastMessageUIID_ = addMessage(chatMessageParser_->parseMessageBody(body, "", true), QT_TRANSLATE_NOOP("", "me"), true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel().getLabel() : std::shared_ptr<SecurityLabel>(), avatarManager_->getAvatarPath(selfJID_), boost::posix_time::microsec_clock::universal_time());
     }
 
     if (stanzaChannel_->getStreamManagementEnabled() && !myLastMessageUIID_.empty() ) {
         chatWindow_->setAckState(myLastMessageUIID_, ChatWindow::Pending);
         unackedStanzas_[sentStanza] = myLastMessageUIID_;
     }
 
     if (sentStanza->getPayload<DeliveryReceiptRequest>()) {
         requestedReceipts_[sentStanza->getID()] = myLastMessageUIID_;
         chatWindow_->setMessageReceiptState(myLastMessageUIID_, ChatWindow::ReceiptRequested);
     }
 
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index 349bf8a..ceed776 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -1,39 +1,40 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/MUCController.h>
 
 #include <algorithm>
+#include <memory>
 
 #include <boost/bind.hpp>
 #include <boost/regex.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Base/Tristate.h>
 #include <Swiften/Client/BlockList.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Elements/Delay.h>
 #include <Swiften/Elements/Thread.h>
 #include <Swiften/MUC/MUC.h>
 #include <Swiften/MUC/MUCBookmark.h>
 #include <Swiften/MUC/MUCBookmarkManager.h>
 #include <Swiften/Network/Timer.h>
 #include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Roster/XMPPRoster.h>
 
 #include <SwifTools/TabComplete.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
@@ -966,67 +967,66 @@ void MUCController::handleOccupantRoleChangeFailed(ErrorPayload::ref error, cons
     errorMessage = str(format(QT_TRANSLATE_NOOP("", "Occupant role change failed: %1%.")) % errorMessage);
     chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));
 }
 
 void MUCController::configureAsImpromptuRoom(Form::ref form) {
     muc_->configureRoom(buildImpromptuRoomConfiguration(form));
     isImpromptuAlreadyConfigured_ = true;
     onImpromptuConfigCompleted();
 }
 
 void MUCController::handleConfigurationFormReceived(Form::ref form) {
     if (isImpromptu_) {
         if (!isImpromptuAlreadyConfigured_) {
             configureAsImpromptuRoom(form);
         }
     } else {
         chatWindow_->showRoomConfigurationForm(form);
     }
 }
 
 void MUCController::handleConfigurationCancelled() {
     muc_->cancelConfigureRoom();
 }
 
 void MUCController::handleDestroyRoomRequest() {
     muc_->destroyRoom();
 }
 
 void MUCController::handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite) {
     RequestInviteToMUCUIEvent::ImpromptuMode mode = isImpromptu_ ? RequestInviteToMUCUIEvent::Impromptu : RequestInviteToMUCUIEvent::NotImpromptu;
-    std::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(muc_->getJID(), jidsToInvite, mode));
-    eventStream_->send(event);
+    eventStream_->send(std::make_shared<RequestInviteToMUCUIEvent>(getToJID(), jidsToInvite, mode));
 }
 
 void MUCController::handleUIEvent(std::shared_ptr<UIEvent> event) {
     std::shared_ptr<InviteToMUCUIEvent> inviteEvent = std::dynamic_pointer_cast<InviteToMUCUIEvent>(event);
-    if (inviteEvent && inviteEvent->getRoom() == muc_->getJID()) {
+    if (inviteEvent && inviteEvent->getOriginator() == muc_->getJID()) {
         for (const auto& jid : inviteEvent->getInvites()) {
             muc_->invitePerson(jid, inviteEvent->getReason(), isImpromptu_);
         }
     }
 }
 
 void MUCController::handleGetAffiliationsRequest() {
     muc_->requestAffiliationList(MUCOccupant::Owner);
     muc_->requestAffiliationList(MUCOccupant::Admin);
     muc_->requestAffiliationList(MUCOccupant::Member);
     muc_->requestAffiliationList(MUCOccupant::Outcast);
 }
 
 void MUCController::handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes) {
     std::set<JID> addedJIDs;
     for (const auto& change : changes) {
         if (change.first != MUCOccupant::NoAffiliation) {
             addedJIDs.insert(change.second);
         }
     }
     for (const auto& change : changes) {
         if (change.first != MUCOccupant::NoAffiliation || addedJIDs.find(change.second) == addedJIDs.end()) {
             muc_->changeAffiliation(change.second, change.first);
         }
     }
 }
 
 void MUCController::handleUnblockUserRequest() {
     eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, muc_->getJID()));
 }
diff --git a/Swift/Controllers/Chat/UserSearchController.cpp b/Swift/Controllers/Chat/UserSearchController.cpp
index 91e0dea..91de670 100644
--- a/Swift/Controllers/Chat/UserSearchController.cpp
+++ b/Swift/Controllers/Chat/UserSearchController.cpp
@@ -54,92 +54,93 @@ UserSearchController::~UserSearchController() {
         window_->onContactSuggestionsRequested.disconnect(boost::bind(&UserSearchController::handleContactSuggestionsRequested, this, _1));
         window_->onJIDUpdateRequested.disconnect(boost::bind(&UserSearchController::handleJIDUpdateRequested, this, _1));
         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>();
-    RequestInviteToMUCUIEvent::ref inviteToMUCRequest = RequestInviteToMUCUIEvent::ref();
+    auto inviteToMUCRequest = RequestInviteToMUCUIEvent::ref();
     switch (type_) {
         case AddContact:
             if ((addUserRequest = std::dynamic_pointer_cast<RequestAddUserDialogUIEvent>(event))) {
                 handle = true;
             }
             break;
         case StartChat:
             if (std::dynamic_pointer_cast<RequestChatWithUserDialogUIEvent>(event)) {
                 handle = true;
             }
             break;
         case 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) {
+        }
+        else if (inviteToMUCRequest) {
             window_->setCanSupplyDescription(!inviteToMUCRequest->isImpromptu());
             window_->setJIDs(inviteToMUCRequest->getInvites());
-            window_->setRoomJID(inviteToMUCRequest->getRoom());
+            window_->setOriginator(inviteToMUCRequest->getOriginator());
         }
         return;
     }
 }
 
 void UserSearchController::handleFormRequested(const JID& service) {
     window_->setSearchError(false);
     window_->setServerSupportsSearch(true);
 
     //Abort a previous search if is active
     endDiscoWalker();
     delete discoWalker_;
     discoWalker_ = new DiscoServiceWalker(service, iqRouter_);
     discoWalker_->onServiceFound.connect(boost::bind(&UserSearchController::handleDiscoServiceFound, this, _1, _2));
     discoWalker_->onWalkComplete.connect(boost::bind(&UserSearchController::handleDiscoWalkFinished, this));
     discoWalker_->beginWalk();
 }
 
 void UserSearchController::endDiscoWalker() {
     if (discoWalker_) {
         discoWalker_->endWalk();
         discoWalker_->onServiceFound.disconnect(boost::bind(&UserSearchController::handleDiscoServiceFound, this, _1, _2));
         discoWalker_->onWalkComplete.disconnect(boost::bind(&UserSearchController::handleDiscoWalkFinished, this));
     }
 }
 
 void UserSearchController::handleDiscoServiceFound(const JID& jid, std::shared_ptr<DiscoInfo> info) {
     //bool isUserDirectory = false;
     bool supports55 = false;
     // TODO: Cleanup code
diff --git a/Swift/Controllers/UIEvents/InviteToMUCUIEvent.h b/Swift/Controllers/UIEvents/InviteToMUCUIEvent.h
index 414582d..e38eab8 100644
--- a/Swift/Controllers/UIEvents/InviteToMUCUIEvent.h
+++ b/Swift/Controllers/UIEvents/InviteToMUCUIEvent.h
@@ -1,47 +1,47 @@
 /*
  * Copyright (c) 2013 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
  * Copyright (c) 2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <memory>
 #include <vector>
 
 #include <Swiften/JID/JID.h>
 
 #include <Swift/Controllers/UIEvents/UIEvent.h>
 
 namespace Swift {
     class InviteToMUCUIEvent : public UIEvent {
         public:
             typedef std::shared_ptr<InviteToMUCUIEvent> ref;
 
-            InviteToMUCUIEvent(const JID& room, const std::vector<JID>& JIDsToInvite, const std::string& reason) : room_(room), invite_(JIDsToInvite), reason_(reason) {
+            InviteToMUCUIEvent(const JID& originator, const std::vector<JID>& JIDsToInvite, const std::string& reason) : originator_(originator), invite_(JIDsToInvite), reason_(reason) {
             }
 
-            const JID& getRoom() const {
-                return room_;
+            const JID& getOriginator() const {
+                return originator_;
             }
 
             const std::vector<JID> getInvites() const {
                 return invite_;
             }
 
             const std::string getReason() const {
                 return reason_;
             }
 
         private:
-            JID room_;
+            JID originator_;
             std::vector<JID> invite_;
             std::string reason_;
     };
 }
diff --git a/Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h b/Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h
index dac499f..a8e4bb7 100644
--- a/Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h
+++ b/Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h
@@ -2,52 +2,62 @@
  * 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.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <memory>
 #include <vector>
 
 #include <Swiften/JID/JID.h>
 
 #include <Swift/Controllers/UIEvents/UIEvent.h>
 
 namespace Swift {
     class RequestInviteToMUCUIEvent : public UIEvent {
         public:
             typedef std::shared_ptr<RequestInviteToMUCUIEvent> ref;
 
             enum ImpromptuMode {
                 Impromptu,
                 NotImpromptu
             };
 
-            RequestInviteToMUCUIEvent(const JID& room, const std::vector<JID>& JIDsToInvite, ImpromptuMode impromptu) : room_(room), invite_(JIDsToInvite) {
+            /**
+             * @brief RequestInviteToMUCUIEvent
+             * @param originator This can be a MUC JID if the user wants to invite
+             *          people to an existing MUC, or a contact JID if this is the
+             *          start of an impromptu group chat.
+             * @param JIDsToInvite This is a std::vector of JIDs which are prefilled
+             *          in the invite dialog.
+             * @param impromptu This flag indicates whether it is a normal MUC invite
+             *          or an impromptu MUC invite.
+             */
+            RequestInviteToMUCUIEvent(const JID& originator, const std::vector<JID>& JIDsToInvite, ImpromptuMode impromptu) : originator_(originator), invite_(JIDsToInvite) {
                 isImpromptu_ = impromptu == Impromptu;
             }
 
-            const JID& getRoom() const {
-                return room_;
+            const JID& getOriginator() const {
+                return originator_;
             }
 
             const std::vector<JID> getInvites() const {
                 return invite_;
             }
 
             bool isImpromptu() const {
                 return isImpromptu_;
             }
 
         private:
-            JID room_;
+            JID originator_;
             std::vector<JID> invite_;
             bool isImpromptu_;
     };
 }
diff --git a/Swift/Controllers/UIInterfaces/UserSearchWindow.h b/Swift/Controllers/UIInterfaces/UserSearchWindow.h
index be17dc0..279f4f3 100644
--- a/Swift/Controllers/UIInterfaces/UserSearchWindow.h
+++ b/Swift/Controllers/UIInterfaces/UserSearchWindow.h
@@ -8,50 +8,51 @@
 
 #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};
             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;
             boost::signals2::signal<void (const std::vector<JID>&)> onJIDUpdateRequested;
             boost::signals2::signal<void (const std::vector<JID>&)> onJIDAddRequested;
             boost::signals2::signal<void (const JID&)> onJIDEditFieldChanged;
     };
 }
diff --git a/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp b/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
index e00582c..cf62540 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
+++ b/Swift/QtUI/UserSearch/QtUserSearchWindow.cpp
@@ -118,67 +118,67 @@ void QtUserSearchWindow::handleCurrentChanged(int page) {
     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(std::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));
             break;
         case 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, JID(), Q2PSTRING(firstMultiJIDPage_->reason_->text())));
+            eventStream_->send(std::make_shared<CreateImpromptuMUCUIEvent>(jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));
             break;
         case InviteToChat:
             for (Contact::ref contact : contactVector_) {
                 jids.push_back(contact->jid);
             }
-            eventStream_->send(std::make_shared<InviteToMUCUIEvent>(roomJID_, jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));
+            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) {
         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)));
@@ -360,60 +360,64 @@ void QtUserSearchWindow::setSearchFields(std::shared_ptr<SearchPayload> fields)
 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) {
     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) {
         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) {
diff --git a/Swift/QtUI/UserSearch/QtUserSearchWindow.h b/Swift/QtUI/UserSearch/QtUserSearchWindow.h
index 5d8b755..b9d4698 100644
--- a/Swift/QtUI/UserSearch/QtUserSearchWindow.h
+++ b/Swift/QtUI/UserSearch/QtUserSearchWindow.h
@@ -20,87 +20,89 @@ namespace Swift {
     class UserSearchResult;
     class UIEventStream;
     class QtUserSearchFirstPage;
     class QtUserSearchFirstMultiJIDPage;
     class QtUserSearchFieldsPage;
     class QtUserSearchResultsPage;
     class QtUserSearchDetailsPage;
     class QtFormResultItemModel;
     class SettingsProvider;
 
     class QtUserSearchWindow : public QWizard, public UserSearchWindow, private Ui::QtUserSearchWizard {
         Q_OBJECT
         public:
             QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider);
             virtual ~QtUserSearchWindow();
 
             virtual void addSavedServices(const std::vector<JID>& services);
 
             virtual void clear();
             virtual void show();
             virtual void setResults(const std::vector<UserSearchResult>& results);
             virtual void setResultsForm(Form::ref results);
             virtual void setSelectedService(const JID& jid);
             virtual void setServerSupportsSearch(bool error);
             virtual void setSearchError(bool error);
             virtual void setSearchFields(std::shared_ptr<SearchPayload> fields);
             virtual void setNameSuggestions(const std::vector<std::string>& suggestions);
             virtual void prepopulateJIDAndName(const JID& jid, const std::string& name);
             virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions);
             virtual void setJIDs(const std::vector<JID> &jids);
+            virtual void setOriginator(const JID& originator);
             virtual void setRoomJID(const JID &roomJID);
             virtual std::string getReason() const;
             virtual std::vector<JID> getJIDs() const;
             virtual void setCanStartImpromptuChats(bool supportsImpromptu);
             virtual void updateContacts(const std::vector<Contact::ref> &contacts);
             virtual void addContacts(const std::vector<Contact::ref>& contacts);
             virtual void setCanSupplyDescription(bool allowed);
             virtual void setWarning(const boost::optional<std::string>& message);
 
         protected:
             virtual int nextId() const;
 
         private slots:
             void handleFirstPageRadioChange();
             virtual void handleCurrentChanged(int);
             virtual void handleAccepted();
             void handleContactSuggestionRequested(const QString& text);
             void addContact();
             void handleAddViaSearch();
             void handleListChanged(std::vector<Contact::ref> list);
             void handleJIDsAdded(std::vector<JID> jids);
             void handleJIDEditingDone();
 
         private:
             void setFirstPage(QString title = "");
             void setSecondPage();
             void setThirdPage();
 
         private:
             void clearForm();
             void setError(const QString& error);
             JID getServerToSearch();
             void handleSearch();
             JID getContactJID() const;
             Contact::ref getContact() const;
             void addSearchedJIDToList(const Contact::ref& contact);
             void handleOnSearchedJIDSelected(const Contact::ref& contact);
 
         private:
             UIEventStream* eventStream_;
             UserSearchWindow::Type type_;
             QAbstractItemModel* model_;
             UserSearchDelegate* delegate_;
             QtUserSearchFirstPage* firstPage_;
             QtUserSearchFirstMultiJIDPage* firstMultiJIDPage_;
             QtUserSearchFieldsPage* fieldsPage_;
             QtUserSearchResultsPage* resultsPage_;
             QtUserSearchDetailsPage* detailsPage_;
             JID myServer_;
             JID roomJID_;
+            JID originatorJID_;
             int lastPage_;
             std::vector<Contact::ref> contactVector_;
             SettingsProvider* settings_;
             bool searchNext_;
             bool supportsImpromptu_;
     };
 }