ProjectItem.cpp

Go to the documentation of this file.

#include "ProjectItem.h"

#include <QBrush>
#include <QIcon>
#include <QStandardItem>
#include <QVariant>
#include <QDebug>

#include "BundleResults.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"
#include "Template.h"
#include "TemplateList.h"

namespace Isis {
  ProjectItem::ProjectItem() : QStandardItem() {
    setTextColor(Qt::black);
    setEditable(false);
  }


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


  ProjectItem::ProjectItem(FileItemQsp filename, QString treeText, QIcon icon) {
    setTextColor(Qt::black);
    setEditable(false);
    setData(QVariant::fromValue<FileItemQsp>(filename));
    setText(treeText);
    setIcon(icon);
  }


  ProjectItem::ProjectItem(FileItemQsp filename, QString treeText, QString toolTipText,
                           QIcon icon) {
    setTextColor(Qt::black);
    setEditable(false);
    setData(QVariant::fromValue<FileItemQsp>(filename));
    setText(treeText);
    setToolTip(toolTipText);
    setIcon(icon);
  }


  ProjectItem::ProjectItem(BundleResults bundleResults) {
    setTextColor(Qt::black);
    setEditable(false);
    setBundleResults(bundleResults);
  }


  ProjectItem::ProjectItem(BundleSettingsQsp bundleSettings) {
    setTextColor(Qt::black);
    setEditable(false);
    setBundleSettings(bundleSettings);
  }


  ProjectItem::ProjectItem(BundleSolutionInfo *bundleSolutionInfo) {
    setTextColor(Qt::black);
    setEditable(false);
    setBundleSolutionInfo(bundleSolutionInfo);

    appendRow( new ProjectItem( bundleSolutionInfo->bundleSettings() ) );
    appendRow( new ProjectItem(bundleSolutionInfo->control()) );
    appendRow( new ProjectItem( bundleSolutionInfo->bundleResults() ) );
    if (!bundleSolutionInfo->adjustedImages().isEmpty()) {
      appendRow( new ProjectItem( bundleSolutionInfo->adjustedImages() ) );
    }
  }


  ProjectItem::ProjectItem(Control *control) {
    setTextColor(Qt::black);
    setEditable(false);
    setControl(control);
  }


  ProjectItem::ProjectItem(ControlList *controlList) {
    setTextColor(Qt::black);
    setEditable(false);
    setControlList(controlList);
    foreach (Control *control, *controlList) {
      appendRow( new ProjectItem(control) );
    }
  }


  ProjectItem::ProjectItem(QList<ControlList *> controls) {
    setTextColor(Qt::black);
    setEditable(false);
    setControls();
    foreach (ControlList *controlList, controls) {
      appendRow( new ProjectItem(controlList) );
    }
  }


  ProjectItem::ProjectItem(CorrelationMatrix correlationMatrix) {
    setTextColor(Qt::black);
    setEditable(false);
    setCorrelationMatrix(correlationMatrix);
  }


  ProjectItem::ProjectItem(Image *image) {
    setTextColor(Qt::black);
    setEditable(true);
    setImage(image);
  }


  ProjectItem::ProjectItem(ImageList *imageList) {
    setTextColor(Qt::black);
    setEditable(true);
    setImageList(imageList);
    foreach (Image *image, *imageList) {
      appendRow( new ProjectItem(image) );
    }
  }


  ProjectItem::ProjectItem(QList<ImageList *> images) {
    setTextColor(Qt::black);
    setEditable(false);
    setImages();
    foreach (ImageList *imageList, images) {
      appendRow( new ProjectItem(imageList) );
    }
  }


  ProjectItem::ProjectItem(Shape *shape) {
    setTextColor(Qt::black);
    setEditable(false);
    setShape(shape);
  }


  ProjectItem::ProjectItem(ShapeList *shapeList) {
    setTextColor(Qt::black);
    setEditable(false);
    setShapeList(shapeList);
    foreach (Shape *shape, *shapeList) {
      appendRow(new ProjectItem(shape));
    }
  }


