ProjectItemModel.cpp

Go to the documentation of this file.

#include "IsisDebug.h"

#include "ProjectItemModel.h"

#include <QItemSelection>
#include <QList>
#include <QMimeData>
#include <QModelIndex>
#include <QObject>
#include <QStandardItemModel>
#include <QString>

#include "BundleSolutionInfo.h"
#include "Control.h"
#include "ControlList.h"
#include "GuiCameraList.h"
#include "ImageList.h"
#include "Project.h"
#include "ProjectItem.h"
#include "ShapeList.h"
#include "TargetBodyList.h"

namespace Isis {
  ProjectItemModel::ProjectItemModel(QObject *parent) : QStandardItemModel(parent) {
    m_selectionModel = new QItemSelectionModel(this, this);
    connect(m_selectionModel, SIGNAL(selectionChanged(const QItemSelection &,
                                                      const QItemSelection &) ),
            this, SLOT(onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
                                    
    connect( this, SIGNAL(rowsInserted(const QModelIndex &, int, int)), 
             this, SLOT(onRowsInserted(const QModelIndex &, int, int)) );

    connect( this, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)), 
             this, SLOT(onRowsRemoved(const QModelIndex &, int, int)) );

  }


  ProjectItemModel::~ProjectItemModel() {

  }

  
  bool ProjectItemModel::canDropMimeData(const QMimeData *data,
                                         Qt::DropAction action,
                                         int row, int column,
                                         const QModelIndex &parent) const {
    return false;
  }

  
  QItemSelectionModel *ProjectItemModel::selectionModel() {
    return m_selectionModel;
  }


  ProjectItem *ProjectItemModel::addProject(Project *project) {

    connect(project, SIGNAL( nameChanged(QString) ),
            this, SLOT( onNameChanged(QString) ) );
    connect(project, SIGNAL( bundleSolutionInfoAdded(BundleSolutionInfo *) ),
            this, SLOT( onBundleSolutionInfoAdded(BundleSolutionInfo *) ) );
    connect(project, SIGNAL( controlAdded(Control *) ),
            this, SLOT( onControlAdded(Control *) ) );
    connect(project, SIGNAL( controlListAdded(ControlList *) ),
            this, SLOT( onControlListAdded(ControlList *) ) );
    connect(project, SIGNAL( imagesAdded(ImageList *) ),
            this, SLOT( onImagesAdded(ImageList *) ) );
    connect(project, SIGNAL( shapesAdded(ShapeList *) ),
            this, SLOT( onShapesAdded(ShapeList *) ) );
    connect(project, SIGNAL( targetsAdded(TargetBodyList *) ),
            this, SLOT( onTargetsAdded(TargetBodyList *) ) );
    connect(project, SIGNAL( guiCamerasAdded(GuiCameraList *) ),
            this, SLOT( onGuiCamerasAdded(GuiCameraList *) ) );
    ProjectItem *projectItem = new ProjectItem(project);
    appendRow(projectItem);
//  qDebug()<<"ProjectItem::addProject after appendRow projectItem rowCount = "<<rowCount();
    return projectItem;
  }


  ProjectItem *ProjectItemModel::currentItem() {
    return itemFromIndex( selectionModel()->currentIndex() );
  }


  QList<ProjectItem *> ProjectItemModel::selectedItems() {
    QItemSelection selection = selectionModel()->selection();
    QList<ProjectItem *> items;
    
    foreach ( QModelIndex index, selection.indexes() ) {
      items.append( itemFromIndex(index) );
    }

    return items;
  }


  ProjectItem *ProjectItemModel::findItemData(const QVariant &data, int role) {

//  qDebug()<<"ProjectItemModel::findItemData  incoming data = "<<data;
    for (int i=0; i<rowCount(); i++) {
//    qDebug()<<"ProjectItemModel::findItemData  BEFORE call: item(i)->findItemData...";
      ProjectItem *projectItem = item(i)->findItemData(data, role);
//    qDebug()<<"ProjectItemModel::findItemData  AFTER call: item(i)->findItemData...";
      if (projectItem) {
        return projectItem;
      }
    }

    return 0;
  }


