+ case Qt::DisplayRole: return chat_.impromptuJIDs.empty() ? P2QSTRING(chat_.chatName) : P2QSTRING(chat_.getImpromptuTitle());

+ settings_ = settings;

+ QRegExp hasTrailingGarbage("^(.[-\\w\\s,&]+)([^\\s\\,w].*)$");

+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageKind_(PreviosuMessageWasNone), eventStream_(eventStream), blockingState_(BlockingUnsupported), isMUC_(false), supportsImpromptuChat_(false) {

+ connect(jsBridge, SIGNAL(buttonClicked(QString,QString,QString,QString,QString,QString)), this, SLOT(handleHTMLButtonClicked(QString,QString,QString,QString,QString,QString)));

+void QtChatWindow::convertToMUC(bool impromptuMUC) {

+ impromptu_ = impromptuMUC;

+ isMUC_ = true;

+ subject_->setVisible(!impromptu_);

+QString QtChatWindow::buildChatWindowButton(const QString& name, const QString& id, const QString& arg1, const QString& arg2, const QString& arg3, const QString& arg4, const QString& arg5) {

+ QString html = QString("<input id='%2' type='submit' value='%1' onclick='chatwindow.buttonClicked(\"%2\", \"%3\", \"%4\", \"%5\", \"%6\", \"%7\");' />").arg(name).arg(id).arg(encodeButtonArgument(arg1)).arg(encodeButtonArgument(arg2)).arg(encodeButtonArgument(arg3)).arg(encodeButtonArgument(arg4)).arg(encodeButtonArgument(arg5));

+void QtChatWindow::handleHTMLButtonClicked(QString id, QString encodedArgument1, QString encodedArgument2, QString encodedArgument3, QString encodedArgument4, QString encodedArgument5) {

+ QString arg4 = decodeButtonArgument(encodedArgument4);

+ QString arg5 = decodeButtonArgument(encodedArgument5);

+ QString isImpromptu = arg4;

+ QString isContinuation = arg5;

+ eventStream_->send(boost::make_shared<JoinMUCUIEvent>(Q2PSTRING(roomJID), Q2PSTRING(password), boost::optional<std::string>(), false, false, isImpromptu.contains("true"), isContinuation.contains("true")));

+ if (!isMUC_) {

+ event->acceptProposedAction();

+ }

+ } else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid")) {

+ if (isMUC_ || supportsImpromptuChat_) {

+ event->acceptProposedAction();

+ }

+ if (event->mimeData()->hasUrls()) {

+ if (event->mimeData()->urls().size() == 1) {

+ onSendFileRequest(Q2PSTRING(event->mimeData()->urls().at(0).toLocalFile()));

+ } else {

+ std::string messageText(Q2PSTRING(tr("Sending of multiple files at once isn't supported at this time.")));

+ ChatMessage message;

+ message.append(boost::make_shared<ChatTextMessagePart>(messageText));

+ addSystemMessage(message, DefaultDirection);

+ }

+ } else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid")) {

+ QByteArray dataBytes = event->mimeData()->data("application/vnd.swift.contact-jid");

+ QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);

+ QString jidString;

+ dataStream >> jidString;

+ onInviteToChat(std::vector<JID>(1, JID(Q2PSTRING(jidString))));

+

+ if (supportsImpromptuChat_) {

+ invite = contextMenu.addAction(tr("Invite person to this chat…"));

+ }

+

+ if (impromptu_) {

+ // hide options we don't need in impromptu chats

+ if (availableAction == ChatWindow::ChangeSubject ||

+ availableAction == ChatWindow::Configure ||

+ availableAction == ChatWindow::Affiliations ||

+ availableAction == ChatWindow::Destroy) {

+ continue;

+ }

+ }

+ onInviteToChat(std::vector<JID>());

+void QtChatWindow::setCanInitiateImpromptuChats(bool supportsImpromptu) {

+ supportsImpromptuChat_ = supportsImpromptu;

+}

+

+void QtChatWindow::addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) {

+ QString message;

+ if (isImpromptu) {

+ message = QObject::tr("You've been invited to join a chat.") + "\n";

+ } else {

+ message = QObject::tr("You've been invited to enter the %1 room.").arg(P2QSTRING(jid.toString())) + "\n";

+ }

+ buildChatWindowButton(chatMessageToHTML(ChatMessage(Q2PSTRING((tr("Accept Invite"))))), ButtonMUCInvite, QtUtilities::htmlEscape(P2QSTRING(jid.toString())), QtUtilities::htmlEscape(P2QSTRING(password)), id, QtUtilities::htmlEscape(isImpromptu ? "true" : "false"), QtUtilities::htmlEscape(isContinuation ? "true" : "false")) +

+ void convertToMUC(bool impromptuMUC = false);

+ void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct = true, bool isImpromptu = false, bool isContinuation = false);

+ virtual void setCanInitiateImpromptuChats(bool supportsImpromptu);

+ static QString buildChatWindowButton(const QString& name, const QString& id, const QString& arg1 = QString(), const QString& arg2 = QString(), const QString& arg3 = QString(), const QString& arg4 = QString(), const QString& arg5 = QString());

+ void handleHTMLButtonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);