  ProjectItem::ProjectItem(QList<ShapeList *> shapes) {
    setTextColor(Qt::black);
    setEditable(false);
    setShapes();
    foreach (ShapeList *shapeList, shapes) {
      appendRow( new ProjectItem(shapeList) );
    }
  }


  ProjectItem::ProjectItem(Template *newTemplate) {
    setTextColor(Qt::black);
    setEditable(false);
    setTemplate(newTemplate);
  }


  ProjectItem::ProjectItem(TemplateList *templateList) {

    setTextColor(Qt::black);
    setEditable(false);
    setTemplateList(templateList);
    foreach (Template *currentTemplate, *templateList) {
      appendRow(new ProjectItem(currentTemplate));
    }
  }


  ProjectItem::ProjectItem(QList<TemplateList *> templates) {
    setTextColor(Qt::black);
    setEditable(false);
    setTemplates();
    foreach (TemplateList *templateList, templates) {
      appendRow( new ProjectItem(templateList) );
    }
  }

  ProjectItem::ProjectItem(GuiCameraQsp guiCamera) {
    setTextColor(Qt::black);
    setEditable(false);
    setGuiCamera(guiCamera);
  }


  ProjectItem::ProjectItem(GuiCameraList *guiCameraList) {
    setTextColor(Qt::black);
    setEditable(false);
    setGuiCameraList();
    foreach (GuiCameraQsp guiCamera, *guiCameraList) {
      appendRow( new ProjectItem(guiCamera) );
    }
  }


  ProjectItem::ProjectItem(Project *project) {
    setTextColor(Qt::black);
    setProject(project);
    appendRow( new ProjectItem( project->controls() ) );
    appendRow( new ProjectItem( project->images() ) );
    appendRow( new ProjectItem( project->shapes() ) );

    appendRow( new ProjectItem( project->templates() ) );

    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) {
    setTextColor(Qt::black);
    setEditable(false);
    setResults();
    foreach (BundleSolutionInfo *bundleSolutionInfo, results) {
      appendRow( new ProjectItem( bundleSolutionInfo) );
    }
  }


  ProjectItem::ProjectItem(TargetBodyQsp targetBody) {
    setTextColor(Qt::black);
    setEditable(false);
    setTargetBody(targetBody);
  }


  ProjectItem::ProjectItem(TargetBodyList *targetBodyList) {
    setTextColor(Qt::black);
    setEditable(false);
    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 *>();
  }


  Template *ProjectItem::getTemplate() const {
    return data().value<Template *>();
  }


  TemplateList *ProjectItem::templateList() const {
    return data().value<TemplateList *>();
  }


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


  FileItemQsp ProjectItem::fileItem() const {
    return data().value<FileItemQsp>();
  }


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


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


  bool ProjectItem::isFileItem() const {
    return data().canConvert<FileItemQsp>();
  }


  void ProjectItem::setProjectItem(ProjectItem *item) {
    setTextColor(Qt::black);
    setText( item->text() );
    setIcon( item->icon() );
    setData( item->data() );
    setEditable(item->isEditable());
  }


  void ProjectItem::setBundleResults(BundleResults bundleResults) {
    setTextColor(Qt::black);
    setText("Statistics");
    setIcon( QIcon(FileName("$base/icons/kchart.png")
                           .expanded()));
    setData( QVariant::fromValue<BundleResults>(bundleResults) );
  }


  void ProjectItem::setBundleSettings(BundleSettingsQsp bundleSettings) {
    setTextColor(Qt::black);
    setText("Settings");
    setIcon( QIcon(FileName("$base/icons/applications-system.png")
                           .expanded()));
    setData( QVariant::fromValue<BundleSettingsQsp>(bundleSettings) );
  }


  void ProjectItem::setBundleSolutionInfo(BundleSolutionInfo *bundleSolutionInfo) {
    setTextColor(Qt::black);
    if (bundleSolutionInfo->name() != "") {
      setText( bundleSolutionInfo->name() );
    }
    else {
      setText( bundleSolutionInfo->runTime() );
    }
    setIcon( QIcon(FileName("$base/icons/kchart.png")
                           .expanded()));
    setData( QVariant::fromValue<BundleSolutionInfo *>(bundleSolutionInfo) );
  }


