ProjectItemProxyModel.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "IsisDebug.h"
 
#include "ProjectItemProxyModel.h"
 
#include <QList>
#include <QItemSelection>
#include <QMap>
#include <QMimeData>
#include <QModelIndex>
#include <QObject>
#include <QtDebug>
 
#include "ProjectItem.h"
#include "ProjectItemModel.h"
 
namespace Isis {
  ProjectItemProxyModel::ProjectItemProxyModel(QObject *parent) : ProjectItemModel(parent) {
    m_sourceModel = 0;
    m_sourceProxyMap = QMap<ProjectItem *, ProjectItem *>();
  }
 
 
  QModelIndex ProjectItemProxyModel::mapIndexFromSource(const QModelIndex &sourceIndex) {
    ProjectItem *proxyItem = mapItemFromSource( sourceModel()->itemFromIndex(sourceIndex) );
 
    if (proxyItem) {
      return proxyItem->index();
    }
    else {
      return QModelIndex();
    }
 
  }
 
 
  QModelIndex ProjectItemProxyModel::mapIndexToSource(const QModelIndex &proxyIndex) {
    ProjectItem *sourceItem = mapItemToSource( itemFromIndex(proxyIndex) );
 
    if (sourceItem) {
      return sourceItem->index();
    }
    else {
      return QModelIndex();
    }
  }
 
 
  QItemSelection ProjectItemProxyModel::mapSelectionFromSource(
      const QItemSelection &sourceSelection) {
 
    QItemSelection proxySelection = QItemSelection();
 
    foreach ( QModelIndex sourceIndex, sourceSelection.indexes() ) {
      QModelIndex proxyIndex = mapIndexFromSource(sourceIndex);
      if ( proxyIndex.isValid() ) {
        proxySelection.select(proxyIndex, proxyIndex);
      }
    }
 
    return proxySelection;
  }
 
 
  QItemSelection ProjectItemProxyModel::mapSelectionToSource(const QItemSelection &proxySelection) {
    QItemSelection sourceSelection = QItemSelection();
 
    foreach ( QModelIndex proxyIndex, proxySelection.indexes() ) {
      QModelIndex sourceIndex = mapIndexToSource(proxyIndex);
      if ( sourceIndex.isValid() ) {
        sourceSelection.select(sourceIndex, sourceIndex);
      }
    }
 
    return sourceSelection;
  }
 
 
  ProjectItem *ProjectItemProxyModel::mapItemFromSource(ProjectItem *sourceItem) {
    return m_sourceProxyMap.value(sourceItem, 0);
  }
 
 
  ProjectItem *ProjectItemProxyModel::mapItemToSource(ProjectItem *proxyItem) {
    return m_sourceProxyMap.key(proxyItem, 0);
  }
 
 
  ProjectItem *ProjectItemProxyModel::addItem(ProjectItem *sourceItem) {
    if (!sourceItem) {
      return 0;
    }
 
    ProjectItem *proxyItem;
 
    if (ProjectItem *parentItem = mapItemFromSource( sourceItem->parent() ) ) {
      proxyItem = addChild(sourceItem, parentItem);
    }
    else {
      proxyItem = addChild(sourceItem, 0);
    }
 
    for (int i=0; i < sourceItem->rowCount(); i++) {
      addItem( sourceItem->child(i) );
    }
 
    return proxyItem;
  }
 
 
  void ProjectItemProxyModel::addItems(QList<ProjectItem *> sourceItems) {
    foreach (ProjectItem *item, sourceItems) {
      addItem(item);
    }
    emit itemsAdded();
  }
 
 
  void ProjectItemProxyModel::removeItem(ProjectItem *item) {
    if (item) {
      m_sourceProxyMap.remove( mapItemToSource(item) );
    }
//  qDebug()<<"ProjectItemProxyModel::removeItem  item= "<<item;
    ProjectItemModel::removeItem(item);
  }
 
 
  void ProjectItemProxyModel::setSourceModel(ProjectItemModel *sourceModel) {
    if (m_sourceModel == sourceModel) {
      return;
    }
 
    if (m_sourceModel) {
      clear();
      m_sourceModel->disconnect(this);
    }
 
    m_sourceModel = sourceModel;
 
    //  If current item changes on the Source Model, update this proxy model's current item
    connect(sourceModel->selectionModel(),
            SIGNAL( currentChanged(const QModelIndex &, const QModelIndex &) ),
            this, SLOT( updateProxyCurrent() ) );
    //  If current item changes on this proxy model, update the source model's current item
    connect(selectionModel(),
            SIGNAL( currentChanged(const QModelIndex &, const QModelIndex &) ),
            this, SLOT( updateSourceCurrent() ) );
    //  If selection changes on the Source Model, update this proxy model's selection
    connect(sourceModel->selectionModel(),
            SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
            this, SLOT( updateProxySelection() ) );
    //  If the selection changes on this proxy model, update the source model's selection
    connect(selectionModel(),
            SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
            this, SLOT( updateSourceSelection() ) );
 
    connect(sourceModel, SIGNAL( itemChanged(QStandardItem *) ),
            this, SLOT( onItemChanged(QStandardItem *) ) );
 
    connect(sourceModel, SIGNAL(itemRemoved(ProjectItem *)),
            this, SIGNAL(itemRemoved(ProjectItem *)));
  }
 
 
  ProjectItemModel *ProjectItemProxyModel::sourceModel() {
    return m_sourceModel;
  }
 
 
  void ProjectItemProxyModel::updateItem(ProjectItem *sourceItem) {
    if ( ProjectItem *proxyItem = mapItemFromSource(sourceItem) ) {
      proxyItem->setProjectItem(sourceItem);
    }
  }
 
 
  void ProjectItemProxyModel::updateProxyCurrent() {
    QModelIndex newProxyCurrent = mapIndexFromSource(
        sourceModel()->selectionModel()->currentIndex() );
    if ( newProxyCurrent != selectionModel()->currentIndex() ) {
      selectionModel()->setCurrentIndex(newProxyCurrent, QItemSelectionModel::Current);
    }
  }
 
 
  void ProjectItemProxyModel::updateSourceCurrent() {
    QModelIndex newSourceCurrent = mapIndexToSource( selectionModel()->currentIndex() );
    if ( newSourceCurrent != sourceModel()->selectionModel()->currentIndex() ) {
      sourceModel()->selectionModel()->setCurrentIndex(newSourceCurrent,
                                                       QItemSelectionModel::Current);
    }
  }
 
 
  void ProjectItemProxyModel::updateProxySelection() {
    QItemSelection newProxySelection = mapSelectionFromSource(
        sourceModel()->selectionModel()->selection() );
    if ( newProxySelection != selectionModel()->selection() ) {
      selectionModel()->select(newProxySelection, QItemSelectionModel::ClearAndSelect);
    }
  }
 
 
  void ProjectItemProxyModel::updateSourceSelection() {
    QItemSelection newSourceSelection = mapSelectionToSource( selectionModel()->selection() );
    if ( mapSelectionFromSource(newSourceSelection) !=
         mapSelectionFromSource( sourceModel()->selectionModel()->selection() ) ) {
      sourceModel()->selectionModel()->select(newSourceSelection,
                                              QItemSelectionModel::ClearAndSelect);
    }
  }
 
 
  ProjectItem *ProjectItemProxyModel::addChild(ProjectItem *sourceItem, ProjectItem *parentItem) {
    if (!sourceItem) {
      return 0;
    }
 
    if ( !sourceModel() ) {
      setSourceModel( sourceItem->model() );
    }
 
    if ( sourceItem->model() != sourceModel() ) {
      return 0;
    }
 
    if ( parentItem && (parentItem->model() != this) ) {
      return 0;
    }
 
    ProjectItem *proxyItem = mapItemFromSource(sourceItem);
 
    if (!proxyItem) {
      proxyItem = new ProjectItem();
      proxyItem->setProjectItem(sourceItem);
      m_sourceProxyMap.insert(sourceItem, proxyItem);
    }
    else {
      if ( ProjectItem *oldParent = proxyItem->parent() ) {
        oldParent->takeRow( proxyItem->row() );
      }
      else if ( ProjectItemModel *model = proxyItem->model() ) {
        model->takeRow( proxyItem->row() );
      }
    }
 
    if (parentItem) {
      parentItem->appendRow(proxyItem);
    }
    else {
      appendRow(proxyItem);
    }
 
    return proxyItem;
  }
 
 
  void ProjectItemProxyModel::onItemChanged(QStandardItem *item) {
    updateItem( static_cast<ProjectItem *>(item) );
  }
 
 
  bool ProjectItemProxyModel::canDropMimeData(const QMimeData *data,
                                           Qt::DropAction action,
                                           int row, int column,
                                           const QModelIndex &parent) const {
    return true;
  }
 
 
  bool ProjectItemProxyModel::dropMimeData(const QMimeData *data,
                                           Qt::DropAction action,
                                           int row, int column,
                                           const QModelIndex &parent) {
    if ( data->hasFormat("application/x-qabstractitemmodeldatalist") ) {
      addItems( sourceModel()->selectedItems() );
      return true;
    }
    return false;
  }
}