File indexing completed on 2024-04-28 03:59:17

 /*
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>
     SPDX-FileContributor: Stephen Kelly <stephen@kdab.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kviewstateserializer.h"
 
 #include <QAbstractScrollArea>
 #include <QPointer>
 #include <QScrollBar>
 #include <QTimer>
 #include <QTreeView>
 
 class KViewStateSerializerPrivate
 {
 public:
     KViewStateSerializerPrivate(KViewStateSerializer *qq)
         : q_ptr(qq)
         , m_treeView(nullptr)
         , m_view(nullptr)
         , m_selectionModel(nullptr)
         , m_scrollArea(nullptr)
         , m_horizontalScrollBarValue(-1)
         , m_verticalScrollBarValue(-1)
     {
     }
 
     Q_DECLARE_PUBLIC(KViewStateSerializer)
     KViewStateSerializer *const q_ptr;
 
     QStringList getExpandedItems(const QModelIndex &index) const;
 
     void listenToPendingChanges();
     void processPendingChanges();
 
     inline void restoreScrollBarState()
     {
         if (!m_scrollArea || !m_scrollArea->horizontalScrollBar() || !m_scrollArea->verticalScrollBar()) {
             return;
         }
         if (m_horizontalScrollBarValue >= 0 && m_horizontalScrollBarValue <= m_scrollArea->horizontalScrollBar()->maximum()) {
             m_scrollArea->horizontalScrollBar()->setValue(m_horizontalScrollBarValue);
             m_horizontalScrollBarValue = -1;
         }
         if (m_verticalScrollBarValue >= 0 && m_verticalScrollBarValue <= m_scrollArea->verticalScrollBar()->maximum()) {
             m_scrollArea->verticalScrollBar()->setValue(m_verticalScrollBarValue);
             m_verticalScrollBarValue = -1;
         }
     }
 
     void restoreSelection();
     void restoreCurrentItem();
     void restoreExpanded();
 
     inline bool hasPendingChanges() const
     {
         return !m_pendingCurrent.isEmpty() || !m_pendingExpansions.isEmpty() || !m_pendingSelections.isEmpty();
     }
 
     const QAbstractItemModel *getModel()
     {
         if (m_selectionModel && m_selectionModel->model()) {
             return m_selectionModel->model();
         } else if (m_view && m_view->model()) {
             return m_view->model();
         }
         return nullptr;
     }
 
     void rowsInserted(const QModelIndex & /*index*/, int /*start*/, int /*end*/)
     {
         Q_Q(KViewStateSerializer);
         processPendingChanges();
 
         if (!hasPendingChanges()) {
             q->disconnect(m_rowsInsertedConnection);
             q->deleteLater();
         }
     }
 
     QTreeView *m_treeView;
     QAbstractItemView *m_view;
     QItemSelectionModel *m_selectionModel;
     QPointer<QAbstractScrollArea> m_scrollArea;
 
     int m_horizontalScrollBarValue;
     int m_verticalScrollBarValue;
     QSet<QString> m_pendingSelections;
     QSet<QString> m_pendingExpansions;
     QString m_pendingCurrent;
     QMetaObject::Connection m_rowsInsertedConnection;
 };
 
 KViewStateSerializer::KViewStateSerializer(QObject *parent)
     : QObject(nullptr)
     , d_ptr(new KViewStateSerializerPrivate(this))
 {
     Q_UNUSED(parent);
     qRegisterMetaType<QModelIndex>("QModelIndex");
 }
 
 KViewStateSerializer::~KViewStateSerializer() = default;
 
 void KViewStateSerializer::setView(QAbstractItemView *view)
 {
     Q_D(KViewStateSerializer);
     d->m_scrollArea = view;
     if (view) {
         d->m_selectionModel = view->selectionModel();
         d->m_treeView = qobject_cast<QTreeView *>(view);
     } else {
         d->m_selectionModel = nullptr;
         d->m_treeView = nullptr;
     }
     d->m_view = view;
 }
 
 QAbstractItemView *KViewStateSerializer::view() const
 {
     Q_D(const KViewStateSerializer);
     return d->m_view;
 }
 
 QItemSelectionModel *KViewStateSerializer::selectionModel() const
 {
     Q_D(const KViewStateSerializer);
     return d->m_selectionModel;
 }
 
 void KViewStateSerializer::setSelectionModel(QItemSelectionModel *selectionModel)
 {
     Q_D(KViewStateSerializer);
     d->m_selectionModel = selectionModel;
 }
 
 void KViewStateSerializerPrivate::listenToPendingChanges()
 {
     Q_Q(KViewStateSerializer);
     // watch the model for stuff coming in delayed
     if (hasPendingChanges()) {
         const QAbstractItemModel *model = getModel();
         if (model) {
             q->disconnect(m_rowsInsertedConnection);
             m_rowsInsertedConnection = q->connect(model, &QAbstractItemModel::rowsInserted, q, [this](const QModelIndex &parent, int first, int last) {
                 rowsInserted(parent, first, last);
             });
             return;
         } else {
             q->deleteLater();
         }
     } else {
         q->deleteLater();
     }
 }
 
 void KViewStateSerializerPrivate::processPendingChanges()
 {
     Q_Q(KViewStateSerializer);
 
     q->restoreCurrentItem(m_pendingCurrent);
     q->restoreSelection(m_pendingSelections.values());
     q->restoreExpanded(m_pendingExpansions.values());
     q->restoreScrollState(m_verticalScrollBarValue, m_horizontalScrollBarValue);
 }
 
 QStringList KViewStateSerializerPrivate::getExpandedItems(const QModelIndex &index) const
 {
     Q_Q(const KViewStateSerializer);
 
     QStringList expansion;
     for (int i = 0; i < m_treeView->model()->rowCount(index); ++i) {
         const QModelIndex child = m_treeView->model()->index(i, 0, index);
 
         // http://bugreports.qt.nokia.com/browse/QTBUG-18039
         if (m_treeView->model()->hasChildren(child)) {
             if (m_treeView->isExpanded(child)) {
                 expansion << q->indexToConfigString(child);
             }
             expansion << getExpandedItems(child);
         }
     }
     return expansion;
 }
 
 void KViewStateSerializerPrivate::restoreCurrentItem()
 {
     Q_Q(KViewStateSerializer);
 
     QModelIndex currentIndex = q->indexFromConfigString(m_selectionModel->model(), m_pendingCurrent);
     if (currentIndex.isValid()) {
         if (m_treeView) {
             m_treeView->setCurrentIndex(currentIndex);
         } else {
             m_selectionModel->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
         }
         m_pendingCurrent.clear();
     }
 }
 
 void KViewStateSerializer::restoreCurrentItem(const QString &indexString)
 {
     Q_D(KViewStateSerializer);
     if (!d->m_selectionModel || !d->m_selectionModel->model()) {
         return;
     }
 
     if (indexString.isEmpty()) {
         return;
     }
     d->m_pendingCurrent = indexString;
     d->restoreCurrentItem();
 
     if (d->hasPendingChanges()) {
         d->listenToPendingChanges();
     }
 }
 
 void KViewStateSerializerPrivate::restoreExpanded()
 {
     Q_Q(KViewStateSerializer);
 
     QSet<QString>::iterator it = m_pendingExpansions.begin();
     for (; it != m_pendingExpansions.end();) {
         QModelIndex idx = q->indexFromConfigString(m_treeView->model(), *it);
         if (idx.isValid()) {
             m_treeView->expand(idx);
             it = m_pendingExpansions.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 void KViewStateSerializer::restoreExpanded(const QStringList &indexStrings)
 {
     Q_D(KViewStateSerializer);
     if (!d->m_treeView || !d->m_treeView->model()) {
         return;
     }
 
     if (indexStrings.isEmpty()) {
         return;
     }
 
     d->m_pendingExpansions.unite(QSet<QString>(indexStrings.begin(), indexStrings.end()));
 
     d->restoreExpanded();
     if (d->hasPendingChanges()) {
         d->listenToPendingChanges();
     }
 }
 
 void KViewStateSerializer::restoreScrollState(int verticalScoll, int horizontalScroll)
 {
     Q_D(KViewStateSerializer);
 
     if (!d->m_scrollArea) {
         return;
     }
 
     d->m_verticalScrollBarValue = verticalScoll;
     d->m_horizontalScrollBarValue = horizontalScroll;
 
     QTimer::singleShot(0, this, [d]() {
         d->restoreScrollBarState();
     });
 }
 
 void KViewStateSerializerPrivate::restoreSelection()
 {
     Q_Q(KViewStateSerializer);
 
     QSet<QString>::iterator it = m_pendingSelections.begin();
     for (; it != m_pendingSelections.end();) {
         QModelIndex idx = q->indexFromConfigString(m_selectionModel->model(), *it);
         if (idx.isValid()) {
             m_selectionModel->select(idx, QItemSelectionModel::Select);
             it = m_pendingSelections.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 void KViewStateSerializer::restoreSelection(const QStringList &indexStrings)
 {
     Q_D(KViewStateSerializer);
 
     if (!d->m_selectionModel || !d->m_selectionModel->model()) {
         return;
     }
 
     if (indexStrings.isEmpty()) {
         return;
     }
 
     d->m_pendingSelections.unite(QSet<QString>(indexStrings.begin(), indexStrings.end()));
 
     d->restoreSelection();
     if (d->hasPendingChanges()) {
         d->listenToPendingChanges();
     }
 }
 
 QString KViewStateSerializer::currentIndexKey() const
 {
     Q_D(const KViewStateSerializer);
     if (!d->m_selectionModel) {
         return QString();
     }
     return indexToConfigString(d->m_selectionModel->currentIndex());
 }
 
 QStringList KViewStateSerializer::expansionKeys() const
 {
     Q_D(const KViewStateSerializer);
     if (!d->m_treeView || !d->m_treeView->model()) {
         return QStringList();
     }
 
     return d->getExpandedItems(QModelIndex());
 }
 
 QStringList KViewStateSerializer::selectionKeys() const
 {
     Q_D(const KViewStateSerializer);
     if (!d->m_selectionModel) {
         return QStringList();
     }
 
     const QModelIndexList selectedIndexes = d->m_selectionModel->selectedRows();
     QStringList selection;
     selection.reserve(selectedIndexes.count());
     for (const QModelIndex &index : selectedIndexes) {
         selection << indexToConfigString(index);
     }
 
     return selection;
 }
 
 QPair<int, int> KViewStateSerializer::scrollState() const
 {
     Q_D(const KViewStateSerializer);
     return qMakePair(d->m_scrollArea->verticalScrollBar()->value(), d->m_scrollArea->horizontalScrollBar()->value());
 }
 
 void KViewStateSerializer::restoreState()
 {
     Q_D(KViewStateSerializer);
     // Delete myself if not finished after 60 seconds
     QTimer::singleShot(60000, this, &KViewStateSerializer::deleteLater);
 
     d->processPendingChanges();
     if (d->hasPendingChanges()) {
         d->listenToPendingChanges();
     }
 }
 
 #include "moc_kviewstateserializer.cpp"