Add objects filter to the objects dock

src/tiled/objectsdock.cpp

@@ -37,7 +37,9 @@
 #include <QBoxLayout>
 #include <QContextMenuEvent>
 #include <QHeaderView>
+#include <QKeyEvent>
 #include <QLabel>
+#include <QLineEdit>
 #include <QMenu>
 #include <QSettings>
 #include <QToolBar>
@@ -52,8 +54,10 @@ using namespace Tiled::Internal;
 
 ObjectsDock::ObjectsDock(QWidget *parent)
     : QDockWidget(parent)
+    , mFilterEdit(new QLineEdit(this))
     , mObjectsView(new ObjectsView)
     , mMapDocument(nullptr)
+    , mFilterWasEmpty(true)
 {
     setObjectName(QLatin1String("ObjectsDock"));
 
@@ -64,10 +68,15 @@ ObjectsDock::ObjectsDock(QWidget *parent)
 
     MapDocumentActionHandler *handler = MapDocumentActionHandler::instance();
 
+    mFilterEdit->setClearButtonEnabled(true);
+    connect(mFilterEdit, &QLineEdit::textChanged, this, &ObjectsDock::filterObjects);
+    connect(mFilterEdit, &QLineEdit::returnPressed, [&] { mObjectsView->setFocus(); });
+
     QWidget *widget = new QWidget(this);
     QVBoxLayout *layout = new QVBoxLayout(widget);
     layout->setMargin(0);
     layout->setSpacing(0);
+    layout->addWidget(mFilterEdit);
     layout->addWidget(mObjectsView);
 
     mActionNewLayer = new QAction(this);
@@ -136,7 +145,12 @@ void ObjectsDock::moveObjectsDown()
 void ObjectsDock::setMapDocument(MapDocument *mapDoc)
 {
     if (mMapDocument) {
-        saveExpandedGroups();
+        mFilterStrings[mMapDocument] = mFilterEdit->text();
+
+        // Save only if no filter was applied, otherwise the state is already saved
+        if (mFilterEdit->text().isEmpty())
+            saveExpandedGroups();
+
         mMapDocument->disconnect(this);
     }
 
@@ -145,7 +159,19 @@ void ObjectsDock::setMapDocument(MapDocument *mapDoc)
     mObjectsView->setMapDocument(mapDoc);
 
     if (mMapDocument) {
-        restoreExpandedGroups();
+        QString filterString = mFilterStrings.take(mMapDocument);
+
+        // A hack to prevent saving the state if no filter was applied before switching
+        mFilterWasEmpty = false;
+
+        mFilterEdit->setText(filterString);
+
+        // Restore the expansion state if no filter is applied
+        if (filterString.isEmpty()) {
+            restoreExpandedGroups();
+            mFilterWasEmpty = true;
+        }
+
         connect(mMapDocument, SIGNAL(selectedObjectsChanged()),
                 this, SLOT(updateActions()));
     }
@@ -174,6 +200,9 @@ void ObjectsDock::retranslateUi()
     mActionMoveUp->setToolTip(tr("Move Objects Up"));
     mActionMoveDown->setToolTip(tr("Move Objects Down"));
 
+    // Avoiding adding new strings during the string freeze period
+    mFilterEdit->setPlaceholderText(QCoreApplication::translate("Tiled::Internal::TileStampsDock", "Filter"));
+
     updateActions();
 }
 
@@ -225,43 +254,82 @@ void ObjectsDock::saveExpandedGroups()
 {
     mExpandedGroups[mMapDocument].clear();
 
-    const auto proxyModel = static_cast<QAbstractProxyModel*>(mObjectsView->model());
     const auto &objectGroups = mMapDocument->map()->objectGroups();
 
-    for (ObjectGroup *og : objectGroups) {
-        const QModelIndex sourceIndex = mMapDocument->mapObjectModel()->index(og);
-        const QModelIndex index = proxyModel->mapFromSource(sourceIndex);
-        if (mObjectsView->isExpanded(index))
+    for (ObjectGroup *og : objectGroups)
+        if (mObjectsView->isGroupExpanded(og))
             mExpandedGroups[mMapDocument].append(og);
-    }
 }
 
 void ObjectsDock::restoreExpandedGroups()
 {
     const auto objectGroups = mExpandedGroups.take(mMapDocument);
-    for (ObjectGroup *og : objectGroups) {
-        const QModelIndex sourceIndex = mMapDocument->mapObjectModel()->index(og);
-        const QModelIndex index = static_cast<QAbstractProxyModel*>(mObjectsView->model())->mapFromSource(sourceIndex);
-        mObjectsView->setExpanded(index, true);
-    }
+
+    for (ObjectGroup *og : objectGroups)
+        mObjectsView->setGroupExpanded(og, true);
 }
 
 void ObjectsDock::documentAboutToClose(Document *document)
 {
-    if (MapDocument *mapDocument = qobject_cast<MapDocument*>(document))
+    if (MapDocument *mapDocument = qobject_cast<MapDocument*>(document)) {
+        mFilterStrings.remove(mapDocument);
         mExpandedGroups.remove(mapDocument);
+    }
+}
+
+void ObjectsDock::filterObjects()
+{
+    // Save the prefilter expansion state if this is the first applied filter
+    if (mFilterWasEmpty) {
+        mFilterWasEmpty = false;
+        saveExpandedGroups();
+    }
+
+    mObjectsView->objectsFilterModel()->setFilterFixedString(mFilterEdit->text());
+
+    if (mFilterEdit->text().isEmpty()) { // Restore the prefilter expansion state
+        mFilterWasEmpty = true;
+        const auto &objectGroups = mMapDocument->map()->objectGroups();
+
+        // Collapse all groups so expansion is restored to the original state
+        for (ObjectGroup *og : objectGroups)
+            mObjectsView->setGroupExpanded(og, false);
+
+        restoreExpandedGroups();
+        mObjectsView->setItemsExpandable(true);
+    } else { // Expand the filtered Groups
+        const auto &objectGroups = mMapDocument->map()->objectGroups();
+
+        for (ObjectGroup *og : objectGroups)
+            mObjectsView->setGroupExpanded(og, true);
+
+        mObjectsView->setItemsExpandable(false);
+    }
+}
+
+void ObjectsDock::keyPressEvent(QKeyEvent *event)
+{
+    if (event->key() == Qt::Key_Escape)
+        mFilterEdit->clear();
+    else
+        QDockWidget::keyPressEvent(event);
 }
 
 ///// ///// ///// ///// /////
 
 ObjectsView::ObjectsView(QWidget *parent)
     : QTreeView(parent)
     , mMapDocument(nullptr)
-    , mProxyModel(new ReversingProxyModel(this))
+    , mObjectsFilterModel(new ObjectsFilterModel(mapObjectModel() ,this))
+    , mReversingProxyModel(new ReversingProxyModel(this))
     , mSynching(false)
 {
     setUniformRowHeights(true);
-    setModel(mProxyModel);
+
+    mObjectsFilterModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
+    mReversingProxyModel->setSourceModel(mObjectsFilterModel);
+    setModel(mReversingProxyModel);
+
     setItemDelegate(new EyeVisibilityDelegate(this));
 
     setSelectionBehavior(QAbstractItemView::SelectRows);
@@ -293,7 +361,7 @@ void ObjectsView::setMapDocument(MapDocument *mapDoc)
     mMapDocument = mapDoc;
 
     if (mMapDocument) {
-        mProxyModel->setSourceModel(mMapDocument->mapObjectModel());
+        mObjectsFilterModel->setSourceModel(mMapDocument->mapObjectModel());
 
         const QSettings *settings = Preferences::instance()->settings();
         const int firstSectionSize =
@@ -306,7 +374,7 @@ void ObjectsView::setMapDocument(MapDocument *mapDoc)
         restoreVisibleSections();
         synchronizeSelectedItems();
     } else {
-        mProxyModel->setSourceModel(nullptr);
+        mObjectsFilterModel->setSourceModel(nullptr);
     }
 }
 
@@ -329,19 +397,44 @@ bool ObjectsView::event(QEvent *event)
     return QTreeView::event(event);
 }
 
