/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swift/Controllers/Chat/ChatsManager.h>

#include <boost/bind.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/smart_ptr/make_shared.hpp>

void ChatsManager::handleLocalServiceWalkFinished() {

onImpromptuMUCServiceDiscovered(!localMUCServiceJID_.toString().empty());

}

std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {

return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

}

foreach (ChatListWindow::Chat chat, recentChats_) {

if (!chat.isMUC) {

}

}

return result;

}

ChatsManager::SingleChatWindowFactoryAdapter::SingleChatWindowFactoryAdapter(ChatWindow* chatWindow) : chatWindow_(chatWindow) {}

ChatsManager::SingleChatWindowFactoryAdapter::~SingleChatWindowFactoryAdapter() {}

ChatWindow* ChatsManager::SingleChatWindowFactoryAdapter::createChatWindow(const JID &, UIEventStream*) {

return chatWindow_;

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <map>

#include <string>

class ChatsManager : public ContactProvider {

public:

ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, const std::map<std::string, std::string>& emoticons, UserSearchController* inviteUserSearchController, VCardManager* vcardManager);

virtual ~ChatsManager();

void setAvatarManager(AvatarManager* avatarManager);

void setOnline(bool enabled);

void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

void handleIncomingMessage(boost::shared_ptr<Message> message);

std::vector<ChatListWindow::Chat> getRecentChats() const;

boost::signal<void (bool supportsImpromptu)> onImpromptuMUCServiceDiscovered;

private:

class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

public:

SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);

virtual ~SingleChatWindowFactoryAdapter();

virtual ChatWindow* createChatWindow(const JID &, UIEventStream*);

handleJIDUpdateRequested(std::vector<JID>(1, jid));

}

void UserSearchController::handlePresenceChanged(Presence::ref presence) {

handleJIDUpdateRequested(std::vector<JID>(1, presence->getFrom().toBare()));

}

void UserSearchController::handleJIDUpdateRequested(const std::vector<JID>& jids) {

if (window_) {

foreach(const JID& jid, jids) {

updates.push_back(convertJIDtoContact(jid));

}

window_->updateContacts(updates);

}

}

void UserSearchController::handleJIDAddRequested(const std::vector<JID>& jids) {

foreach(const JID& jid, jids) {

contacts.push_back(convertJIDtoContact(jid));

}

window_->addContacts(contacts);

}

// name lookup

boost::optional<XMPPRosterItem> rosterItem = rosterController_->getItem(jid);

if (rosterItem && !rosterItem->getName().empty()) {

} else {

VCard::ref vcard = vcardManager_->getVCard(jid);

if (vcard && !vcard->getFullName().empty()) {

} else {

}

}

// presence lookup

Presence::ref presence = presenceOracle_->getHighestPriorityPresence(jid);

if (presence) {

} else {

}

// avatar lookup

return contact;

}

void UserSearchController::handleDiscoWalkFinished() {

window_->setServerSupportsSearch(false);

endDiscoWalker();

}