  void ProjectItemModel::removeItem(ProjectItem *item) {
    if (!item) {
      return;
    }
//  qDebug()<<"ProjectItemModel::removeItem item= "<<item;
    if ( ProjectItem *parentItem = item->parent() ) {
//    qDebug()<<"ProjectItemModel::removeItem  ParentItem ";
      removeRow( item->row(), parentItem->index() );
    }
    else {
//    qDebug()<<"ProjectItemModel::removeItem item row =  "<<item->row();
      removeRow( item->row() );
    }
  }


  void ProjectItemModel::removeItems(QList<ProjectItem *> items) {
    foreach (ProjectItem *item, items) {
      removeItem(item);
    }
  }
  

  void ProjectItemModel::appendRow(ProjectItem *item) {
    QStandardItemModel::appendRow(item);
  }


  QModelIndex ProjectItemModel::indexFromItem(const ProjectItem *item) {
    return QStandardItemModel::indexFromItem(item);
  }

  
  void ProjectItemModel::insertRow(int row, ProjectItem *item) {
    QStandardItemModel::insertRow(row, item);
  }


  ProjectItem *ProjectItemModel::item(int row) {
    return static_cast<ProjectItem *>( QStandardItemModel::item(row) );
  }


  ProjectItem *ProjectItemModel::itemFromIndex(const QModelIndex &index) {
    return static_cast<ProjectItem *>( QStandardItemModel::itemFromIndex(index) );
  }

  
  void ProjectItemModel::setItem(int row, ProjectItem *item) {
    QStandardItemModel::setItem(row, item);
  }
  
  
  ProjectItem *ProjectItemModel::takeItem(int row) {
    QList<QStandardItem *> items = QStandardItemModel::takeRow(row);
    
    if ( items.isEmpty() ) {
      return 0;
    }

    return static_cast<ProjectItem *>( items.first() );
  }


  void ProjectItemModel::onNameChanged(QString newName) {
    Project *project = qobject_cast<Project *>( sender() );

    if (!project) {
      return;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        projectItem->setText(newName);
      }
    }
  }

  
  void ProjectItemModel::onBundleSolutionInfoAdded(BundleSolutionInfo *bundleSolutionInfo) {
    Project *project = qobject_cast<Project *>( sender() );

    if (!project) {
      return;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *resultsItem = projectItem->child(j);
          if (resultsItem->text() == "Results") {
            resultsItem->appendRow( new ProjectItem(bundleSolutionInfo) );
          }
        }
      }
    }
  }


  void ProjectItemModel::onControlAdded(Control * control) {
    Project *project = qobject_cast<Project *>( sender() );

    if (!project) {
      return;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *controlsItem = projectItem->child(j);
          if (controlsItem->text() == "Control Networks") {
            for (int k=0; k < controlsItem->rowCount(); k++) {
              ProjectItem *controlListItem = controlsItem->child(k);
              ControlList *controlList = controlListItem->controlList();
              if ( controlList && controlList->contains(control) ) {
                controlListItem->appendRow( new ProjectItem(control) );
              }
            }
          }
        }
      }
    }
//  qDebug()<<"ProjectItemModel::onControlAdded rowCount = "<<rowCount();
  }


  void ProjectItemModel::onControlListAdded(ControlList * controlList) {
    Project *project = qobject_cast<Project *>( sender() );

    if (!project) {
      return;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *controlsItem = projectItem->child(j);
          if (controlsItem->text() == "Control Networks") {
            controlsItem->appendRow( new ProjectItem(controlList) );
          }
        }
      }
    }
  }


  void ProjectItemModel::onImagesAdded(ImageList * imageList) {
//  qDebug()<<"ProjectItemModel::onImagesAdded  before add rowCount = "<<rowCount();
    Project *project = qobject_cast<Project *>( sender() );
    
    if (!project) {
      return;
    }
    
    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *imagesItem = projectItem->child(j);
          if (imagesItem->text() == "Images") {
            imagesItem->appendRow( new ProjectItem(imageList) );
          }
        }
      }
    }