-void ObjectsView::onPressed(const QModelIndex &proxyIndex)
+QModelIndex ObjectsView::mapFromViewModel(const QModelIndex &viewIndex) const
+{
+    return mObjectsFilterModel->mapToSource(mReversingProxyModel->mapToSource(viewIndex));
+}
+
+QModelIndex ObjectsView::mapToViewModel(const QModelIndex &sourceIndex) const
+{
+    return mReversingProxyModel->mapFromSource(mObjectsFilterModel->mapFromSource(sourceIndex));
+}
+
+QModelIndex ObjectsView::groupIndex(ObjectGroup *objectGroup) const
 {
-    const QModelIndex index = mProxyModel->mapToSource(proxyIndex);
+    return mapToViewModel(mMapDocument->mapObjectModel()->index(objectGroup));
+}
+
+void ObjectsView::setGroupExpanded(ObjectGroup *objectGroup, bool expand)
+{
+    setExpanded(groupIndex(objectGroup), expand);
+}
+
+bool ObjectsView::isGroupExpanded(ObjectGroup *objectGroup) const
+{
+    return isExpanded(groupIndex(objectGroup));
+}
+
+void ObjectsView::onPressed(const QModelIndex &viewIndex)
+{
+    const QModelIndex index = mapFromViewModel(viewIndex);
 
     if (MapObject *mapObject = mapObjectModel()->toMapObject(index))
         mMapDocument->setCurrentObject(mapObject);
     else if (Layer *layer = mapObjectModel()->toLayer(index))
         mMapDocument->setCurrentObject(layer);
 }
 