void UserSearchController::initializeUserWindow() {

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <map>

#include <vector>

#include <string>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/Presence.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 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_;

void handleSearch(boost::shared_ptr<SearchPayload> fields, const JID& jid);

void handleSearchResponse(boost::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 endDiscoWalker();

void initializeUserWindow();

private:

Type type_;

JID jid_;

JID suggestionsJID_;

UIEventStream* uiEventStream_;

VCardManager* vcardManager_;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <boost/filesystem/path.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/JID/JID.h>

namespace Swift {

public:

Contact();

Contact(const std::string& name, const JID& jid, StatusShow::Type statusType, const boost::filesystem::path& path);

public:

std::string name;

JID jid;

StatusShow::Type statusType;

boost::filesystem::path avatarPath;

};

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <vector>

#include <Swift/Controllers/Contact.h>

namespace Swift {

class ContactProvider {

public:

virtual ~ContactProvider();

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#include <Swift/Controllers/ContactSuggester.h>

#include <boost/algorithm/string/find.hpp>

#include <boost/lambda/lambda.hpp>

#include <boost/lambda/bind.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/JID/JID.h>

}

ContactSuggester::~ContactSuggester() {

}

void ContactSuggester::addContactProvider(ContactProvider* provider) {

contactProviders_.push_back(provider);

}

}

foreach(ContactProvider* provider, contactProviders_) {

append(results, provider->getContacts());

}

results.erase(std::remove_if(results.begin(), results.end(), !lambda::bind(&ContactSuggester::matchContact, search, lambda::_1)),

results.end());

return results;

}

bool ContactSuggester::fuzzyMatch(std::string text, std::string match) {

for (std::string::iterator currentQueryChar = match.begin(); currentQueryChar != match.end(); currentQueryChar++) {

//size_t result = text.find(*currentQueryChar);

std::string::iterator result = boost::algorithm::ifind_first(text, std::string(currentQueryChar, currentQueryChar+1)).begin();

if (result == text.end()) {

return false;

}

text.erase(result);

}

return true;

}

} else {

}

}

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <string>

#include <vector>

#include <Swift/Controllers/Contact.h>

namespace Swift {

class ContactProvider;

class ContactSuggester {

public:

ContactSuggester();

~ContactSuggester();

void addContactProvider(ContactProvider* provider);

private:

/**

* Performs fuzzy matching on the string text. Matches when each character of match string is present in sequence in text string.

*/

static bool fuzzyMatch(std::string text, std::string match);

private:

std::vector<ContactProvider*> contactProviders_;

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

namespace Swift {

ContactsFromXMPPRoster::ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle) : roster_(roster), avatarManager_(avatarManager), presenceOracle_(presenceOracle) {

}

ContactsFromXMPPRoster::~ContactsFromXMPPRoster() {

}

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

foreach(const XMPPRosterItem& rosterItem, rosterItems) {

results.push_back(contact);

}

return results;

}

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swift/Controllers/ContactProvider.h>

namespace Swift {

class PresenceOracle;

class AvatarManager;

class XMPPRoster;

class ContactsFromXMPPRoster : public ContactProvider {

public:

ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle);

virtual ~ContactsFromXMPPRoster();

private:

XMPPRoster* roster_;

AvatarManager* avatarManager_;

PresenceOracle* presenceOracle_;

};

}

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(boost::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 setJIDs(const std::vector<JID>&) = 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 show() = 0;

boost::signal<void (const JID&)> onFormRequested;

boost::signal<void (boost::shared_ptr<SearchPayload>, const JID&)> onSearchRequested;

boost::signal<void (const JID&)> onNameSuggestionRequested;

boost::signal<void (const std::string&)> onContactSuggestionsRequested;

boost::signal<void (const std::vector<JID>&)> onJIDUpdateRequested;

boost::signal<void (const std::vector<JID>&)> onJIDAddRequested;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#include <Swift/QtUI/UserSearch/ContactListDelegate.h>

#include <Swift/QtUI/UserSearch/ContactListModel.h>

#include <Swift/Controllers/Contact.h>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

ContactListDelegate::ContactListDelegate(bool compact) : compact_(compact) {

}

ContactListDelegate::~ContactListDelegate() {

}

void ContactListDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

if (!index.isValid()) {

return;

}

QColor nameColor = index.data(Qt::TextColorRole).value<QColor>();

QString avatarPath = index.data(ContactListModel::AvatarRole).value<QString>();

QIcon presenceIcon =index.data(ChatListRecentItem::PresenceIconRole).isValid() && !index.data(ChatListRecentItem::PresenceIconRole).value<QIcon>().isNull()

? index.data(ChatListRecentItem::PresenceIconRole).value<QIcon>()

: QIcon(":/icons/offline.png");

QString name = P2QSTRING(contact->name);

QString statusText = P2QSTRING(contact->jid.toString());

common_.paintContact(painter, option, nameColor, avatarPath, presenceIcon, name, statusText, false, 0, compact_);

}