+ bool impromptu_;

+ bool isMUC_;

+ bool supportsImpromptuChat_;

+ void buttonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);

+ addUserAction_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_D));

+ chatUserAction_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));

+ return new QtUserSearchWindow(eventStream, type, groups, qtOnlySettings);

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

+ drawBackground(painter, option, index);

+ setDragEnabled(true);

+ QTreeView::dragMoveEvent(event);

+#include <QMimeData>

+}

+Qt::ItemFlags RosterModel::flags(const QModelIndex& index) const {

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

+ if (dynamic_cast<GroupRosterItem*>(getItem(index)) == NULL) {

+ flags |= Qt::ItemIsDragEnabled;

+ }

+ return flags;

+}

+

+QMimeData* RosterModel::mimeData(const QModelIndexList& indexes) const {

+ QMimeData* data = QAbstractItemModel::mimeData(indexes);

+

+ ContactRosterItem *item = dynamic_cast<ContactRosterItem*>(getItem(indexes.first()));

+ if (item == NULL) {

+ return data;

+ }

+

+ QByteArray itemData;

+ QDataStream dataStream(&itemData, QIODevice::WriteOnly);

+

+ // jid, chatName, activity, statusType, avatarPath

+ dataStream << P2QSTRING(item->getJID().toString());

+ dataStream << P2QSTRING(item->getDisplayName());

+ dataStream << P2QSTRING(item->getStatusText());

+ dataStream << item->getSimplifiedStatusShow();

+ dataStream << P2QSTRING(item->getAvatarPath().string());

+ data->setData("application/vnd.swift.contact-jid", itemData);

+ return data;

+}

+

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

+ QMimeData* mimeData(const QModelIndexList& indexes) const;

+

+ "UserSearch/ContactListDelegate.cpp",

+ "UserSearch/ContactListModel.cpp",

+ "UserSearch/QtContactListWidget.cpp",

+ "UserSearch/QtSuggestingJIDInput.cpp",

+ "UserSearch/QtUserSearchFirstMultiJIDPage.cpp",

+myenv.Uic4("UserSearch/QtUserSearchFirstMultiJIDPage.ui")

+/*

+ * 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;

+ }

+ const Contact* contact = static_cast<Contact*>(index.internalPointer());

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

+}

+

+QSize ContactListDelegate::sizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const {

+ QFontMetrics nameMetrics(common_.nameFont);

+ QFontMetrics statusMetrics(common_.detailFont);

+ int sizeByText = 2 * common_.verticalMargin + nameMetrics.height() + statusMetrics.height();

+ return QSize(150, sizeByText);

+}

+

+void ContactListDelegate::setCompact(bool compact) {

+ compact_ = compact;

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QStyledItemDelegate>

+

+#include <Swift/QtUI/Roster/DelegateCommons.h>

+

+namespace Swift {

+

+class ContactListDelegate : public QStyledItemDelegate {

+ public:

+ ContactListDelegate(bool compact);

+ virtual ~ContactListDelegate();

+

+ QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;

+ void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;

+

+ public slots:

+ void setCompact(bool compact);

+

+ private:

+ bool compact_;

+ DelegateCommons common_;

+};

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swiften/Base/Path.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Elements/StatusShow.h>

+

+#include <QMimeData>

+

+namespace Swift {

+

+QDataStream& operator >>(QDataStream& in, StatusShow::Type& e){

+ quint32 buffer;

+ in >> buffer;

+ switch(buffer) {

+ case StatusShow::Online:

+ e = StatusShow::Online;

+ break;

+ case StatusShow::Away:

+ e = StatusShow::Away;

+ break;

+ case StatusShow::FFC:

+ e = StatusShow::FFC;

+ break;

+ case StatusShow::XA:

+ e = StatusShow::XA;

+ break;

+ case StatusShow::DND:

+ e = StatusShow::DND;

+ break;

+ default:

+ e = StatusShow::None;

+ break;

+ }

+ return in;

+}

+

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

+}

+

+void ContactListModel::setList(const std::vector<Contact>& list) {

+ emit layoutAboutToBeChanged();

+ contacts_ = list;

+ emit layoutChanged();

+}

+

+const std::vector<Contact>& ContactListModel::getList() const {

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

+ const Contact& contact = contacts_[index.row()];

+ if (role == Qt::EditRole) {

+ return P2QSTRING(contact.jid.toString());

+ }

+ return dataForContact(contact, role);

+ } else {

+ return QVariant();

+ }

+}

+

+bool ContactListModel::dropMimeData(const QMimeData* data, Qt::DropAction /*action*/, int /*row*/, int /*column*/, const QModelIndex& /*parent*/) {

+ if (!data->hasFormat("application/vnd.swift.contact-jid")) {

+ return false;

+ }

+

+ QByteArray dataBytes = data->data("application/vnd.swift.contact-jid");

+ QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);

+ QString jidString;

+ QString displayName;

+ QString statusText;

+ StatusShow::Type statusType;

+ QString avatarPath;

+

