+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swift/QtUI/MUCSearch/MUCSearchDelegate.h>

+

+#include <QPen>

+#include <Swift/QtUI/MUCSearch/MUCSearchItem.h>

+#include <Swift/QtUI/MUCSearch/MUCSearchRoomItem.h>

+#include <Swift/QtUI/MUCSearch/MUCSearchServiceItem.h>

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

+// // MUCSearchItem* item = static_cast<MUCSearchItem*>(index.internalPointer());

+// // if (item && dynamic_cast<MUCSearchMUCItem*>(item)) {

+// // return mucSizeHint(option, index);

+// // } else if (item && dynamic_cast<MUCSearchGroupItem*>(item)) {

+// // return groupDelegate_->sizeHint(option, index);

+// // }

+// return QStyledItemDelegate::sizeHint(option, index);

+// QFontMetrics nameMetrics(common_.nameFont);

+// QFontMetrics statusMetrics(common_.detailFont);

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

+// return QSize(150, sizeByText);

+// MUCSearchItem* item = static_cast<MUCSearchItem*>(index.internalPointer());

+// if (item && dynamic_cast<MUCSearchMUCItem*>(item)) {

+// paintMUC(painter, option, dynamic_cast<MUCSearchMUCItem*>(item));

+// } else if (item && dynamic_cast<MUCSearchGroupItem*>(item)) {

+// MUCSearchGroupItem* group = dynamic_cast<MUCSearchGroupItem*>(item);

+// groupDelegate_->paint(painter, option, group->data(Qt::DisplayRole).toString(), group->rowCount(), option.state & QStyle::State_Open);

+// } else {

+// QStyledItemDelegate::paint(painter, option, index);

+// }

+// painter->save();

+// QRect fullRegion(option.rect);

+// if ( option.state & QStyle::State_Selected ) {

+// painter->fillRect(fullRegion, option.palette.highlight());

+// painter->setPen(option.palette.highlightedText().color());

+// } else {

+// QColor nameColor = item->data(Qt::TextColorRole).value<QColor>();

+// painter->setPen(QPen(nameColor));

+// }

+

+// QFontMetrics nameMetrics(common_.nameFont);

+// painter->setFont(common_.nameFont);

+// int extraFontWidth = nameMetrics.width("H");

+// int leftOffset = common_.horizontalMargin * 2 + extraFontWidth / 2;

+// QRect textRegion(fullRegion.adjusted(leftOffset, 0, 0, 0));

+

+// int nameHeight = nameMetrics.height() + common_.verticalMargin;

+// QRect nameRegion(textRegion.adjusted(0, common_.verticalMargin, 0, 0));

+

+// painter->drawText(nameRegion, Qt::AlignTop, item->data(Qt::DisplayRole).toString());

+

+// painter->setFont(common_.detailFont);

+// painter->setPen(QPen(QColor(160,160,160)));

+

+// QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

+// painter->drawText(detailRegion, Qt::AlignTop, item->data(DetailTextRole).toString());

+

+// painter->restore();

+ * Copyright (c) 2010-2016 Isode Limited.

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