e = StatusShow::None;

break;

}

return in;

}

ContactListModel::ContactListModel(bool editable) : QAbstractItemModel(), editable_(editable) {

}

emit layoutAboutToBeChanged();

contacts_ = list;

emit layoutChanged();

}

return contacts_;

}

Qt::ItemFlags ContactListModel::flags(const QModelIndex& index) const {

Qt::ItemFlags flags = QAbstractItemModel::flags(index);

if (index.isValid()) {

flags = flags & ~Qt::ItemIsDropEnabled;

} else {

flags = Qt::ItemIsDropEnabled | flags;

}

return flags;

}

int ContactListModel::columnCount(const QModelIndex&) const {

return editable_ ? 2 : 1;

}

QVariant ContactListModel::data(const QModelIndex& index, int role) const {

if (boost::numeric_cast<size_t>(index.row()) < contacts_.size()) {

if (role == Qt::EditRole) {

}

return dataForContact(contact, role);

} else {

return QVariant();

}

}

QModelIndex ContactListModel::index(int row, int column, const QModelIndex& parent) const {

if (!hasIndex(row, column, parent)) {

return QModelIndex();

}

}

QModelIndex ContactListModel::parent(const QModelIndex& index) const {

if (!index.isValid()) {

return QModelIndex();

}

return QModelIndex();

}

emit layoutAboutToBeChanged();

contacts_.erase(contacts_.begin() + row);

emit layoutChanged();

onListChanged(getList());

return true;

}

return false;

}

switch (role) {

case PresenceIconRole: return getPresenceIconForContact(contact);

default: return QVariant();

}

}

}

}

enum ContactRoles {

DetailTextRole = Qt::UserRole,

AvatarRole = Qt::UserRole + 1,

PresenceIconRole = Qt::UserRole + 2

};

public:

ContactListModel(bool editable);

Qt::ItemFlags flags(const QModelIndex& index) const;

int columnCount(const QModelIndex& parent = QModelIndex()) const;

QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;

QModelIndex parent(const QModelIndex& index) const;

int rowCount(const QModelIndex& parent = QModelIndex()) const;

bool removeRows(int row, int count, const QModelIndex& parent = QModelIndex());

private:

signals:

void onJIDsDropped(const std::vector<JID>& contact);

private:

bool editable_;

};

}

#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(onJIDsDropped(std::vector<JID>)), this, SIGNAL(onJIDsAdded(std::vector<JID>)));

setSelectionMode(QAbstractItemView::SingleSelection);

setSelectionBehavior(QAbstractItemView::SelectRows);

setUniformRowHeights(true);

setAlternatingRowColors(true);

setIndentation(0);

setHeaderHidden(true);

header()->setResizeMode(0, QHeaderView::Stretch);

#endif

}

QtContactListWidget::~QtContactListWidget() {

delete contactListDelegate_;

delete removableItemDelegate_;

}

contactListModel_->setList(list);

}

return contactListModel_->getList();

}

void QtContactListWidget::setMaximumNoOfContactsToOne(bool limited) {

limited_ = limited;

}

for(size_t n = 0; n < contacts.size(); n++) {

contacts[n] = contactUpdate;

break;

}

}

}

contactListModel_->setList(contacts);

}