+ dataStream >> jidString;

+ dataStream >> displayName;

+ dataStream >> statusText;

+ dataStream >> statusType;

+ dataStream >> avatarPath;

+

+ JID jid = JID(Q2PSTRING(jidString));

+

+ foreach(const Contact& contact, contacts_) {

+ if (contact.jid == jid) {

+ return false;

+ }

+ }

+

+ emit layoutAboutToBeChanged();

+ contacts_.push_back(Contact(Q2PSTRING(displayName), jid, statusType, Q2PSTRING(avatarPath)));

+ emit layoutChanged();

+

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

+ onListChanged(getList());

+

+ return true;

+}

+

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

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

+ return QModelIndex();

+ }

+

+ return boost::numeric_cast<size_t>(row) < contacts_.size() ? createIndex(row, column, (void*)&(contacts_[row])) : QModelIndex();

+}

+

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

+ if (!index.isValid()) {

+ return QModelIndex();

+ }

+ return QModelIndex();

+}

+

+int ContactListModel::rowCount(const QModelIndex& /*parent*/) const {

+ return contacts_.size();

+}

+

+bool ContactListModel::removeRows(int row, int /*count*/, const QModelIndex& /*parent*/) {

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

+ emit layoutAboutToBeChanged();

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

+ emit layoutChanged();

+ onListChanged(getList());

+ return true;

+ }

+ return false;

+}

+

+QVariant ContactListModel::dataForContact(const Contact& contact, int role) const {

+ switch (role) {

+ case Qt::DisplayRole: return P2QSTRING(contact.name);

+ case DetailTextRole: return P2QSTRING(contact.jid.toString());

+ case AvatarRole: return QVariant(P2QSTRING(pathToString(contact.avatarPath)));

+ case PresenceIconRole: return getPresenceIconForContact(contact);

+ default: return QVariant();

+ }

+}

+

+QIcon ContactListModel::getPresenceIconForContact(const Contact& contact) const {

+ QString iconString;

+ switch (contact.statusType) {

+ case StatusShow::Online: iconString = "online";break;

+ case StatusShow::Away: iconString = "away";break;

+ case StatusShow::XA: iconString = "away";break;

+ case StatusShow::FFC: iconString = "online";break;

+ case StatusShow::DND: iconString = "dnd";break;

+ case StatusShow::None: iconString = "offline";break;

+ }

+ return QIcon(":/icons/" + iconString + ".png");

+}

+

+}

