ProjectItem.cpp

Go to the documentation of this file.

#include "ProjectItem.h"

#include <QIcon>
#include <QStandardItem>
#include <QVariant>

#include "BundleResults.h"
#include "BundleSettings.h"
#include "BundleSolutionInfo.h"
#include "Control.h"
#include "ControlList.h"
#include "CorrelationMatrix.h"
#include "Image.h"
#include "ImageList.h"
#include "Project.h"
#include "ProjectItemModel.h"
#include "Shape.h"
#include "ShapeList.h"

namespace Isis {
  ProjectItem::ProjectItem() : QStandardItem() {}

  
  ProjectItem::ProjectItem(ProjectItem *item) {
    setProjectItem(item);
    for (int i=0; i < item->rowCount(); i++) {
      appendRow(new ProjectItem( item->child(i) ) );
    }
  }


  ProjectItem::ProjectItem(BundleResults bundleResults) {
    setBundleResults(bundleResults);
    appendRow( new ProjectItem( bundleResults.correlationMatrix() ) );
  }


  ProjectItem::ProjectItem(BundleSettingsQsp bundleSettings) {
    setBundleSettings(bundleSettings);
  }


  ProjectItem::ProjectItem(BundleSolutionInfo *bundleSolutionInfo) {
    setBundleSolutionInfo(bundleSolutionInfo);
    
    QString cNetFileName = bundleSolutionInfo->controlNetworkFileName();
    Control *control = new Control(cNetFileName);
    appendRow( new ProjectItem(control) );

    appendRow( new ProjectItem( bundleSolutionInfo->bundleSettings() ) );
    appendRow( new ProjectItem( bundleSolutionInfo->bundleResults() ) );
  }


  ProjectItem::ProjectItem(Control *control) {
    setControl(control);
  }


  ProjectItem::ProjectItem(ControlList *controlList) {
    setControlList(controlList);
    foreach (Control *control, *controlList) {
      appendRow( new ProjectItem(control) );
    }
  }


  ProjectItem::ProjectItem(QList<ControlList *> controls) {
    setControls();
    foreach (ControlList *controlList, controls) {
      appendRow( new ProjectItem(controlList) );
    }
  }


  ProjectItem::ProjectItem(CorrelationMatrix correlationMatrix) {
    setCorrelationMatrix(correlationMatrix);
  }


  ProjectItem::ProjectItem(Image *image) {
    setImage(image);
  }


  ProjectItem::ProjectItem(ImageList *imageList) {
    setImageList(imageList);
    foreach (Image *image, *imageList) {
      appendRow( new ProjectItem(image) );
    }
  }


  ProjectItem::ProjectItem(QList<ImageList *> images) {
    setImages();
    foreach (ImageList *imageList, images) {
      appendRow( new ProjectItem(imageList) );
    }
  }

  
  ProjectItem::ProjectItem(Shape *shape) {
    setShape(shape);
  }


  ProjectItem::ProjectItem(ShapeList *shapeList) {
    setShapeList(shapeList);
    foreach (Shape *shape, *shapeList) {
      appendRow(new ProjectItem(shape));
    }
  }


  ProjectItem::ProjectItem(QList<ShapeList *> shapes) {
    setShapes();
    foreach (ShapeList *shapeList, shapes) {
      appendRow( new ProjectItem(shapeList) );
    }
  }


  ProjectItem::ProjectItem(GuiCameraQsp guiCamera) {
    setGuiCamera(guiCamera);
  }

  
  ProjectItem::ProjectItem(GuiCameraList *guiCameraList) {
    setGuiCameraList();
    foreach (GuiCameraQsp guiCamera, *guiCameraList) {
      appendRow( new ProjectItem(guiCamera) );
    }
  }


  ProjectItem::ProjectItem(Project *project) {
    setProject(project);
//  qDebug()<<"ProjectItem::ProjectItem(Project *project)  rowCount() = "<<rowCount();
    appendRow( new ProjectItem( project->controls() ) );
//  qDebug()<<"                                            rowCount() afterControls = "<<rowCount();
    appendRow( new ProjectItem( project->images() ) );
//  qDebug()<<"                                            rowCount() afterImages = "<<rowCount();
    appendRow( new ProjectItem( project->shapes() ) );
        
    ProjectItem *targetBodyListItem = new ProjectItem();
    targetBodyListItem->setTargetBodyList();
    appendRow(targetBodyListItem);
    
    ProjectItem *guiCameraListItem = new ProjectItem();
    guiCameraListItem->setGuiCameraList();
    appendRow(guiCameraListItem);
    
    ProjectItem *spaceCraftItem = new ProjectItem();
    spaceCraftItem->setSpacecraft();
    appendRow(spaceCraftItem);
    
    appendRow( new ProjectItem( project->bundleSolutionInfo() ) );
  }