void QtContactListWidget::handleSettingsChanged(const std::string&) {

class SettingsProvider;

class QtRemovableItemDelegate;

class QtContactListWidget : public QTreeView {

Q_OBJECT

public:

QtContactListWidget(QWidget* parent, SettingsProvider* settings);

virtual ~QtContactListWidget();

void setMaximumNoOfContactsToOne(bool limited);

public slots:

signals:

void onJIDsAdded(const std::vector<JID>& jids);

private:

void handleSettingsChanged(const std::string&);

private:

SettingsProvider* settings_;

ContactListModel* contactListModel_;

ContactListDelegate* contactListDelegate_;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

#include <Swift/QtUI/UserSearch/ContactListDelegate.h>

#include <Swift/Controllers/Settings/SettingsProvider.h>

#include <Swift/QtUI/QtUISettingConstants.h>

#include <Swift/QtUI/UserSearch/ContactListModel.h>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/bind.hpp>

#include <QAbstractItemView>

#include <QApplication>

#include <QDesktopWidget>

#include <QKeyEvent>

namespace Swift {

treeViewPopup_ = new QTreeView();

treeViewPopup_->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);

//treeViewPopup_->setAttribute(Qt::WA_ShowWithoutActivating);

treeViewPopup_->setAlternatingRowColors(true);

treeViewPopup_->setIndentation(0);

treeViewPopup_->setHeaderHidden(true);

treeViewPopup_->setExpandsOnDoubleClick(false);

treeViewPopup_->setItemsExpandable(false);

treeViewPopup_->setSelectionMode(QAbstractItemView::SingleSelection);

settings_->onSettingChanged.connect(boost::bind(&QtSuggestingJIDInput::handleSettingsChanged, this, _1));

}

QtSuggestingJIDInput::~QtSuggestingJIDInput() {

settings_->onSettingChanged.disconnect(boost::bind(&QtSuggestingJIDInput::handleSettingsChanged, this, _1));

delete treeViewPopup_;

}

return currentContact_;

}

}

}

contactListModel_->setList(suggestions);

positionPopup();

if (!suggestions.empty()) {

treeViewPopup_->setCurrentIndex(contactListModel_->index(0, 0));

showPopup();

} else {

}

}