  void ProjectItem::setImage(Image *image) {
    setTextColor(Qt::black);
    setText( QFileInfo( image->fileName() ).fileName() );
    setIcon( QIcon(FileName("$base/icons/view-preview.png")
                           .expanded()));
    setData( QVariant::fromValue<Image *>(image) );
  }


  void ProjectItem::setImageList(ImageList *imageList) {
    setTextColor(Qt::black);
    if (imageList->name() != "") {
      setText( imageList->name() );
    }
    else {
      setText( imageList->path() );
    }
    setIcon( QIcon(FileName("$base/icons/folder-image.png")
                           .expanded()));
    setData( QVariant::fromValue<ImageList *>(imageList) );
  }


  void ProjectItem::setImages() {
    setTextColor(Qt::black);
    setText("Images");
    setIcon( QIcon(FileName("$base/icons/folder-image.png")
                           .expanded()));
    setData( QVariant() );
  }


  void ProjectItem::setShape(Shape *shape) {
    setTextColor(Qt::black);
    setText( QFileInfo( shape->fileName() ).fileName() );
    setIcon( QIcon(FileName("$base/icons/rating.png")
                           .expanded()));
    setData( QVariant::fromValue<Shape *>(shape) );
  }


  void ProjectItem::setShapeList(ShapeList *shapeList) {
    setTextColor(Qt::black);
    if (shapeList->name() != "") {
      setText( shapeList->name() );
    }
    else {
      setText( shapeList->path() );
    }
    setIcon( QIcon(FileName("$base/icons/folder-orange.png")
                           .expanded()));
    setData( QVariant::fromValue<ShapeList *>(shapeList) );
  }


  void ProjectItem::setShapes() {
    setTextColor(Qt::black);
    setText("Shapes");
    setIcon( QIcon(FileName("$base/icons/folder-red.png")
                           .expanded()));
    setData( QVariant() );
  }


  void ProjectItem::setTemplate(Template *newTemplate) {
    setTextColor(Qt::black);
    setText( QFileInfo( newTemplate->fileName() ).fileName() );
    setIcon( QIcon(":folder"));
    setData( QVariant::fromValue<Template *>(newTemplate) );
  }


  void ProjectItem::setTemplateList(TemplateList *templateList) {
    setTextColor(Qt::black);
    if (templateList->name() != "") {
      setText( templateList->name() );
    }
    else {
      setText( templateList->path() );
    }
    setIcon( QIcon(FileName("$base/icons/folder-orange.png")
                           .expanded()));
    setData( QVariant::fromValue<TemplateList *>(templateList) );
  }


  void ProjectItem::setTemplates() {
    setText("Templates");
    setIcon( QIcon(FileName("$base/icons/folder-red.png")
                           .expanded()));
    setData( QVariant() );

    ProjectItem *mapsItem = new ProjectItem();
    mapsItem->setText("Maps");
    setIcon( QIcon(FileName("$base/icons/folder-red.png")
                           .expanded()));
    mapsItem->setData( QVariant() );
    appendRow(mapsItem);


    ProjectItem *registrationsItem = new ProjectItem();
    registrationsItem->setText("Registrations");
    setIcon( QIcon(FileName("$base/icons/folder-red.png")
                           .expanded()));
    registrationsItem->setData( QVariant() );
    appendRow(registrationsItem);
  }


  void ProjectItem::setControl(Control *control) {
    setTextColor(Qt::black);
    setText( QFileInfo( control->fileName() ).fileName() );
    setIcon( QIcon(FileName("$base/icons/network-server-database.png")
                           .expanded()));
    setData( QVariant::fromValue<Control *>(control) );
  }


  void ProjectItem::setControlList(ControlList *controlList) {
    setTextColor(Qt::black);
    setText( controlList->name() );
    setIcon( QIcon(FileName("$base/icons/folder.png")
                           .expanded()));
    setData( QVariant::fromValue<ControlList *>(controlList) );
  }