  ProjectItem::ProjectItem(QList<BundleSolutionInfo *> results) {
    setResults();
    foreach (BundleSolutionInfo *bundleSolutionInfo, results) {
      appendRow( new ProjectItem( bundleSolutionInfo) );
    }
  }


  ProjectItem::ProjectItem(TargetBodyQsp targetBody) {
    setTargetBody(targetBody);
  }


  ProjectItem::ProjectItem(TargetBodyList *targetBodyList) {
    setTargetBodyList();
    foreach (TargetBodyQsp targetBody, *targetBodyList) {
      appendRow( new ProjectItem(targetBody) );
    }
  }


  ProjectItem::~ProjectItem() {}


  BundleResults ProjectItem::bundleResults() const {
    return data().value<BundleResults>();
  }


  BundleSettingsQsp ProjectItem::bundleSettings() const {
    return data().value<BundleSettingsQsp>();
  }


  BundleSolutionInfo *ProjectItem::bundleSolutionInfo() const {
    return data().value<BundleSolutionInfo *>();
  }


  Image *ProjectItem::image() const {
    return data().value<Image *>();
  }


  ImageList *ProjectItem::imageList() const {
    return data().value<ImageList *>();
  }


  Shape *ProjectItem::shape() const {
    return data().value<Shape *>();
  }


  ShapeList *ProjectItem::shapeList() const {
    return data().value<ShapeList *>();
  }


  Control *ProjectItem::control() const {
    return data().value<Control *>();
  }


  ControlList *ProjectItem::controlList() const {
    return data().value<ControlList *>();
  }

  
  CorrelationMatrix ProjectItem::correlationMatrix() const {
    return data().value<CorrelationMatrix>();
  }


  Project *ProjectItem::project() const {
    return data().value<Project *>();
  }


  GuiCameraQsp ProjectItem::guiCamera() const {
    return data().value<GuiCameraQsp>();

  }
  

  TargetBodyQsp ProjectItem::targetBody() const {
    return data().value<TargetBodyQsp>();
  }


  bool ProjectItem::isBundleResults() const {
    return data().canConvert<BundleResults>();
  }


  bool ProjectItem::isBundleSettings() const {
    return data().canConvert<BundleSettingsQsp>();
  }


  bool ProjectItem::isBundleSolutionInfo() const {
    return data().canConvert<BundleSolutionInfo *>();
  }


  bool ProjectItem::isImage() const {
    return data().canConvert<Image *>();
  }


  bool ProjectItem::isImageList() const {
    return data().canConvert<ImageList *>();
  }


  bool ProjectItem::isShape() const {
    return data().canConvert<Shape *>();
  }


  bool ProjectItem::isShapeList() const {
    return data().canConvert<ShapeList *>();
  }


  bool ProjectItem::isControl() const { 
    return data().canConvert<Control *>();
  }


  bool ProjectItem::isControlList() const {
    return data().canConvert<ControlList *>();
  }


  bool ProjectItem::isCorrelationMatrix() const {
    return data().canConvert<CorrelationMatrix>();
  }


  bool ProjectItem::isProject() const { 
    return data().canConvert<Project *>();
  }


  bool ProjectItem::isGuiCamera() const {     
    return data().canConvert<GuiCameraQsp>();
  }


  bool ProjectItem::isTargetBody() const { 
    return data().canConvert<TargetBodyQsp>();
  }


  void ProjectItem::setProjectItem(ProjectItem *item) {
    setText( item->text() );
    setIcon( item->icon() );
    setData( item->data() );
  }


  void ProjectItem::setBundleResults(BundleResults bundleResults) {
    setText("Results");
    setIcon( QIcon(":results") );
    setData( QVariant::fromValue<BundleResults>(bundleResults) );
  }


  void ProjectItem::setBundleSettings(BundleSettingsQsp bundleSettings) {
    setText("Settings");
    setIcon( QIcon(":settings") );
    setData( QVariant::fromValue<BundleSettingsQsp>(bundleSettings) );
  }


  void ProjectItem::setBundleSolutionInfo(BundleSolutionInfo *bundleSolutionInfo) {
    setText( bundleSolutionInfo->runTime() );
    setIcon( QIcon(":results") );
    setData( QVariant::fromValue<BundleSolutionInfo *>(bundleSolutionInfo) );
  }


  void ProjectItem::setImage(Image *image) {
    setText( QFileInfo( image->fileName() ).fileName() );
    setIcon( QIcon(":pictures") );
    setData( QVariant::fromValue<Image *>(image) );
  }


