ProjectItemModel.cpp

Go to the documentation of this file.

#include "IsisDebug.h"

#include "ProjectItemModel.h"
#include <QDebug>
#include <QItemSelection>
#include <QList>
#include <QMessageBox>
#include <QMimeData>
#include <QModelIndex>
#include <QObject>
#include <QRegExp>
#include <QRegExpValidator>
#include <QStandardItemModel>
#include <QString>
#include <QValidator>

#include "BundleSolutionInfo.h"
#include "Control.h"
#include "ControlList.h"
#include "FileItem.h"
#include "GuiCameraList.h"
#include "ImageList.h"
#include "Project.h"
#include "ProjectItem.h"
#include "ShapeList.h"
#include "TargetBodyList.h"
#include "TemplateList.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( templatesAdded(TemplateList *)),
            this, SLOT( onTemplatesAdded(TemplateList *)));
    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() {

    ProjectItem *item = itemFromIndex( selectionModel()->currentIndex() );

    // We do this because if the user was in a footprint or cubeDN view, then
    // There is no valid currentIndex(). In that case, we grab whichever item
    // was right clicked that triggered this call.
    if (item == NULL) {
      item = selectedItems().at(0);
    }
    return item;
  }


  QList<ProjectItem *> ProjectItemModel::selectedItems() {
    QItemSelection selection = selectionModel()->selection();
    QList<ProjectItem *> items;


    foreach ( QModelIndex index, selection.indexes() ) {
      items.append( itemFromIndex(index) );
    }

    return items;
  }
  QList<ProjectItem *> ProjectItemModel::selectedBOSSImages() {

    QItemSelection selection = selectionModel()->selection();
    QList<ProjectItem *> items;
    QModelIndexList indices = selection.indexes();

    // If nothing is selected, fill items with all image lists and images.
    if (indices.size() == 0) {
      ProjectItem *imageRoot = findItemData(QVariant("Images"), 0);
      items.append(imageRoot);
      for (int i = 0; i < imageRoot->rowCount(); i++) {
        ProjectItem *imglistItem = imageRoot->child(i);
        items.append(imglistItem);
        for (int j = 0; j < imglistItem->rowCount(); j++) {
          ProjectItem *imgItem = imglistItem->child(j);
          if (imgItem->isImage()) {
            items.append(imgItem);
          }
        }
      }
      return items;
    }

    //Query the selected items to see if they have children
    foreach ( QModelIndex ix, indices ) {

      ProjectItem *item = this->itemFromIndex(ix);

      //Anything that is not an image or an image list does
      //not make sense to display in the BOSS treeview tab,
      //so we need to exclude these items.
      if (item->isImageList() || item->isImage() ) {
        items.append( item );
      }
      else {
        return items;
      }

      //If the selected ImageList has children, we have to handle
      //the case where some of the children are selected, or
      //the possibility that the user wants all of the children selected.
      if (this->hasChildren(ix)) {

        //If the node has children, loop through all of them
        //and add them to selected items.
        bool childrenSelected(false);
        int numChildren = this->rowCount(ix);

        //First loop through the children to see if any of them are also selected
        for (int i = 0; i < numChildren;i++) {
          QModelIndex ixchild = this->index(i,0,ix);
          if (indices.contains(ixchild) ){
              childrenSelected=true;
              break;
          }
        }
          //If they are, then add them to selected items
          if (childrenSelected) {
            for (int i =0;i < numChildren;i++) {
              QModelIndex ixchild = this->index(i,0,ix);
              if (indices.contains(ixchild))
                items.append(this->itemFromIndex(ixchild ));
            }
          }
          //No children selected, so we are assuming that the user
          //wanted to select all of the children under the parent.
          else {
            for (int i =0;i < numChildren;i++) {
               QModelIndex ixchild = this->index(i,0,ix);
               items.append(this->itemFromIndex(ixchild ));
            }

          }

      }//end if

      //Append the parent of any selected child.  This is so
      //the children aren't hanging on the tree without
      //a collapsible parent node.
      if( item->parent() ->hasChildren()) {
        ProjectItem * parent = item->parent();
        if (!items.contains(parent)){
          items.append(parent);
        }// end inner if
      }//end outer if
      //Also include the grandparent.  This handles the event
      //that we may have multiple image lists selected to the treeview
      //and we need a grandparent node attached to group them under.
      if (this->itemFromIndex(ix)->parent()->parent() ){
        ProjectItem *grandparent = this->itemFromIndex(ix)->parent()->parent();
        if (!items.contains(grandparent)) {
          items.append(grandparent);
        } //end inner if

      } //end outer if

  }// end foreach

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

    // remove any children the item has first
    if (item->hasChildren()) {
      for (int row = (item->rowCount() - 1); row >= 0; row--) {
        removeRow(item->child(row)->row(), item->index());
      }
    }

    if (ProjectItem *parentItem = item->parent()) {
      // remove the item from its parent
      removeRow(item->row(), parentItem->index());
    }
    else {
      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);
      }
    }
    project->setClean(false);
  }


  void ProjectItemModel::onBundleSolutionInfoAdded(BundleSolutionInfo *bundleSolutionInfo) {
    Project *project = qobject_cast<Project *>( sender() );
    m_reservedNames.append(bundleSolutionInfo->name() );

    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") {
            ProjectItem *pItem = new ProjectItem(bundleSolutionInfo);
            resultsItem->appendRow( pItem );

            // Append text bundle summary and CSV files to the Statistics in the project
            ProjectItem *bundleSummaryItem = new ProjectItem(FileItemQsp(
               new FileItem(bundleSolutionInfo->savedBundleOutputFilename())),
                            "Summary", bundleSolutionInfo->savedBundleOutputFilename(),
                            QIcon(FileName("$base/icons/office-chart-pie.png")
                            .expanded()));
            pItem->child(2)->appendRow(bundleSummaryItem);
            ProjectItem *residualsItem = new ProjectItem(FileItemQsp(
               new FileItem(bundleSolutionInfo->savedResidualsFilename())),
                            "Measure Residuals", bundleSolutionInfo->savedResidualsFilename(),
                            QIcon(FileName("$base/icons/office-chart-pie.png")
                            .expanded()));
            pItem->child(2)->appendRow(residualsItem);
            ProjectItem *imagesItem = new ProjectItem(FileItemQsp(
               new FileItem(bundleSolutionInfo->savedImagesFilename())),
                            "Image", bundleSolutionInfo->savedImagesFilename(),
                            QIcon(FileName("$base/icons/office-chart-pie.png")
                            .expanded()));
            pItem->child(2)->appendRow(imagesItem);
            ProjectItem *pointsItem = new ProjectItem(FileItemQsp(
               new FileItem(bundleSolutionInfo->savedPointsFilename())),
                            "Control Points", bundleSolutionInfo->savedPointsFilename(),
                            QIcon(FileName("$base/icons/office-chart-pie.png")
                            .expanded()));
            pItem->child(2)->appendRow(pointsItem);
          }
        }
      }
    }
  }


  void ProjectItemModel::onTemplatesAdded(TemplateList *templateList) {
    Project *project = qobject_cast<Project *>( sender() );
    if (!project) { return; }

    // Start at our project's node
    // Start at our project's node
    for (int i = 0; i<rowCount(); i++) {
      ProjectItem *projectItem = item(i);
      if (projectItem->project() == project) {

        // Find the "Templates" node
        for (int j = 0; j < projectItem->rowCount(); j++) {
          ProjectItem *templatesItem = projectItem->child(j);
          if (templatesItem->text() == "Templates"){

            // Find either the "Maps" or "Registrations" node
            QString type = templateList->type();
            for (int k = 0; k < templatesItem->rowCount(); k++) {
                ProjectItem *templateType = templatesItem->child(k);
                if (templateType->text().toLower() == type) {
                  templateType->appendRow( new ProjectItem(templateList));
              }
            }
          }
        }
      }
    }
  }


  void ProjectItemModel::onControlAdded(Control * control) {
    Project *project = qobject_cast<Project *>( sender() );
    m_reservedNames.append(control->id() );

    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() );
    m_reservedNames.append(controlList->name() );

    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() );
    m_reservedNames.append(imageList->name() );
    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() );
    m_reservedNames.append(shapes->name());

    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() );
    m_reservedNames.append(targets->name() );

    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() );
    m_reservedNames.append(cameras->name() );

    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();
  }


  bool ProjectItemModel::setData(const QModelIndex &index, const QVariant &value, int role) {

     ProjectItem *item = itemFromIndex(index);

     QString name = value.toString();

     bool rejected =rejectName(m_reservedNames,name);

     if (rejected) {
       QMessageBox nameRejected;
       nameRejected.setText("That name is already in use within this project.");
       nameRejected.exec();
       return true;
     }

     m_reservedNames.append(name);

     if (item->isProject() && role == Qt::EditRole) {
          emit projectNameEdited(name);
     }

    else if (item->isBundleSolutionInfo() && role == Qt::EditRole) {
      item->setText(name);
      item->bundleSolutionInfo()->setName(name);
      emit cleanProject(false);
    }
    else if (item->isImageList() && role == Qt::EditRole) {
      item->setText(name);
      item->imageList()->setName(name);
      emit cleanProject(false);
    }
    else if (item->isControlList() && role == Qt::EditRole) {
      item->setText(name);
      item->controlList()->setName(name);
      emit cleanProject(false);
    }
    else if (item->isShapeList() && role == Qt::EditRole) {
      item->setText(name);
      item->shapeList()->setName(name);
      emit cleanProject(false);
    }
    else if (item->isTemplate() && role == Qt::EditRole) {
      item->setText(name);
      emit cleanProject(false);
    }
    return true;
  }


  Qt::ItemFlags ProjectItemModel::flags(const QModelIndex &index) const {

    return Qt::ItemIsEditable | QStandardItemModel::flags(index);
  }



  bool ProjectItemModel::rejectName(QStringList &reserved, QString target) {


    QRegExpValidator valid;
    QValidator::State state;
    int pos =0;
    foreach (QString name, reserved) {

      QRegExp rx(name);
      valid.setRegExp(rx);
      state = valid.validate(target,pos);

      if (state == 2) {
        return true;
      }
    } //end for

    return false;
  }

   void ProjectItemModel::clean() {
     for (int i=0; i<rowCount(); i++) {
       ProjectItem *projectItem = item(i);
       if (projectItem->project()) {
         for (int j=0; j < projectItem->rowCount(); j++) {
           if (projectItem->hasChildren()) {
             ProjectItem *subProjectItem = projectItem->child(j);

             // The header "Templates" has two subheaders that we want to keep
             if (subProjectItem->text() == "Templates") {
               if (subProjectItem->hasChildren()) {
                 for (int k=0; k < subProjectItem->rowCount(); k++) {
                   ProjectItem *tempProjectItem = subProjectItem->child(k);
                   while (tempProjectItem->hasChildren()) {
                       removeItem(tempProjectItem->child(0));
                   }
                 }
               }
             }
             else {
               while (subProjectItem->hasChildren()) {
                   removeItem(subProjectItem->child(0));
               }
             }
           }
         }
       }
     }
   }


}