//  qDebug()<<"ProjectItemModel::onImagesAdded  after add rowCount = "<<rowCount();
  }


  void ProjectItemModel::onShapesAdded(ShapeList * shapes) {
    Project *project = qobject_cast<Project *>( sender() );
    
    if (!project) {
      return;
    }
    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *shapesItem = projectItem->child(j);
          if (shapesItem->text() == "Shapes") {
            shapesItem->appendRow( new ProjectItem(shapes) );
          }
        }
      }
    }
  }


  void ProjectItemModel::onTargetsAdded(TargetBodyList *targets) {
    Project *project = qobject_cast<Project *>( sender() );

    if (!project) {
      return;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *targetsItem = projectItem->child(j);
          if (targetsItem->text() == "Target Body") {
            foreach(TargetBodyQsp target, *targets) {
              bool append = true;
              for (int k=0; k < targetsItem->rowCount(); k++) {
                ProjectItem *targetItem = targetsItem->child(k);
                if (targetItem->targetBody() == target) {
                  append = false;
                }
              }
              if (append) {
                targetsItem->appendRow( new ProjectItem(target) );
              }
            }
          }
        }
      }
    }
  }
  
  
  void ProjectItemModel::onGuiCamerasAdded(GuiCameraList *cameras) {
    Project *project = qobject_cast<Project *>( sender() );

    if (!project) {
      return;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {
        for (int j=0; j < projectItem->rowCount(); j++) {
          ProjectItem *camerasItem = projectItem->child(j);
          if (camerasItem->text() == "Sensors") {
            foreach(GuiCameraQsp camera, *cameras) {
              bool append = true;
              for (int k=0; k < camerasItem->rowCount(); k++) {
                ProjectItem *cameraItem = camerasItem->child(k);
                if (cameraItem->guiCamera() == camera) {
                  append = false;
                }
              }
              if (append) {
                camerasItem->appendRow( new ProjectItem(camera) );
              }
            }
          }
        }
      }
    }
  }


  void ProjectItemModel::onSelectionChanged(const QItemSelection &selected,
                                            const QItemSelection &deselected) {
    QList<ProjectItem *> selectedItems;
    foreach ( QModelIndex index, selected.indexes() ) {
      selectedItems.append( itemFromIndex(index) );
    }

    foreach (ProjectItem *item, selectedItems) {
      if ( item->isImage() ) {
        item->image()->displayProperties()->setSelected(true);
      }
    }

    QList<ProjectItem *> deselectedItems;
    foreach ( QModelIndex index, deselected.indexes() ) {
      deselectedItems.append( itemFromIndex(index) );
    }

    foreach (ProjectItem *item, deselectedItems) {
      if ( item->isImage() ) {
        item->image()->displayProperties()->setSelected(false);
      }
    }
  }


  void ProjectItemModel::onRowsInserted(const QModelIndex &parent, int start, int end) {
    for (int row=start; row <= end; row++) {
      QModelIndex newIndex = index(row, 0, parent);
      ProjectItem *item = itemFromIndex(newIndex);
      emit itemAdded(item);
    }
  }


  void ProjectItemModel::onRowsRemoved(const QModelIndex &parent, int start, int end) {
    for (int row=start; row <= end; row++) {
      QModelIndex newIndex = index(row, 0, parent);
      ProjectItem *item = itemFromIndex(newIndex);
//    qDebug()<<"ProjectItemModel::onRowsRemoved this = "<<this<<"   item = "<<item;
      emit itemRemoved(item);
    }
//  qDebug()<<"ProjectItemModel::onRowsRemoved  Source model : "<<this<<"  row count = "<<rowCount();
  }
}