-void ObjectsView::onActivated(const QModelIndex &proxyIndex)
+void ObjectsView::onActivated(const QModelIndex &viewIndex)
 {
-    const QModelIndex index = mProxyModel->mapToSource(proxyIndex);
+    const QModelIndex index = mapFromViewModel(viewIndex);
 
     if (MapObject *mapObject = mapObjectModel()->toMapObject(index)) {
         mMapDocument->setCurrentObject(mapObject);
@@ -371,7 +464,7 @@ void ObjectsView::selectionChanged(const QItemSelection &selected,
 
     QList<MapObject*> selectedObjects;
     for (const QModelIndex &proxyIndex : selectedProxyRows) {
-        const QModelIndex index = mProxyModel->mapToSource(proxyIndex);
+        const QModelIndex index = mapFromViewModel(proxyIndex);
 
         if (MapObject *o = mapObjectModel()->toMapObject(index))
             selectedObjects.append(o);
@@ -399,7 +492,7 @@ void ObjectsView::selectedObjectsChanged()
     const QList<MapObject *> &selectedObjects = mMapDocument->selectedObjects();
     if (selectedObjects.count() == 1) {
         MapObject *o = selectedObjects.first();
-        scrollTo(mProxyModel->mapFromSource(mapObjectModel()->index(o)));
+        scrollTo(mapToViewModel(mapObjectModel()->index(o)));
     }
 }
 
@@ -414,7 +507,7 @@ void ObjectsView::setColumnVisibility(bool visible)
 
     QSettings *settings = Preferences::instance()->settings();
     QVariantList visibleSections;
-    for (int i = 0; i < mProxyModel->columnCount(); i++) {
+    for (int i = 0; i < mReversingProxyModel->columnCount(); i++) {
         if (!header()->isSectionHidden(i))
             visibleSections.append(i);
     }
@@ -425,7 +518,7 @@ void ObjectsView::showCustomMenu(const QPoint &point)
 {
     Q_UNUSED(point)
     QMenu contextMenu(this);
-    QAbstractItemModel *model = mProxyModel->sourceModel();
+    QAbstractItemModel *model = mReversingProxyModel->sourceModel();
     for (int i = 0; i < model->columnCount(); i++) {
         if (i == MapObjectModel::Name)
             continue;
@@ -443,8 +536,8 @@ void ObjectsView::restoreVisibleSections()
 {
     QSettings *settings = Preferences::instance()->settings();
     QVariantList visibleSections = settings->value(QLatin1String(VISIBLE_SECTIONS_KEY),
-                                                 QVariantList() << MapObjectModel::Name << MapObjectModel::Type).toList();
-    for (int i = 0; i < mProxyModel->columnCount(); i++) {
+                                                   QVariantList() << MapObjectModel::Name << MapObjectModel::Type).toList();
+    for (int i = 0; i < mReversingProxyModel->columnCount(); i++) {
         header()->setSectionHidden(i, !visibleSections.contains(i));
     }
 }
@@ -457,7 +550,7 @@ void ObjectsView::synchronizeSelectedItems()
     QItemSelection itemSelection;
 
     for (MapObject *o : mMapDocument->selectedObjects()) {
-        QModelIndex index = mProxyModel->mapFromSource(mapObjectModel()->index(o));
+        QModelIndex index = mapToViewModel(mapObjectModel()->index(o));
         itemSelection.select(index, index);
     }
 
@@ -468,3 +561,39 @@ void ObjectsView::synchronizeSelectedItems()
                              QItemSelectionModel::Clear);
     mSynching = false;
 }
+
+ObjectsFilterModel::ObjectsFilterModel(MapObjectModel *mapObjectModel, QObject *parent)
+    : QSortFilterProxyModel(parent)
+    , mMapObjectModel(mapObjectModel)
+{
+}
+
+bool ObjectsFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    // Show all if filter string is empty. Prevents hiding empty groups
+    if (filterRegExp().isEmpty())
+        return true;
+
+    QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+
+    if (ObjectGroup *objectGroup = mMapObjectModel->toObjectGroup(index))
+        return groupHasAnyMatchingObjects(objectGroup);
+    else if (MapObject *mapObject = mMapObjectModel->toMapObject(index))
+        return objectContainsFilterString(mapObject);
+    else return false;
+}
+
+bool ObjectsFilterModel::groupHasAnyMatchingObjects(const ObjectGroup *objectGroup) const
+{
+    for (auto object:objectGroup->objects())
+         if (objectContainsFilterString(object))
+            return true;
+    return false;
+}
+
+bool ObjectsFilterModel::objectContainsFilterString(const MapObject *mapObject) const
+{
+    return mapObject->name().contains(filterRegExp()) ||
+           mapObject->type().contains(filterRegExp()) ||
+           QString::number(mapObject->id()).contains(filterRegExp());
+}