  void ProjectItem::setImageList(ImageList *imageList) {
    setText( imageList->name() );
    setIcon( QIcon(":pictures") );
    setData( QVariant::fromValue<ImageList *>(imageList) );
  }


  void ProjectItem::setImages() {
    setText("Images");
    setIcon( QIcon(":pictures") );
    setData( QVariant() );
  }


  void ProjectItem::setShape(Shape *shape) {
    setText( QFileInfo( shape->fileName() ).fileName() );
    setIcon( QIcon(":dem") );
    setData( QVariant::fromValue<Shape *>(shape) );
  }


  void ProjectItem::setShapeList(ShapeList *shapeList) {
    setText( shapeList->name() );
    setIcon( QIcon(":dem") );
    setData( QVariant::fromValue<ShapeList *>(shapeList) );
  }


  void ProjectItem::setShapes() {
    setText("Shapes");
    setIcon( QIcon(":dem") );
    setData( QVariant() );
  }


  void ProjectItem::setControl(Control *control) {
    setText( QFileInfo( control->fileName() ).fileName() );
    setIcon( QIcon(":pointReg") );
    setData( QVariant::fromValue<Control *>(control) );
  }


  void ProjectItem::setControlList(ControlList *controlList) {
    setText( controlList->name() );
    setIcon( QIcon(":folder") );
    setData( QVariant::fromValue<ControlList *>(controlList) );
  }


  void ProjectItem::setControls() {
    setText("Control Networks");
    setIcon( QIcon(":layers") );
    setData( QVariant() );
  }

  
  void ProjectItem::setCorrelationMatrix(CorrelationMatrix correlationMatrix) {
    setText("Correlation Matrix");
    setIcon( QIcon(":pointReg") );
    setData( QVariant::fromValue<CorrelationMatrix>(correlationMatrix) );
  }


  void ProjectItem::setProject(Project *project) {
    setText( project->name() );
    setIcon( QIcon(":data-management") );
    setData( QVariant::fromValue<Project *>(project) );
  }


  void ProjectItem::setResults() {
    setText("Results");
    setIcon( QIcon(":results") );
    setData( QVariant() );
  }


  void ProjectItem::setGuiCamera(GuiCameraQsp guiCamera) {
    setText( guiCamera->displayProperties()->displayName() );
    setIcon( QIcon(":camera") );
    setData( QVariant::fromValue<GuiCameraQsp>(guiCamera) );
  }


  void ProjectItem::setGuiCameraList() {
    setText("Sensors");
    setIcon( QIcon(":camera") );
    setData( QVariant() );
  }
  
  
  void ProjectItem::setSpacecraft() {
    setText("Spacecraft");
    setIcon( QIcon(":spacecraft") );
    setData( QVariant() );
  }
  

  void ProjectItem::setTargetBody(TargetBodyQsp targetBody) {
    setText( targetBody->displayProperties()->displayName() );
    if (targetBody->displayProperties()->displayName() == "MOON")
      setIcon( QIcon(":moon") );
    else if (targetBody->displayProperties()->displayName() == "Enceladus")
      setIcon( QIcon(":enceladus") );
    else if (targetBody->displayProperties()->displayName() == "Mars")
      setIcon( QIcon(":mars") );
    else if (targetBody->displayProperties()->displayName() == "Titan")
      setIcon( QIcon(":titan") );
    else
      setIcon( QIcon(":moonPhase") );
    setData( QVariant::fromValue<TargetBodyQsp>(targetBody) );
  }
  

  void ProjectItem::setTargetBodyList() {
    setText("Target Body");
    setIcon( QIcon(":moonPhase") );
    setData( QVariant() );
  }


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

    return 0;
  }


  void ProjectItem::appendRow(ProjectItem *item) {
    QStandardItem::appendRow(item);
  }

 
  ProjectItem *ProjectItem::child(int row) const {
    return static_cast<ProjectItem *>( QStandardItem::child(row) );
  }


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


  ProjectItemModel *ProjectItem::model() const {
    return static_cast<ProjectItemModel *>( QStandardItem::model() );
  }


  ProjectItem *ProjectItem::parent() const {
    return static_cast<ProjectItem *>( QStandardItem::parent() );
  }


  void ProjectItem::setChild(int row, ProjectItem *item) {
    QStandardItem::setChild(row, item);
  }


  ProjectItem *ProjectItem::takeChild(int row) {
    QList<QStandardItem *> items = QStandardItem::takeRow(row);
    
    if ( items.isEmpty() ) {
      return 0;
    }

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