+ class MUCSearchDelegate : public QStyledItemDelegate {

+ public:

+ MUCSearchDelegate();

+ ~MUCSearchDelegate();

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

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

+ private:

+// void paintMUC(QPainter* painter, const QStyleOptionViewItem& option, MUCSearchMUCItem* item) const;

+// QSize mucSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

+ DelegateCommons common_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <QFont>

+

+#include <Swift/QtUI/MUCSearch/MUCSearchServiceItem.h>

+MUCSearchEmptyItem::MUCSearchEmptyItem() {

+}

+

+void MUCSearchEmptyItem::setParent(std::weak_ptr<MUCSearchServiceItem> parent) {

+ parent_ = parent;

+std::shared_ptr<MUCSearchServiceItem> MUCSearchEmptyItem::getParent() {

+ return parent_.lock();

+ switch (role) {

+ case Qt::DisplayRole:

+ return QVariant(QObject::tr("No rooms found"));

+ case Qt::FontRole: {

+ QFont font;

+ font.setItalic(true);

+ return font;

+ }

+ case Qt::ForegroundRole:

+ return QColor(Qt::gray);

+ default:

+ return QVariant();

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+ class MUCSearchServiceItem;

+ class MUCSearchEmptyItem : public MUCSearchItem {

+ public:

+ MUCSearchEmptyItem();

+ void setParent(std::weak_ptr<MUCSearchServiceItem> parent);

+ std::shared_ptr<MUCSearchServiceItem> getParent();

+ QVariant data(int role);

+ private:

+ std::weak_ptr<MUCSearchServiceItem> parent_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+

+class MUCSearchServiceItem;

+

+class MUCSearchItem {

+ public:

+ virtual ~MUCSearchItem() {}

+ virtual void setParent(std::weak_ptr<MUCSearchServiceItem>) { }

+ virtual QVariant data(int role) = 0;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swift/QtUI/MUCSearch/MUCSearchModel.h>

+

+#include <memory>

+

+#include <Swift/QtUI/MUCSearch/MUCSearchEmptyItem.h>

+ // We need to reset the model, so that model indices containing raw pointers

+ // to MUCSearchServiceItems are invalaidated before we delete the

+ // MUCSearchServiceItems.

+ emit beginResetModel();

+ services_.clear();

+ emit endResetModel();

+void MUCSearchModel::addService(std::shared_ptr<MUCSearchServiceItem> service) {

+ emit layoutAboutToBeChanged();

+ if (sortOrder_) {

+ service->setSorting(*sortOrder_);

+ }

+ services_.push_back(service);

+ emit layoutChanged();

+ return 1;

+ return index.isValid() ? static_cast<MUCSearchItem*>(index.internalPointer())->data(role) : QVariant();

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

+ return QModelIndex();

+ }

+ if (parent.isValid()) {

+ MUCSearchServiceItem* parentItem = static_cast<MUCSearchServiceItem*>(parent.internalPointer());

+ return row < parentItem->rowCount() ? createIndex(row, column, parentItem->getItem(row)) : QModelIndex();

+ } else {

+ return row < services_.size() ? createIndex(row, column, services_[row].get()) : QModelIndex();

+ }

+ if (!index.isValid()) {

+ return QModelIndex();

+ }

+ MUCSearchItem* item = static_cast<MUCSearchItem*>(index.internalPointer());

+ if (!item) {

+ return QModelIndex();

+ }

+ else if (dynamic_cast<MUCSearchServiceItem*>(item)) {

+ return QModelIndex();

+ }

+

+ std::shared_ptr<MUCSearchServiceItem> parent;

+ if (MUCSearchRoomItem* roomItem = dynamic_cast<MUCSearchRoomItem*>(item)) {

+ parent = roomItem->getParent();

+ }

+ else if (MUCSearchEmptyItem* emptyItem = dynamic_cast<MUCSearchEmptyItem*>(item)) {

+ parent = emptyItem->getParent();

+ }

+ if (parent) {

+ int row = services_.indexOf(parent);

+ return createIndex(row, 1, parent.get());

+ }

+ else {

+ return QModelIndex();

+ }

+ if (!parentIndex.isValid()) {

+ return services_.size();

+ }

+ if (dynamic_cast<MUCSearchServiceItem*>(static_cast<MUCSearchItem*>(parentIndex.internalPointer()))) {

+ return services_[parentIndex.row()]->rowCount();

+ }

+ else {

+ return 0;

+ }

+}

+

+void MUCSearchModel::sort(int column, Qt::SortOrder order) {

+ sortOrder_ = order;

+ if (column == 0) {

+ for (auto&& serviceItem : services_) {

+ serviceItem->setSorting(*sortOrder_);

+ }

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <boost/optional.hpp>

+#include <QVector>

+#include <Swift/QtUI/MUCSearch/MUCSearchServiceItem.h>

+ class MUCSearchModel : public QAbstractItemModel {

+ Q_OBJECT

+ public:

+ MUCSearchModel();

+ void clear();

+ void addService(std::shared_ptr<MUCSearchServiceItem> service);

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

+ virtual void sort(int column, Qt::SortOrder order = Qt::AscendingOrder);

+

+ private:

+ QVector<std::shared_ptr<MUCSearchServiceItem>> services_;

+ boost::optional<Qt::SortOrder> sortOrder_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swift/QtUI/MUCSearch/MUCSearchRoomItem.h>

+#include <memory>

+

+#include <Swift/QtUI/MUCSearch/MUCSearchServiceItem.h>

+

+MUCSearchRoomItem::MUCSearchRoomItem(const QString& node) : node_(node) {

+

+void MUCSearchRoomItem::setParent(std::weak_ptr<MUCSearchServiceItem> parent) {

+ parent_ = parent;

+

+std::shared_ptr<MUCSearchServiceItem> MUCSearchRoomItem::getParent() {

+ return parent_.lock();

+}

+

+ switch (role) {

+ case Qt::DisplayRole: return QVariant(node_);

+ default: return QVariant();

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <Swift/QtUI/MUCSearch/MUCSearchItem.h>

+ class MUCSearchServiceItem;

+ class MUCSearchRoomItem : public MUCSearchItem {

+ public:

+ MUCSearchRoomItem(const QString& node);

+ void setParent(std::weak_ptr<MUCSearchServiceItem> parent);

+ std::shared_ptr<MUCSearchServiceItem> getParent();

+ QVariant data(int role);

+ QString getNode() const {return node_;}

+

+ private:

+ std::weak_ptr<MUCSearchServiceItem> parent_;

+ QString node_;

+ };

+/*

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/MUCSearch/MUCSearchServiceItem.h>

+

+#include <memory>

+

+#include <QString>

+#include <QVector>

+#include <QtAlgorithms>

+

+namespace Swift {

+

+MUCSearchServiceItem::MUCSearchServiceItem(const QString& jidString) : jidString_(jidString) {

+

+}

+

+void MUCSearchServiceItem::addRoom(std::shared_ptr<MUCSearchItem> room) {

+ room->setParent(shared_from_this());

+ rooms_.push_back(room);

+ if (sortOrder_) {

+ sort();

+ }

+}

+

+void MUCSearchServiceItem::addRooms(const std::vector<std::shared_ptr<MUCSearchItem> >& rooms) {

+ for (auto&& room: rooms) {

+ room->setParent(shared_from_this());

+ rooms_.push_back(room);

+ }

+ if (sortOrder_) {

+ sort();

+ }

+}

+

+int MUCSearchServiceItem::rowCount() {

+ return rooms_.count();

+}

+

+MUCSearchItem* MUCSearchServiceItem::getItem(int i) {

+ return rooms_[i].get();

+}

+

+QVariant MUCSearchServiceItem::data(int role) {

+ switch (role) {

+ case Qt::DisplayRole:

+ return QVariant(jidString_);

+ default:

+ return QVariant();

+ }

+}

+

+QString MUCSearchServiceItem::getHost() const {

+ return jidString_;

+}

+

+void MUCSearchServiceItem::setSorting(Qt::SortOrder sortOrder) {

+ sortOrder_ = sortOrder;

+ sort();

+}

+

+void MUCSearchServiceItem::sort() {

+ if (*sortOrder_ == Qt::AscendingOrder) {

+ qStableSort(rooms_.begin(), rooms_.end(), [](const std::shared_ptr<MUCSearchItem>& item1, const std::shared_ptr<MUCSearchItem>& item2) -> bool {

+ return QString::localeAwareCompare(item1->data(Qt::DisplayRole).toString(), item2->data(Qt::DisplayRole).toString()) < 0;

+ });

+ }

+ else {

+ qStableSort(rooms_.begin(), rooms_.end(), [](const std::shared_ptr<MUCSearchItem>& item1, const std::shared_ptr<MUCSearchItem>& item2) -> bool {

+ return QString::localeAwareCompare(item1->data(Qt::DisplayRole).toString(), item2->data(Qt::DisplayRole).toString()) > 0;

+ });

+ }

+}

+

+}

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <boost/optional.hpp>

+

+#include <QVector>

+#include <Swift/QtUI/MUCSearch/MUCSearchRoomItem.h>

+ class MUCSearchServiceItem : public MUCSearchItem, public std::enable_shared_from_this<MUCSearchServiceItem> {

+ public:

+ MUCSearchServiceItem(const QString& jidString);

+

+ void addRoom(std::shared_ptr<MUCSearchItem> room);

+ void addRooms(const std::vector<std::shared_ptr<MUCSearchItem>>& rooms);

+ int rowCount();

+ MUCSearchItem* getItem(int i);

+ QVariant data(int role);

+ QString getHost() const;

+ void setSorting(Qt::SortOrder sortOrder);

+

+ private:

+ void sort();

+

+ private:

+ QVector<std::shared_ptr<MUCSearchItem>> rooms_;

+ QString jidString_;

+ boost::optional<Qt::SortOrder> sortOrder_;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/MUCSearch/QtLeafSortFilterProxyModel.h>

+

+namespace Swift {

+

+QtLeafSortFilterProxyModel::QtLeafSortFilterProxyModel(QObject* parent) : QSortFilterProxyModel(parent) {

+

+}

+

+QtLeafSortFilterProxyModel::~QtLeafSortFilterProxyModel() {

+

+}

+

+bool QtLeafSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const {

+ if (!sourceModel()->hasChildren(sourceModel()->index(source_row, 0, source_parent))) {

+ return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);

+ }

+ else {

+ return true;

+ }

+}

+

+}

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <QSortFilterProxyModel>

+

+namespace Swift {

+

+/**

+ * @brief The QtLeafSortFilterProxyModel class is similar to the QSortFilterProxyModel

+ * class. While the basic QSortFilterProxyModel class filters all hierarchical items,

+ * the QtLeafSortFilterProxyModel class will only filter on items without children.

+ */

+class QtLeafSortFilterProxyModel : public QSortFilterProxyModel {

+ Q_OBJECT

+

+public:

+ QtLeafSortFilterProxyModel(QObject* parent = nullptr);

+ virtual ~QtLeafSortFilterProxyModel();

+

+protected:

+ virtual bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const;

+};

+

+}

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swift/QtUI/MUCSearch/QtMUCSearchWindow.h>

+

+#include <memory>

+#include <vector>

+#include <QPushButton>

+#include <QSortFilterProxyModel>

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

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

+

+#include <Swift/QtUI/MUCSearch/MUCSearchDelegate.h>

+#include <Swift/QtUI/MUCSearch/MUCSearchEmptyItem.h>

+#include <Swift/QtUI/MUCSearch/MUCSearchModel.h>

+#include <Swift/QtUI/MUCSearch/QtLeafSortFilterProxyModel.h>

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

+ ui_.setupUi(this);

+ setWindowIcon(QIcon(":/logo-icon-16.png"));

+ setModal(true);

+ model_ = new MUCSearchModel();

+ sortFilterProxyModel_ = new QtLeafSortFilterProxyModel(this);

+ sortFilterProxyModel_->setSourceModel(model_);

+ sortFilterProxyModel_->setDynamicSortFilter(true);

+ delegate_ = new MUCSearchDelegate();

+ ui_.results_->setModel(sortFilterProxyModel_);

+ ui_.results_->setItemDelegate(delegate_);

+ ui_.results_->setHeaderHidden(true);

+ ui_.results_->setRootIsDecorated(true);

+ ui_.results_->setAnimated(true);

+ ui_.results_->setAlternatingRowColors(true);

+ ui_.results_->setSortingEnabled(true);

+ ui_.results_->sortByColumn(0, Qt::AscendingOrder);

+ connect(ui_.searchButton_, SIGNAL(clicked()), this, SLOT(handleSearch()));

+ connect(ui_.service_, SIGNAL(activated(const QString&)), this, SLOT(handleSearch(const QString&)));

+ connect(ui_.results_->selectionModel(), SIGNAL(selectionChanged (const QItemSelection&, const QItemSelection&)), this, SLOT(handleSelectionChanged (const QItemSelection&, const QItemSelection&)));

+ connect(ui_.results_, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleActivated(const QModelIndex&)));

+ connect(ui_.results_, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleActivated(const QModelIndex&)));

+ // Not using a button box, because i can't seem to be able to make the ok button non-default (on mac)

+ connect(ui_.okButton, SIGNAL(clicked()), this, SLOT(accept()));

+ ui_.okButton->setEnabled(false);

+ connect(ui_.cancelButton, SIGNAL(clicked()), this, SLOT(reject()));

+ connect(ui_.filter_, SIGNAL(textChanged(const QString&)), this, SLOT(handleFilterStringChanged(const QString&)));

+

+ throbber_ = new QLabel(tr("Searching"), ui_.results_);

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

+ throbber_->setToolTip(tr("Searching"));

+

+ hasHadScrollBars_ = false;

+ updateThrobberPosition();

+ setSearchInProgress(false);

+ updateThrobberPosition();

+ bool isShown = throbber_->isVisible();

+ int resultWidth = ui_.results_->width();

+ int resultHeight = ui_.results_->height();

+ //throbberWidth = throbber_->movie()->scaledSize().width();

+ //throbberHeight = throbber_->movie()->scaledSize().height();

+ int throbberWidth = 16; /* This is nasty, but the above doesn't work! */

+ int throbberHeight = 16;

+ /* It's difficult (or I spent a while trying) to work out whether the scrollbars are currently shown and their appropriate size,

+ * because if you listen for the expanded/collapsed signals, you seem to get them before the scrollbars are updated.

+ * This seems an acceptable workaround.

+ */

+ hasHadScrollBars_ |= ui_.results_->verticalScrollBar()->isVisible();

+ int hMargin = hasHadScrollBars_ ? ui_.results_->verticalScrollBar()->width() + 2 : 2;

+ int vMargin = 2; /* We don't get horizontal scrollbars */

+ throbber_->setGeometry(QRect(resultWidth - throbberWidth - hMargin, resultHeight - throbberHeight - vMargin, throbberWidth, throbberHeight)); /* include margins */

+ throbber_->setVisible(isShown);

+ ui_.service_->clear();

+ for (const auto& jid : services) {

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

+ }

+ if (!services.empty()) {

+ ui_.service_->setEditText(P2QSTRING(services.begin()->toString()));

+ }

+ else {

+ ui_.service_->clearEditText();

+ }

+ if (!index.isValid()) {

+ return;

+ }

+ if (dynamic_cast<MUCSearchRoomItem*>(static_cast<MUCSearchItem*>(sortFilterProxyModel_->mapToSource(index).internalPointer()))) {

+ accept();

+ }

+ handleSearch(ui_.service_->currentText());

+ if (!service.isEmpty()) {

+ onSearchService(JID(Q2PSTRING(service)));

+ }

+}

+

+void QtMUCSearchWindow::handleFilterStringChanged(const QString& filterString) {

+ sortFilterProxyModel_->setFilterRegExp(filterString);

+ ui_.filter_->clear();

+ QWidget::show();

+ QWidget::activateWindow();

+ model_->clear();

+ updateThrobberPosition();

+ auto serviceItem = std::make_shared<MUCSearchServiceItem>(P2QSTRING(service.getJID().toString()));

+ if (service.getRooms().size() > 0) {

+ std::vector<std::shared_ptr<MUCSearchItem>> rooms;

+ for (auto&& room : service.getRooms()) {

+ if (!room.getNode().empty()) {

+ rooms.push_back(std::make_shared<MUCSearchRoomItem>(P2QSTRING(room.getNode())));

+ }

+ }

+ serviceItem->addRooms(rooms);

+ }

+ else {

+ serviceItem->addRoom(std::make_shared<MUCSearchEmptyItem>());

+ }

+ model_->addService(serviceItem);

+ ui_.results_->expandAll();

+ if (searching) {

+ throbber_->movie()->start();

+ } else {

+ throbber_->movie()->stop();

+ }

+ throbber_->setVisible(searching);

+ MUCSearchRoomItem* room = getSelectedRoom();

+ if (room) {

+ onFinished(JID(Q2PSTRING(room->getNode()), Q2PSTRING(room->getParent()->getHost())));

+ }

+ else {

+ onFinished(boost::optional<JID>());

+ }

+ QDialog::accept();

+ onFinished(boost::optional<JID>());

+ QDialog::reject();

+ ui_.okButton->setEnabled(getSelectedRoom());

+ // Not using selectedIndexes(), because this seems to cause a crash in Qt (4.7.0) in the

+ // QModelIndexList destructor.

+ // This is a workaround posted in http://www.qtcentre.org/threads/16933 (although this case

+ // was resolved by linking against the debug libs, ours isn't, and we're not alone)

+ QItemSelection ranges = ui_.results_->selectionModel()->selection();

+ QModelIndexList lstIndex;

+ for (int i = 0; i < ranges.count(); ++i) {

+ QModelIndex parent = ranges.at(i).parent();

+ int right = ranges.at(i).model()->columnCount(parent) - 1;

+ if (ranges.at(i).left() == 0 && ranges.at(i).right() == right) {

+ for (int r = ranges.at(i).top(); r <= ranges.at(i).bottom(); ++r) {

+ lstIndex.append(ranges.at(i).model()->index(r, 0, parent));

+ }

+ }

+ }

+ if (lstIndex.isEmpty()) {

+ return nullptr;

+ }

+ else {

+ return dynamic_cast<MUCSearchRoomItem*>(static_cast<MUCSearchItem*>(sortFilterProxyModel_->mapToSource(lstIndex.first()).internalPointer()));

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

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

+#include <Swift/QtUI/MUCSearch/ui_QtMUCSearchWindow.h>

+

+class QSortFilterProxyModel;

+ class MUCSearchModel;

+ class MUCSearchDelegate;

+ class MUCSearchRoomItem;

+

+ class QtMUCSearchWindow : public QDialog, public MUCSearchWindow {

+ Q_OBJECT

+ public:

+ QtMUCSearchWindow();

+ virtual ~QtMUCSearchWindow();

+

+ virtual void clearList();

+ virtual void addService(const MUCService& service);

+ virtual void addSavedServices(const std::list<JID>& services);

+ virtual void setSearchInProgress(bool searching);

+

+ virtual void show();

+ virtual void accept();

+ virtual void reject();

+

+ protected:

+ virtual void resizeEvent(QResizeEvent* event);

+

+ private slots:

+ void handleSearch();

+ void handleSearch(const QString&);

+ void handleFilterStringChanged(const QString&);

+ void handleActivated(const QModelIndex& index);

+ void updateThrobberPosition();

+ void handleSelectionChanged (const QItemSelection&, const QItemSelection&);

+ MUCSearchRoomItem* getSelectedRoom() const;

+

+ private:

+ Ui::QtMUCSearchWindow ui_;

+ MUCSearchModel* model_;

+ MUCSearchDelegate* delegate_;

+ QLabel* throbber_;

+ bool hasHadScrollBars_;

+ QSortFilterProxyModel* sortFilterProxyModel_ = nullptr;

+ };

+ <width>566</width>

+ <height>264</height>

+ <item row="0" column="0">

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

+ <string>Service:</string>

+ <item row="2" column="0" colspan="5">

+ <item row="0" column="4">

+ <widget class="QLineEdit" name="filter_">

+ <property name="sizePolicy">

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

+ <horstretch>1</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="text">

+ <string/>

+ </property>

+ <property name="frame">

+ <bool>true</bool>

+ </property>

+ <property name="placeholderText">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ <widget class="QToolButton" name="searchButton_">

+ <item row="1" column="0" colspan="5">

+ <widget class="QTreeView" name="results_"/>

+ </item>

+ <item row="0" column="3">

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

+ <property name="text">

+ <string>Search for</string>

+ </property>

+ </widget>

+ </item>