+/*

+ * 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 <boost/bind.hpp>

+#include <Swiften/Base/boost_bsignals.h>

+

+#include <QAbstractItemModel>

+

+#include <Swift/Controllers/Contact.h>

+#include <Swift/QtUI/ChatList/ChatListItem.h>

+#include <Swift/QtUI/ChatList/ChatListGroupItem.h>

+#include <Swift/QtUI/ChatList/ChatListRecentItem.h>

+

+namespace Swift {

+ class ContactListModel : public QAbstractItemModel {

+ Q_OBJECT

+ public:

+ enum ContactRoles {

+ DetailTextRole = Qt::UserRole,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2

+ };

+

+ public:

+ ContactListModel(bool editable);

+

+ void setList(const std::vector<Contact>& list);

+ const std::vector<Contact>& getList() const;

+

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

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

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

+ bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);

+ 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:

+ QVariant dataForContact(const Contact& contact, int role) const;

+ QIcon getPresenceIconForContact(const Contact& contact) const;

+

+ signals:

+ void onListChanged(std::vector<Contact> list);

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

+

+ private:

+ bool editable_;

+ std::vector<Contact> contacts_;

+ };

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

+

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

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

+#include <Swift/QtUI/QtUISettingConstants.h>

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

+#include <Swift/QtUI/QtVCardWidget/QtRemovableItemDelegate.h>

+

+#include <QHeaderView>

+

+namespace Swift {

+

+QtContactListWidget::QtContactListWidget(QWidget* parent, SettingsProvider* settings) : QTreeView(parent), settings_(settings), limited_(false) {

+ contactListModel_ = new ContactListModel(true);

+ setModel(contactListModel_);

+

+ connect(contactListModel_, SIGNAL(onListChanged(std::vector<Contact>)), this, SLOT(handleListChanged(std::vector<Contact>)));

+ connect(contactListModel_, SIGNAL(onListChanged(std::vector<Contact>)), this, SIGNAL(onListChanged(std::vector<Contact>)));

+ connect(contactListModel_, SIGNAL(onJIDsDropped(std::vector<JID>)), this, SIGNAL(onJIDsAdded(std::vector<JID>)));

+

+ setSelectionMode(QAbstractItemView::SingleSelection);

+ setSelectionBehavior(QAbstractItemView::SelectRows);

+ setDragEnabled(true);

+ setAcceptDrops(true);

+ setDropIndicatorShown(true);

+ setUniformRowHeights(true);

+

+ setAlternatingRowColors(true);

+ setIndentation(0);

+ setHeaderHidden(true);

+ setExpandsOnDoubleClick(false);

+ setItemsExpandable(false);

+ setEditTriggers(QAbstractItemView::DoubleClicked);

+

+ contactListDelegate_ = new ContactListDelegate(settings->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ removableItemDelegate_ = new QtRemovableItemDelegate(style());

+

+ setItemDelegateForColumn(0, contactListDelegate_);

+ setItemDelegateForColumn(1, removableItemDelegate_);

+

+ int closeIconWidth = fontMetrics().height();

+ header()->resizeSection(1, closeIconWidth);

+

+ header()->setStretchLastSection(false);

+#if QT_VERSION >= 0x050000

+ header()->setSectionResizeMode(0, QHeaderView::Stretch);

+#else

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

+#endif

+}

+

+QtContactListWidget::~QtContactListWidget() {

+ delete contactListDelegate_;

+ delete removableItemDelegate_;

+}

+

+void QtContactListWidget::setList(const std::vector<Contact>& list) {

+ contactListModel_->setList(list);

+}

+

+std::vector<Contact> QtContactListWidget::getList() const {

+ return contactListModel_->getList();

+}

+

+void QtContactListWidget::setMaximumNoOfContactsToOne(bool limited) {

+ limited_ = limited;

+ if (limited) {

+ handleListChanged(getList());

+ } else {

+ setAcceptDrops(true);

+ setDropIndicatorShown(true);

+ }

+}

+

+void QtContactListWidget::updateContacts(const std::vector<Contact>& contactUpdates) {

+ std::vector<Contact> contacts = contactListModel_->getList();

+ foreach(const Contact& contactUpdate, contactUpdates) {

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

+ if (contactUpdate.jid == contacts[n].jid) {

+ contacts[n] = contactUpdate;

+ break;

+ }

+ }

+ }

+ contactListModel_->setList(contacts);

+}

+

+void QtContactListWidget::handleListChanged(std::vector<Contact> list) {

+ if (limited_) {

+ setAcceptDrops(list.size() <= 1);

+ setDropIndicatorShown(list.size() <= 1);

+ }

+}

+

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

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

+}

+

+}

+/*

+ * 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 <QTreeView>

+

+#include <Swift/Controllers/Contact.h>

+#include <Swiften/Base/Log.h>

+

+#include <QDragEnterEvent>

+#include <QDragMoveEvent>

+#include <QDropEvent>

+

+namespace Swift {

+

+class ContactListDelegate;

+class ContactListModel;

+class SettingsProvider;

+class QtRemovableItemDelegate;

+

+class QtContactListWidget : public QTreeView {

+ Q_OBJECT

+public:

+ QtContactListWidget(QWidget* parent, SettingsProvider* settings);

+ virtual ~QtContactListWidget();

+

+ void setList(const std::vector<Contact>& list);

+ std::vector<Contact> getList() const;

+ void setMaximumNoOfContactsToOne(bool limited);

+

+public slots:

+ void updateContacts(const std::vector<Contact>& contactUpdates);

+

+signals:

+ void onListChanged(std::vector<Contact> list);

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

+

+private slots:

+ void handleListChanged(std::vector<Contact> list);

+

+private:

+ void handleSettingsChanged(const std::string&);

+

+private:

+ SettingsProvider* settings_;

+ ContactListModel* contactListModel_;

+ ContactListDelegate* contactListDelegate_;

+ QtRemovableItemDelegate* removableItemDelegate_;

+ bool limited_;

+};

+

+}

+/*

+ * 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 <Swift/QtUI/QtSwiftUtil.h>

+

+#include <QAbstractItemView>

+#include <QApplication>

+#include <QDesktopWidget>

+#include <QKeyEvent>

+

+

+namespace Swift {

+

+QtSuggestingJIDInput::QtSuggestingJIDInput(QWidget* parent, SettingsProvider* settings) : QLineEdit(parent), settings_(settings), currentContact_(NULL) {

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

+ treeViewPopup_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

+ treeViewPopup_->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

+ QSizePolicy policy(treeViewPopup_->sizePolicy());

+ policy.setVerticalPolicy(QSizePolicy::Expanding);

+ treeViewPopup_->setSizePolicy(policy);

+ treeViewPopup_->hide();

+ treeViewPopup_->setFocusProxy(this);

+ connect(treeViewPopup_, SIGNAL(clicked(QModelIndex)), this, SLOT(handleClicked(QModelIndex)));

+ connect(treeViewPopup_, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(handleClicked(QModelIndex)));

+

+ contactListModel_ = new ContactListModel(false);

+ treeViewPopup_->setModel(contactListModel_);

+

+ contactListDelegate_ = new ContactListDelegate(settings->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ treeViewPopup_->setItemDelegate(contactListDelegate_);

+

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

+}

+

+QtSuggestingJIDInput::~QtSuggestingJIDInput() {

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

+ delete treeViewPopup_;

+}

+

+const Contact* QtSuggestingJIDInput::getContact() {

+ if (currentContact_ != NULL) {

+ return currentContact_;

+ } else {

+ if (!text().isEmpty()) {

+ JID jid(Q2PSTRING(text()));

+ if (jid.isValid()) {

+ manualContact_.name = jid.toString();

+ manualContact_.jid = jid;

+ return &manualContact_;

+ }

+ }

+ return NULL;

+ }

+}

+

+void QtSuggestingJIDInput::setSuggestions(const std::vector<Contact>& suggestions) {

+ contactListModel_->setList(suggestions);

+ positionPopup();

+ if (!suggestions.empty()) {

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

+ showPopup();

+ } else {

+ currentContact_ = NULL;

+ }

+}

+

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

+ currentContact_ = &contactListModel_->getList()[index.row()];

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

+ hidePopup();

+ clearFocus();

+ } else {

+ currentContact_ = NULL;

+ }

+ 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

+ to prevent stealing of focus when opening a the suggestion window. */