void QtSuggestingJIDInput::keyPressEvent(QKeyEvent* event) {

if (event->key() == Qt::Key_Up) {

if (contactListModel_->rowCount() > 0) {

int row = treeViewPopup_->currentIndex().row();

row = (row + contactListModel_->rowCount() - 1) % contactListModel_->rowCount();

treeViewPopup_->setCurrentIndex(contactListModel_->index(row, 0));

} else if (event->key() == Qt::Key_Down) {

if (contactListModel_->rowCount() > 0) {

int row = treeViewPopup_->currentIndex().row();

row = (row + contactListModel_->rowCount() + 1) % contactListModel_->rowCount();

treeViewPopup_->setCurrentIndex(contactListModel_->index(row, 0));

}

} else if (event->key() == Qt::Key_Return && treeViewPopup_->isVisible()) {

QModelIndex index = treeViewPopup_->currentIndex();

if (!contactListModel_->getList().empty() && index.isValid()) {

setText(P2QSTRING(currentContact_->jid.toString()));

hidePopup();

clearFocus();

} else {

}

editingDone();

} else {

QLineEdit::keyPressEvent(event);

}

}

void QtSuggestingJIDInput::handleApplicationFocusChanged(QWidget* /*old*/, QWidget* /*now*/) {

/* Using the now argument gives use the wrong widget. This is part of the code needed

void QtSuggestingJIDInput::handleSettingsChanged(const std::string& setting) {

if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {

contactListDelegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

}

}

void QtSuggestingJIDInput::handleClicked(const QModelIndex& index) {

if (index.isValid()) {

setText("");

onUserSelected(currentContact_->jid);

hidePopup();

}

}

void QtSuggestingJIDInput::positionPopup() {

QDesktopWidget* desktop = QApplication::desktop();

int screen = desktop->screenNumber(this);

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <QLineEdit>

#include <QTreeView>

#include <Swiften/Base/boost_bsignals.h>

#include <Swift/Controllers/Contact.h>

namespace Swift {

class SettingsProvider;

class ContactListModel;

class QtSuggestingJIDInput : public QLineEdit {

Q_OBJECT

public:

QtSuggestingJIDInput(QWidget* parent, SettingsProvider* settings);

virtual ~QtSuggestingJIDInput();

boost::signal<void (const JID&)> onUserSelected;

signals:

void editingDone();

protected:

virtual void keyPressEvent(QKeyEvent* event);

void positionPopup();

void showPopup();

void hidePopup();

private:

SettingsProvider* settings_;

ContactListModel* contactListModel_;

QTreeView* treeViewPopup_;

ContactListDelegate* contactListDelegate_;

};

}

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(jid_, SIGNAL(editingDone()), this, SLOT(handleEditingDone()));

setAcceptDrops(true);

}

bool QtUserSearchFirstMultiJIDPage::isComplete() const {

return !contactList_->getList().empty();

}

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) {

eventStream_->send(event);

break;

}

}

eventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(jids, JID(), Q2PSTRING(firstMultiJIDPage_->reason_->text())));

break;

case InviteToChat:

}

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() {

}

firstMultiJIDPage_->contactList_->setList(contactVector_);

firstMultiJIDPage_->emitCompletenessCheck();

if (type_ == ChatToContact) {

firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

}

}

int QtUserSearchWindow::nextId() const {

}

}

else {

jid = JID(Q2PSTRING(firstPage_->jid_->text().trimmed()));

}

return jid;

}

void QtUserSearchWindow::addSearchedJIDToList(const JID& jid) {

contactVector_.push_back(contact);

firstMultiJIDPage_->contactList_->setList(contactVector_);

firstMultiJIDPage_->emitCompletenessCheck();

if (type_ == ChatToContact) {

firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

}

}

void QtUserSearchWindow::show() {

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);

}

if (type_ == AddContact) {

firstPage_->jid_->setSuggestions(suggestions);

} else {

firstMultiJIDPage_->jid_->setSuggestions(suggestions);

}

}

void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {

foreach(JID jid, jids) {

roomJID_ = roomJID;

}

std::string QtUserSearchWindow::getReason() const {

return Q2PSTRING(firstMultiJIDPage_->reason_->text());

}

std::vector<JID> QtUserSearchWindow::getJIDs() const {

std::vector<JID> jids;

}

return jids;

}

void QtUserSearchWindow::setCanStartImpromptuChats(bool supportsImpromptu) {

supportsImpromptu_ = supportsImpromptu;

if (type_ == ChatToContact) {

firstMultiJIDPage_->contactList_->setMaximumNoOfContactsToOne(!supportsImpromptu_);

}

}

if (type_ != AddContact) {

firstMultiJIDPage_->contactList_->updateContacts(contacts);

}

}

if (type_ != AddContact) {

/* prevent duplicate JIDs from appearing in the contact list */

bool found = false;

found = true;

break;

}

}

if (!found) {

contactVector_.push_back(newContact);

}

}

firstMultiJIDPage_->contactList_->setList(contactVector_);

firstMultiJIDPage_->emitCompletenessCheck();

}

}

void QtUserSearchWindow::handleAddViaSearch() {

searchNext_ = true;

next();

}

contactVector_ = list;

if (type_ == ChatToContact) {

firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

}

}

void QtUserSearchWindow::handleJIDsAdded(std::vector<JID> jids) {

onJIDAddRequested(jids);

}

#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(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);

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(boost::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 setJIDs(const std::vector<JID> &jids);

virtual void setRoomJID(const JID &roomJID);

virtual std::string getReason() const;

virtual std::vector<JID> getJIDs() const;

virtual void setCanStartImpromptuChats(bool supportsImpromptu);

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 handleJIDsAdded(std::vector<JID> jids);

private:

void setFirstPage(QString title = "");

void setSecondPage();

void setThirdPage();

private:

void clearForm();

UserSearchDelegate* delegate_;

QtUserSearchFirstPage* firstPage_;

QtUserSearchFirstMultiJIDPage* firstMultiJIDPage_;

QtUserSearchFieldsPage* fieldsPage_;

QtUserSearchResultsPage* resultsPage_;

QtUserSearchDetailsPage* detailsPage_;

JID myServer_;

JID roomJID_;

int lastPage_;

SettingsProvider* settings_;

bool searchNext_;

bool supportsImpromptu_;

};

}