  void ProjectItem::setControls() {
    setTextColor(Qt::black);
    setText("Control Networks");
    setIcon( QIcon(FileName("$base/icons/folder-remote.png")
                           .expanded()));
    setData( QVariant() );
  }


  void ProjectItem::setCorrelationMatrix(CorrelationMatrix correlationMatrix) {
    setTextColor(Qt::black);
    setText("Correlation Matrix");
    setIcon( QIcon(FileName("$base/icons/network-server-database.png")
                           .expanded()));
    setData( QVariant::fromValue<CorrelationMatrix>(correlationMatrix) );
  }


  void ProjectItem::setProject(Project *project) {
    setTextColor(Qt::black);
    setText( project->name() );
    setIcon( QIcon(FileName("$base/icons/folder-activities.png")
                           .expanded()));
    setData( QVariant::fromValue<Project *>(project) );
    setToolTip(project->projectRoot());
  }


  void ProjectItem::setResults() {
    setTextColor(Qt::black);
    setText("Results");
    setIcon( QIcon(FileName("$base/icons/kchart.png")
                           .expanded()));
    setData( QVariant() );
  }


  void ProjectItem::setGuiCamera(GuiCameraQsp guiCamera) {
    setTextColor(Qt::black);
    setText( guiCamera->displayProperties()->displayName() );
    setIcon( QIcon(FileName("$base/icons/camera-photo.png")
                           .expanded()));
    setData( QVariant::fromValue<GuiCameraQsp>(guiCamera) );
  }


  void ProjectItem::setGuiCameraList() {
    setTextColor(Qt::black);
    setText("Sensors");
    setIcon( QIcon(FileName("$base/icons/camera-photo.png")
                           .expanded()));
    setData( QVariant() );
  }


  void ProjectItem::setSpacecraft() {
    setTextColor(Qt::black);
    setText("Spacecraft");
    setIcon( QIcon(FileName("$base/icons/preferences-desktop-launch-feedback.png")
                           .expanded()));
    setData( QVariant() );
  }



  void ProjectItem::setTargetBody(TargetBodyQsp targetBody) {
    setTextColor(Qt::black);
    setText( targetBody->displayProperties()->displayName() );
    if (targetBody->displayProperties()->displayName() == "MOON")
      setIcon( QIcon(FileName("$base/icons/weather-clear-night.png")
                             .expanded()));
    else if (targetBody->displayProperties()->displayName() == "Enceladus")
      setIcon( QIcon(FileName("$base/icons/nasa_enceladus.png")
                             .expanded()));
    else if (targetBody->displayProperties()->displayName() == "Mars")
      setIcon( QIcon(FileName("$base/icons/nasa_mars.png")
                             .expanded()));
    else if (targetBody->displayProperties()->displayName() == "Titan")
      setIcon( QIcon(FileName("$base/icons/nasa_titan.png")
                             .expanded()));
    else
      setIcon( QIcon(FileName("$base/icons/view-web-browser-dom-tree.png")
                             .expanded()));

    setData( QVariant::fromValue<TargetBodyQsp>(targetBody) );
  }


  void ProjectItem::setTargetBodyList() {
    setTextColor(Qt::black);
    setText("Target Body");
    setIcon( QIcon(FileName("$base/icons/view-web-browser-dom-tree.png")
                           .expanded()));
    setData( QVariant() );
  }


  ProjectItem *ProjectItem::findItemData(const QVariant &value, int role) {
    if ( data(role) == value ) {
      return this;
    }

    for (int i=0; i<rowCount(); i++) {
      ProjectItem *item = child(i)->findItemData(value, role);
      if (item) {
        return item;
      }
    }

    return 0;
  }


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


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


  void ProjectItem::insertRow(int row, ProjectItem *item) {
    setTextColor(Qt::black);
    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) {
    setTextColor(Qt::black);
    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() );
  }


  void ProjectItem::setTextColor(Qt::GlobalColor color) {
    setForeground(QBrush(color));
  }
}