+ QWidget* now = qApp->focusWidget();

+ if (!now || (now != treeViewPopup_ && now != this && !now->isAncestorOf(this) && !now->isAncestorOf(treeViewPopup_) && !this->isAncestorOf(now) && !treeViewPopup_->isAncestorOf(now))) {

+ hidePopup();

+ }

+}

+

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

+ currentContact_ = &contactListModel_->getList()[index.row()];

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

+ hidePopup();

+ }

+}

+

+void QtSuggestingJIDInput::positionPopup() {

+ QDesktopWidget* desktop = QApplication::desktop();

+ int screen = desktop->screenNumber(this);

+ QPoint point = mapToGlobal(QPoint(0, height()));

+ QRect geometry = desktop->availableGeometry(screen);

+ int x = point.x();

+ int y = point.y();

+ int width = this->width();

+ int height = 80;

+

+ int screenWidth = geometry.x() + geometry.width();

+ if (x + width > screenWidth) {

+ x = screenWidth - width;

+ }

+

+ height = treeViewPopup_->sizeHintForRow(0) * contactListModel_->rowCount();

+ height = height > 200 ? 200 : height;

+

+ int marginLeft;

+ int marginTop;

+ int marginRight;

+ int marginBottom;

+ treeViewPopup_->getContentsMargins(&marginLeft, &marginTop, &marginRight, &marginBottom);

+ height += marginTop + marginBottom;

+ width += marginLeft + marginRight;

+

+ treeViewPopup_->setGeometry(x, y, width, height);

+ treeViewPopup_->move(x, y);

+ treeViewPopup_->setMaximumWidth(width);

+}

+

+void QtSuggestingJIDInput::showPopup() {

+ treeViewPopup_->show();

+ activateWindow();

+ connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(handleApplicationFocusChanged(QWidget*, QWidget*)), Qt::QueuedConnection);

+ setFocus();

+}

+

+void QtSuggestingJIDInput::hidePopup() {

+ disconnect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(handleApplicationFocusChanged(QWidget*, QWidget*)));

+ treeViewPopup_->hide();

+}

+

+}

+/*

+ * 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 <Swift/Controllers/Contact.h>

+

+namespace Swift {

+

+class ContactListDelegate;

+class SettingsProvider;

+class ContactListModel;

+

+class QtSuggestingJIDInput : public QLineEdit {

+ Q_OBJECT

+ public:

+ QtSuggestingJIDInput(QWidget* parent, SettingsProvider* settings);

+ virtual ~QtSuggestingJIDInput();

+

+ const Contact* getContact();

+

+ void setSuggestions(const std::vector<Contact>& suggestions);

+

+ signals:

+ void editingDone();

+

+ protected:

+ virtual void keyPressEvent(QKeyEvent* event);

+

+ private:

+ void handleSettingsChanged(const std::string& setting);

+

+ private slots:

+ void handleClicked(const QModelIndex& index);

+ void handleApplicationFocusChanged(QWidget* old, QWidget* now);

+

+ private:

+ void positionPopup();

+ void showPopup();

+ void hidePopup();

+

+ private:

+ SettingsProvider* settings_;

+ ContactListModel* contactListModel_;

+ QTreeView* treeViewPopup_;

+ ContactListDelegate* contactListDelegate_;

+ Contact manualContact_;

+ const Contact* currentContact_;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h"

+

+#include "Swift/QtUI/QtSwiftUtil.h"

+#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

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

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

+

+namespace Swift {

+

+QtUserSearchFirstMultiJIDPage::QtUserSearchFirstMultiJIDPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {

+ setupUi(this);

+ setTitle(title);

+ QString introText = "";

+ switch (type) {

+ case UserSearchWindow::AddContact:

+ introText = tr("Add another user to your contact list");

+ break;

+ case UserSearchWindow::ChatToContact:

+ introText = tr("Chat to another user");

+ break;

+ case UserSearchWindow::InviteToChat:

+ introText = tr("Invite contact to chat");

+ break;

+ }

+

+ setSubTitle(QString(tr("%1. If you know their address you can enter it directly, or you can search for them.")).arg(introText));

+

+ contactList_ = new QtContactListWidget(this, settings);

+ horizontalLayout_5->addWidget(contactList_);

+

+ jid_ = new QtSuggestingJIDInput(this, settings);

+ horizontalLayout_6->insertWidget(0, jid_);

+

+ connect(contactList_, SIGNAL(onListChanged(std::vector<Contact>)), this, SLOT(emitCompletenessCheck()));

+ connect(jid_, SIGNAL(editingDone()), this, SLOT(handleEditingDone()));

+}

+

+bool QtUserSearchFirstMultiJIDPage::isComplete() const {

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

+}

+

+void QtUserSearchFirstMultiJIDPage::emitCompletenessCheck() {

+ emit completeChanged();

+}

+

+void QtUserSearchFirstMultiJIDPage::handleEditingDone() {

+ addContactButton_->setFocus();

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QWizardPage>

+

+#include <Swift/QtUI/UserSearch/ui_QtUserSearchFirstMultiJIDPage.h>

+#include <Swift/Controllers/UIInterfaces/UserSearchWindow.h>

+

+namespace Swift {

+ class UserSearchModel;

+ class UserSearchDelegate;

+ class UserSearchResult;

+ class UIEventStream;

+ class QtContactListWidget;

+ class ContactSuggester;

+ class AvatarManager;

+ class VCardManager;

+ class SettingsProvider;

+ class QtSuggestingJIDInput;

+

+ class QtUserSearchFirstMultiJIDPage : public QWizardPage, public Ui::QtUserSearchFirstMultiJIDPage {

+ Q_OBJECT

+ public:

+ QtUserSearchFirstMultiJIDPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings);

+ virtual bool isComplete() const;

+

+ public slots:

+ void emitCompletenessCheck();

+ void handleEditingDone();

+

+ public:

+ QtContactListWidget* contactList_;

+ QtSuggestingJIDInput* jid_;

+ };

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtUserSearchFirstMultiJIDPage</class>

+ <widget class="QWizardPage" name="QtUserSearchFirstMultiJIDPage">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>477</width>

+ <height>500</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string/>

+ </property>

+ <property name="title">

+ <string>Add a user</string>

+ </property>

+ <property name="subTitle">

+ <string>Add another user to your contact list. If you know their address you can add them directly, or you can search for them.</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <item>

+ <widget class="QLabel" name="howLabel_">

+ <property name="text">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_5"/>

+ </item>

+ <item>

+ <widget class="QGroupBox" name="groupBox">

+ <property name="minimumSize">

+ <size>

+ <width>0</width>

+ <height>0</height>

+ </size>

+ </property>

+ <property name="title">

+ <string>Choose another contact</string>

+ </property>

+ <property name="flat">

+ <bool>false</bool>

+ </property>

+ <property name="checkable">

+ <bool>false</bool>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout_3">

+ <property name="spacing">

+ <number>-1</number>

+ </property>

+ <property name="margin">

+ <number>6</number>

+ </property>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_6" stretch="0">

+ <property name="spacing">

+ <number>-1</number>

+ </property>

+ <item>

+ <widget class="QPushButton" name="addContactButton_">

+ <property name="autoFillBackground">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Add Contact</string>

+ </property>

+ <property name="default">

+ <bool>false</bool>

+ </property>

+ <property name="flat">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <widget class="Line" name="line">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_3">

+ <item>

+ <widget class="QRadioButton" name="byLocalSearch_">

+ <property name="text">

+ <string>I'd like to search my server</string>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <item>

+ <widget class="QRadioButton" name="byRemoteSearch_">

+ <property name="text">

+ <string>I'd like to search another server:</string>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QComboBox" name="service_">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Expanding" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="editable">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_2">

+ <item>

+ <spacer name="horizontalSpacer_2">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QPushButton" name="addViaSearchButton_">

+ <property name="text">

+ <string>Add via Search</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_4">

+ <item>

+ <widget class="QLabel" name="label">

+ <property name="text">

+ <string>Reason:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLineEdit" name="reason_"/>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <spacer name="verticalSpacer_2">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>20</width>

+ <height>77</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QLabel" name="errorLabel_">

+ <property name="text">

+ <string/>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignCenter</set>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="verticalSpacer">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>20</width>

+ <height>40</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

+#include <Swiften/Base/Log.h>

+

+QtUserSearchFirstPage::QtUserSearchFirstPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {

+ jid_ = new QtSuggestingJIDInput(this, settings);

+ horizontalLayout_2->addWidget(jid_);

+ setTabOrder(byJID_, jid_);

+ setTabOrder(jid_, byLocalSearch_);

+ setTabOrder(byLocalSearch_, byRemoteSearch_);

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

+

+ QtUserSearchFirstPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings);

+ public:

+ QtSuggestingJIDInput* jid_;

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

+#include <Swift/Controllers/UIEvents/AddContactUIEvent.h>

+#include <Swift/Controllers/UIEvents/CreateImpromptuMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>

+#include <Swift/QtUI/UserSearch/UserSearchModel.h>

+#include <Swift/QtUI/UserSearch/UserSearchDelegate.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swift/QtUI/QtFormResultItemModel.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchFieldsPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchResultsPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchDetailsPage.h>

+#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

+

+#include <Swiften/Base/Log.h>

+QtUserSearchWindow::QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider) : eventStream_(eventStream), type_(type), model_(NULL), settings_(settingsProvider), searchNext_(false), supportsImpromptu_(false) {

+ QString title;

+ switch(type) {

+ case AddContact:

+ title = tr("Add Contact");

+ break;

+ case ChatToContact:

+ title = tr("Chat to Users");

+ break;

+ case InviteToChat:

+ title = tr("Add Users to Chat");

+ break;

+ }

+ setFirstPage(title);

+ setSecondPage();

+ setThirdPage();

+ searchNext_ = false;

+ if (page == 1 && lastPage_ == 3) {

+ addSearchedJIDToList(getContactJID());

+ setSecondPage();

+ }

+ else if (page == 2 && lastPage_ == 1) {

+ setThirdPage();

+ JID server = getServerToSearch();

+

+ if (type_ == AddContact) {

+ bool remote = firstPage_->byRemoteSearch_->isChecked();

+ firstPage_->byRemoteSearch_->setChecked(remote);

+ firstPage_->service_->setEditText(P2QSTRING(server.toString()));

+ } else {

+ bool remote = firstMultiJIDPage_->byRemoteSearch_->isChecked();

+ setFirstPage();

+ firstMultiJIDPage_->byRemoteSearch_->setChecked(remote);

+ firstMultiJIDPage_->service_->setEditText(P2QSTRING(server.toString()));

+ }

+ 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_;

+ }

+ JID jid;

+ std::vector<JID> jids;

+ switch(type_) {

+ case AddContact:

+ jid = getContactJID();

+ eventStream_->send(boost::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));

+ break;

+ case ChatToContact:

+ if (contactVector_.size() == 1) {

+ boost::shared_ptr<UIEvent> event(new RequestChatUIEvent(contactVector_[0].jid));

+ eventStream_->send(event);

+ break;

+ }

+ foreach(const Contact& contact, contactVector_) {

+ jids.push_back(contact.jid);

+ }

+

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

+ break;

+ case InviteToChat:

+ foreach(const Contact& contact, contactVector_) {

+ jids.push_back(contact.jid);

+ }

+ eventStream_->send(boost::make_shared<InviteToMUCUIEvent>(roomJID_, jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));

+ break;

+}

+

+void QtUserSearchWindow::handleContactSuggestionRequested(const QString& text) {

+ std::string stdText = Q2PSTRING(text);

+ onContactSuggestionsRequested(stdText);

+}

+

+void QtUserSearchWindow::addContact() {

+ if (firstMultiJIDPage_->jid_->getContact() != 0) {

+ Contact contact = *(firstMultiJIDPage_->jid_->getContact());

+ contactVector_.push_back(contact);

+ }

+ firstMultiJIDPage_->contactList_->setList(contactVector_);

+ firstMultiJIDPage_->emitCompletenessCheck();

+ if (type_ == ChatToContact) {

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

+ if (type_ == AddContact) {

+ switch (currentId()) {

+ case 1: return firstPage_->byJID_->isChecked() ? (type_ == AddContact ? 4 : -1) : 2;

+ case 2: return 3;

+ case 3: return type_ == AddContact ? 4 : -1;

+ case 4: return -1;

+ default: return -1;

+ }

+ } else {

+ switch (currentId()) {

+ case 1: return searchNext_ ? 2 : -1;

+ case 2: return 3;

+ case 3: return 1;

+ case 4: return -1;

+ default: return -1;

+ }

+

+ bool useSearchResult;

+ if (type_ == AddContact) {

+ useSearchResult = !firstPage_->byJID_->isChecked();

+ } else {

+ useSearchResult = true;

+ }

+

+ if (useSearchResult) {

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

+ Contact contact(jid, jid.toString(), StatusShow::None, "");

+ contactVector_.push_back(contact);

+ firstMultiJIDPage_->contactList_->setList(contactVector_);

+ firstMultiJIDPage_->emitCompletenessCheck();

+ if (type_ == ChatToContact) {

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

+ }

+}

+

+ if (type_ == AddContact) {

+ firstPage_->service_->clear();

+ foreach (JID jid, services) {

+ firstPage_->service_->addItem(P2QSTRING(jid.toString()));

+ }

+ firstPage_->service_->clearEditText();

+ } else {

+ firstMultiJIDPage_->service_->clear();

+ foreach (JID jid, services) {

+ firstMultiJIDPage_->service_->addItem(P2QSTRING(jid.toString()));

+ }

+ firstMultiJIDPage_->service_->clearEditText();

+void QtUserSearchWindow::setContactSuggestions(const std::vector<Contact>& suggestions) {

+ if (type_ == AddContact) {

+ firstPage_->jid_->setSuggestions(suggestions);

+ } else {

+ firstMultiJIDPage_->jid_->setSuggestions(suggestions);

+ }

+}

+

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

+ foreach(JID jid, jids) {

+ addSearchedJIDToList(jid);

+ }

+ onJIDUpdateRequested(jids);

+}

+

+void QtUserSearchWindow::setRoomJID(const JID& roomJID) {

+ roomJID_ = roomJID;

+}

+

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

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

+}

+

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

+ std::vector<JID> jids;

+ foreach (const Contact& 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>& contacts) {

+ if (type_ != AddContact) {

+ firstMultiJIDPage_->contactList_->updateContacts(contacts);

+ }

+}

+

+void QtUserSearchWindow::handleAddViaSearch() {

+ searchNext_ = true;

+ next();

+}

+

+void QtUserSearchWindow::handleListChanged(std::vector<Contact> list) {

+ contactVector_ = list;

+ if (type_ == ChatToContact) {

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

+ }

+}

+

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

+ onJIDUpdateRequested(jids);

+}

+

+void QtUserSearchWindow::setFirstPage(QString title) {

+ if (page(1) != 0) {

+ removePage(1);

+ }

+ if (type_ == AddContact) {

+ firstPage_ = new QtUserSearchFirstPage(type_, title.isEmpty() ? firstPage_->title() : title, settings_);

+ connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));

+ connect(firstPage_->byJID_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

+ connect(firstPage_->byLocalSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

+ connect(firstPage_->byRemoteSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

+#if QT_VERSION >= 0x040700

+ firstPage_->jid_->setPlaceholderText(tr("alice@wonderland.lit"));

+#endif

+ firstPage_->service_->setEnabled(false);

+ setPage(1, firstPage_);

+ } else {

+ firstMultiJIDPage_ = new QtUserSearchFirstMultiJIDPage(type_, title.isEmpty() ? firstMultiJIDPage_->title() : title, settings_);

+ connect(firstMultiJIDPage_->addContactButton_, SIGNAL(clicked()), this, SLOT(addContact()));

+ connect(firstMultiJIDPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));

+ connect(firstMultiJIDPage_->addViaSearchButton_, SIGNAL(clicked()), this, SLOT(handleAddViaSearch()));

+ connect(firstMultiJIDPage_->contactList_, SIGNAL(onListChanged(std::vector<Contact>)), this, SLOT(handleListChanged(std::vector<Contact>)));

+ connect(firstMultiJIDPage_->contactList_, SIGNAL(onJIDsAdded(std::vector<JID>)), this, SLOT(handleJIDsAdded(std::vector<JID>)));

+ setPage(1, firstMultiJIDPage_);

+ }

+}

+

+void QtUserSearchWindow::setSecondPage() {

+ if (page(2) != 0) {

+ removePage(2);

+ }

+ fieldsPage_ = new QtUserSearchFieldsPage();

+ fieldsPage_->fetchingThrobber_->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));

+ fieldsPage_->fetchingThrobber_->movie()->stop();

+ setPage(2, fieldsPage_);

+}

+

+void QtUserSearchWindow::setThirdPage() {

+ if (page(3) != 0) {

+ removePage(3);

+ }

+ resultsPage_ = new QtUserSearchResultsPage();

+

+#ifdef SWIFT_PLATFORM_MACOSX

+ resultsPage_->results_->setAlternatingRowColors(true);

+#endif

+ if (type_ == AddContact) {

+ connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));

+ }

+ else {

+ connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));

+ }

+ setPage(3, resultsPage_);

+}

+

+ firstPage_->errorLabel_->setVisible(false);

+ firstPage_->howLabel_->setText(howText);

+ firstPage_->byJID_->setChecked(true);

+ handleFirstPageRadioChange();

+ } else {

+ contactVector_.clear();

+ firstMultiJIDPage_->contactList_->setList(contactVector_);

+ firstMultiJIDPage_->errorLabel_->setVisible(false);

+ if (type_ == ChatToContact) {

+ howText = QString(tr("Who would you like to chat to?"));

+ } else if (type_ == InviteToChat) {

+ howText = QString(tr("Who do you want to invite to the chat?"));

+ }

+ firstMultiJIDPage_->howLabel_->setText(howText);

+ if (type_ == AddContact) {

+ firstPage_->errorLabel_->hide();

+ } else {

+ firstMultiJIDPage_->errorLabel_->hide();

+ }

+ if (type_ == AddContact) {

+ firstPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));

+ firstPage_->errorLabel_->show();

+ } else {

+ firstMultiJIDPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));

+ firstMultiJIDPage_->errorLabel_->show();

+ }

+ class QtUserSearchFirstMultiJIDPage;

+ class SettingsProvider;

+ QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider);

+ virtual void setContactSuggestions(const std::vector<Contact>& suggestions);

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

+ virtual void updateContacts(const std::vector<Contact> &contacts);

+

+ void handleContactSuggestionRequested(const QString& text);

+ void addContact();

+ void handleAddViaSearch();

+ void handleListChanged(std::vector<Contact> list);

+ void handleJIDsAdded(std::vector<JID> jids);

+

+ private:

+ void setFirstPage(QString title = "");

+ void setSecondPage();

+ void setThirdPage();

+

+ void addSearchedJIDToList(const JID& jid);

+ QtUserSearchFirstMultiJIDPage* firstMultiJIDPage_;

+ JID roomJID_;

+ std::vector<Contact> contactVector_;

+ SettingsProvider* settings_;

+ bool searchNext_;

+ bool supportsImpromptu_;