TargetBodyList.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "TargetBodyList.h"
 
//#include <QAction>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QFuture>
#include <QInputDialog>
#include <QLabel>
#include <QProgressDialog>
#include <QtConcurrentMap>
#include <QXmlStreamWriter>
 
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "Project.h"
#include "TargetBody.h"
#include "XmlStackedHandlerReader.h"
 
namespace Isis {
  TargetBodyList::TargetBodyList(QString name, QString path, QObject *parent) : QObject(parent) {
    m_name = name;
    m_path = path;
  }
 
 
  TargetBodyList::TargetBodyList(QObject *parent) : QObject(parent) {
  }
 
 
  TargetBodyList::TargetBodyList(QList<TargetBodyQsp> targetBodys, QObject *parent) : QObject(parent) {
    append(targetBodys);
  }
 
 
  TargetBodyList::TargetBodyList(Project *project, XmlStackedHandlerReader *xmlReader,
                                 QObject *parent) : QObject(parent) {
    xmlReader->pushContentHandler(new XmlHandler(this, project));
  }
 
 
  TargetBodyList::TargetBodyList(const TargetBodyList &other) :
      QList<TargetBodyQsp>(other) {
    m_name = other.m_name;
    m_path = other.m_path;
  }
 
 
//  TargetBodyList::TargetBodyList(QStringList &fileNames) {
//    foreach (QString fileName, fileNames) {
//      try {
//        TargetBodyQsp targetBody = TargetBodyQsp(new TargetBody(fileName);
//        append(targetBody);
//      }
//      catch (IException &) {
//      }
//    }
//  }
 
 
  TargetBodyList::~TargetBodyList() {
  }
 
 
  void TargetBodyList::append(TargetBodyQsp const &value) {
    QList<TargetBodyQsp>::append(value);
    emit countChanged(count());
  }
 
 
  void TargetBodyList::append(const QList<TargetBodyQsp> &value) {
    QList<TargetBodyQsp>::append(value);
    emit countChanged(count());
  }
 
 
  void TargetBodyList::clear() {
    bool countChanging = count();
    QList<TargetBodyQsp>::clear();
    if (countChanging) {
      emit countChanged(count());
    }
  }
 
 
  QList<TargetBodyQsp>::iterator TargetBodyList::erase(iterator pos) {
    iterator result = QList<TargetBodyQsp>::erase(pos);
    emit countChanged(count());
    return result;
  }
 
 
  QList<TargetBodyQsp>::iterator TargetBodyList::erase(iterator begin, iterator end) {
    iterator result = QList<TargetBodyQsp>::erase(begin, end);
    emit countChanged(count());
    return result;
  }
 
 
  void TargetBodyList::insert(int i, TargetBodyQsp const &value) {
    QList<TargetBodyQsp>::insert(i, value);
 
    emit countChanged(count());
  }
 
 
  QList<TargetBodyQsp>::iterator TargetBodyList::insert(iterator before, TargetBodyQsp const &value) {
    iterator result = QList<TargetBodyQsp>::insert(before, value);
    emit countChanged(count());
    return result;
  }
 
 
  void TargetBodyList::prepend(TargetBodyQsp const &value) {
    QList<TargetBodyQsp>::prepend(value);
    emit countChanged(count());
  }
 
 
  void TargetBodyList::push_back(TargetBodyQsp const &value) {
    QList<TargetBodyQsp>::push_back(value);
    emit countChanged(count());
  }
 
 
  void TargetBodyList::push_front(TargetBodyQsp const &value) {
    QList<TargetBodyQsp>::push_front(value);
    emit countChanged(count());
  }
 
 
  int TargetBodyList::removeAll(TargetBodyQsp const &value) {
    int result = QList<TargetBodyQsp>::removeAll(value);
 
    if (result != 0) {
      emit countChanged(count());
    }
 
    return result;
  }
 
 
  void TargetBodyList::removeAt(int i) {
    QList<TargetBodyQsp>::removeAt(i);
    emit countChanged(count());
  }
 
 
  void TargetBodyList::removeFirst() {
    QList<TargetBodyQsp>::removeFirst();
    emit countChanged(count());
  }
 
 
  void TargetBodyList::removeLast() {
    QList<TargetBodyQsp>::removeLast();
    emit countChanged(count());
  }
 
 
  bool TargetBodyList::removeOne(TargetBodyQsp const &value) {
    bool result = QList<TargetBodyQsp>::removeOne(value);
 
    if (result) {
      emit countChanged(count());
    }
 
    return result;
  }
 
 
  void TargetBodyList::swap(QList<TargetBodyQsp> &other) {
    QList<TargetBodyQsp>::swap(other);
 
    if (count() != other.count()) {
      emit countChanged(count());
    }
  }
 
 
  TargetBodyQsp TargetBodyList::takeAt(int i) {
    TargetBodyQsp result = QList<TargetBodyQsp>::takeAt(i);
    emit countChanged(count());
    return result;
  }
 
 
  TargetBodyQsp TargetBodyList::takeFirst() {
    TargetBodyQsp result = QList<TargetBodyQsp>::takeFirst();
    emit countChanged(count());
    return result;
  }
 
 
  TargetBodyQsp TargetBodyList::takeLast() {
    TargetBodyQsp result = QList<TargetBodyQsp>::takeLast();
    emit countChanged(count());
    return result;
  }
 
 
  TargetBodyList &TargetBodyList::operator+=(const QList<TargetBodyQsp> &other) {
    QList<TargetBodyQsp>::operator+=(other);
 
    if (other.count()) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  TargetBodyList &TargetBodyList::operator+=(TargetBodyQsp const &other) {
    QList<TargetBodyQsp>::operator+=(other);
    emit countChanged(count());
    return *this;
  }
 
 
  TargetBodyList &TargetBodyList::operator<<(const QList<TargetBodyQsp> &other) {
    QList<TargetBodyQsp>::operator<<(other);
 
    if (other.count()) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  TargetBodyList &TargetBodyList::operator<<(TargetBodyQsp const &other) {
    QList<TargetBodyQsp>::operator<<(other);
    emit countChanged(count());
    return *this;
  }
 
 
  TargetBodyList &TargetBodyList::operator=(const QList<TargetBodyQsp> &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<TargetBodyQsp>::operator=(rhs);
 
    if (countChanging) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  TargetBodyList &TargetBodyList::operator=(const TargetBodyList &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<TargetBodyQsp>::operator=(rhs);
 
    m_name = rhs.m_name;
    m_path = rhs.m_path;
 
    if (countChanging) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
//  QList<QAction *> TargetBodyList::supportedActions(Project *project) {
//    QList<QAction *> actions;
 
//    // It turns out connect() statements cannot be templated, hence they aren't inside of
//    //   createWorkOrder().
//    if (allSupport(ImageDisplayProperties::Color)) {
//      QAction *alphaAction = createWorkOrder(project, TargetBodyListActionWorkOrder::ChangeTransparency);
//      if (!project) {
//        connect(alphaAction, SIGNAL(triggered()),
//                this, SLOT(askAndUpdateAlpha()));
//      }
//      actions.append(alphaAction);
 
//      QAction *colorAction = createWorkOrder(project, TargetBodyListActionWorkOrder::ChangeColor);
//      if (!project) {
//        connect(colorAction, SIGNAL(triggered()),
//                this, SLOT(askAndUpdateColor()));
//      }
//      actions.append(colorAction);
 
 
//      QAction *ranColorAction = createWorkOrder(project, TargetBodyListActionWorkOrder::RandomizeColor);
//      if (!project) {
//        connect(ranColorAction, SIGNAL(triggered()),
//                this, SLOT(showRandomColor()));
//      }
//      actions.append(ranColorAction);
//    }
 
 
//    if (allSupport(ImageDisplayProperties::ShowLabel)) {
//      QAction *labelVisibleAction = createWorkOrder(project,
//                                                    TargetBodyListActionWorkOrder::ToggleShowLabel);
//      if (!project) {
//        connect(labelVisibleAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowLabel()));
//      }
//      actions.append(labelVisibleAction);
//    }
 
 
//    if (allSupport(ImageDisplayProperties::ShowFill)) {
//      QAction *fillAction = createWorkOrder(project, TargetBodyListActionWorkOrder::ToggleShowFilled);
//      if (!project) {
//        connect(fillAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowFill()));
//      }
//      actions.append(fillAction);
//    }
 
 
//    if (allSupport(ImageDisplayProperties::ShowDNs)) {
//      QAction *cubeDataAction = createWorkOrder(project,
//                                                TargetBodyListActionWorkOrder::ToggleShowCubeData);
//      if (!project) {
//        connect(cubeDataAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowDNs()));
//      }
//      actions.append(cubeDataAction);
//    }
 
 
//    if (allSupport(ImageDisplayProperties::ShowOutline)) {
//      QAction *outlineAction = createWorkOrder(project,
//                                               TargetBodyListActionWorkOrder::ToggleShowOutline);
//      if (!project) {
//        connect(outlineAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowOutline()));
//      }
//      actions.append(outlineAction);
//    }
 
//    actions.append(NULL);
 
//    if (!project) {
//      if (allSupport(ImageDisplayProperties::ZOrdering)) {
//        QAction *moveToTopAct = new QAction(tr("Bring to Front"), this);
//        QAction *moveUpAct = new QAction(tr("Bring Forward"), this);
//        QAction *moveToBottomAct = new QAction(tr("Send to Back"), this);
//        QAction *moveDownAct = new QAction(tr("Send Backward"), this);
 
//        foreach (Image *image, *this) {
//          connect(moveToTopAct, SIGNAL(triggered()),
//                  image->displayProperties(), SIGNAL(moveToTop()));
 
//          connect(moveUpAct, SIGNAL(triggered()),
//                  image->displayProperties(), SIGNAL(moveUpOne()));
 
//          connect(moveToBottomAct, SIGNAL(triggered()),
//                  image->displayProperties(), SIGNAL(moveToBottom()));
 
//          connect(moveDownAct, SIGNAL(triggered()),
//                  image->displayProperties(), SIGNAL(moveDownOne()));
//        }
//        actions.append(moveToTopAct);
//        actions.append(moveUpAct);
//        actions.append(moveToBottomAct);
//        actions.append(moveDownAct);
//      }
 
//      actions.append(NULL);
 
//      if (size() == 1 && allSupport(ImageDisplayProperties::Zooming)) {
//        QAction *zoomFit = new QAction(tr("Zoom Fit"), this);
//        connect(zoomFit, SIGNAL(triggered()),
//                first()->displayProperties(), SIGNAL(zoomFit()));
//        actions.append(zoomFit);
//      }
//    }
 
//    return actions;
//  }
 
 
//  bool TargetBodyList::allSupport(ImageDisplayProperties::Property prop) {
//    if (isEmpty())
//      return false;
 
//    foreach (Image *image, *this) {
//      if (!image->displayProperties()->supports(prop))
//        return false;
//    }
 
//    return true;
//  }
 
 
  void TargetBodyList::setName(QString newName) {
    m_name = newName;
  }
 
 
  void TargetBodyList::setPath(QString newPath) {
    m_path = newPath;
  }
 
 
  QString TargetBodyList::name() const {
    return m_name;
  }
 
 
  QString TargetBodyList::path() const {
    return m_path;
  }
 
 
//  void TargetBodyList::deleteFromDisk(Project *project) {
//    foreach (TargetBodyQsp targetBody, *this) {
//      targetBody->deleteFromDisk();
//    }
 
//    if (!m_path.isEmpty()) {
//      QFile::remove(project->imageDataRoot() + "/" + m_path + "/targets.xml");
 
//      QDir dir;
//      dir.rmdir(project->imageDataRoot() + "/" + m_path);
//    }
//  }
 
 
  void TargetBodyList::save(QXmlStreamWriter &stream, const Project *project,
                            FileName newProjectRoot) const {
//    stream.writeStartElement("TargetBodyList");
//    stream.writeAttribute("name", m_name);
//    stream.writeAttribute("path", m_path);
 
//    FileName settingsFileName(
//        Project::targetBodyRoot(newProjectRoot.toString()) + "/" + m_path + "/targets.xml");
 
//    if (!settingsFileName.dir().mkpath(settingsFileName.path())) {
//      throw IException(IException::Io,
//                       QString("Failed to create directory [%1]")
//                         .arg(settingsFileName.path()),
//                       _FILEINFO_);
//    }
 
//    QFile TargetBodyListContentsFile(settingsFileName.toString());
 
//    if (!TargetBodyListContentsFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
//      throw IException(IException::Io,
//          QString("Unable to save target body information for [%1] because [%2] could not be opened"
//                  " for writing")
//            .arg(m_name).arg(settingsFileName.original()),
//          _FILEINFO_);
//    }
 
//    QXmlStreamWriter targetBodyDetailsWriter(&TargetBodyListContentsFile);
//    targetBodyDetailsWriter.setAutoFormatting(true);
//    targetBodyDetailsWriter.writeStartDocument();
 
//    int countWidth = QString("%1L").arg(count()).size() - 1;
//    QChar paddingChar('0');
 
//    QLabel *progressLabel = new QLabel;
 
//    QProgressDialog progressDialog;
//    progressDialog.setLabel(progressLabel);
//    progressDialog.setRange(-1, count());
//    progressDialog.setValue(-1);
 
//    targetBodyDetailsWriter.writeStartElement("targets");
//    // Mapped is way faster than hundreds/thousands of run() calls... so use mapped for performance
//    QFuture<void *> future = QtConcurrent::mapped(*this,
//        CopyTargetBodyDataFunctor(project, newProjectRoot));
 
//    for (int i = 0; i < count(); i++) {
//      int newProgressValue = progressDialog.value() + 1;
//      progressLabel->setText(
//          tr("Saving Target Body Information for [%1] - %L2/%L3 done")
//            .arg(m_name)
//            .arg(newProgressValue, countWidth, 10, paddingChar)
//            .arg(count()));
//      progressDialog.setValue(newProgressValue);
//      future.resultAt(i);
//    }
 
//    progressLabel->setText(tr("Finalizing..."));
//    progressDialog.setRange(0, 0);
//    progressDialog.setValue(0);
 
//    foreach (TargetBodyQsp targetBody, *this) {
//      targetBody->save(targetBodyDetailsWriter, project, newProjectRoot);
//    }
 
//    targetBodyDetailsWriter.writeEndElement();
 
//    targetBodyDetailsWriter.writeEndDocument();
 
//    stream.writeEndElement();
  }
 
 
//  TargetBodyList::CopyTargetBodyDataFunctor::CopyTargetBodyDataFunctor(const Project *project,
//                                                                       FileName newProjectRoot) {
//    m_project = project;
//    m_newProjectRoot = newProjectRoot;
//  }
 
 
//  TargetBodyList::CopyTargetBodyDataFunctor::CopyTargetBodyDataFunctor(
//                  const CopyTargetBodyDataFunctor &other) {
//    m_project = other.m_project;
//    m_newProjectRoot = other.m_newProjectRoot;
//  }
 
 
//  TargetBodyList::CopyTargetBodyDataFunctor::~CopyTargetBodyDataFunctor() {
//  }
 
 
//  void *TargetBodyList::CopyTargetBodyDataFunctor::operator()(TargetBodyQsp const &targetToCopy) {
//    targetToCopy->copyToNewProjectRoot(m_project, m_newProjectRoot);
//    return NULL;
//  }
 
 
//  TargetBodyList::CopyTargetBodyDataFunctor &TargetBodyList::CopyTargetBodyDataFunctor::operator=(
//      const CopyTargetBodyDataFunctor &rhs) {
//    m_project = rhs.m_project;
//    m_newProjectRoot = rhs.m_newProjectRoot;
//    return *this;
//  }
 
 
//  QStringList TargetBodyList::saveAndToggleShowLabel() {
//    QStringList results;
 
//    if (!isEmpty()) {
//      ImageDisplayProperties *firstDisplayProps = first()->displayProperties();
//      bool newValue = !firstDisplayProps->getValue(ImageDisplayProperties::ShowLabel).toBool();
 
//      foreach (Image *image, *this) {
//        ImageDisplayProperties *displayProps = image->displayProperties();
 
//        bool value = displayProps->getValue(ImageDisplayProperties::ShowLabel).toBool();
//        results.append(value? "shown" : "hidden");
 
//        image->displayProperties()->setShowLabel(newValue);
//      }
//    }
 
//    return results;
//  }
 
 
  TargetBodyList::XmlHandler::XmlHandler(TargetBodyList *TargetBodyList, Project *project) {
    m_TargetBodyList = TargetBodyList;
    m_project = project;
  }
 
 
  bool TargetBodyList::XmlHandler::startElement(const QString &namespaceURI,
                                                const QString &localName,
                                                const QString &qName,
                                                const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "TargetBodyList") {
        QString name = atts.value("name");
        QString path = atts.value("path");
 
        if (!name.isEmpty()) {
          m_TargetBodyList->setName(name);
        }
 
        if (!path.isEmpty()) {
          m_TargetBodyList->setPath(path);
        }
      }
      else if (localName == "target") {
//        m_TargetBodyList->append(TargetBodyQsp(new TargetBody(m_project->targetBodyRoot()
//                                           + "/" + m_TargetBodyList->path(),
//                                           reader())));
      }
    }
 
    return true;
  }
 
 
  bool TargetBodyList::XmlHandler::endElement(const QString &namespaceURI,
                                              const QString &localName,
                                              const QString &qName) {
    if (localName == "TargetBodyList") {
      XmlHandler handler(m_TargetBodyList, m_project);
 
      XmlStackedHandlerReader reader;
      reader.pushContentHandler(&handler);
      reader.setErrorHandler(&handler);
 
      QString TargetBodyListXmlPath = m_project->targetBodyRoot() + "/" +
                                m_TargetBodyList->path() + "/targets.xml";
      QFile file(TargetBodyListXmlPath);
 
      if (!file.open(QFile::ReadOnly)) {
        throw IException(IException::Io,
                         QString("Unable to open [%1] with read access")
                           .arg(TargetBodyListXmlPath),
                         _FILEINFO_);
      }
 
      QXmlInputSource xmlInputSource(&file);
      if (!reader.parse(xmlInputSource))
        throw IException(IException::Io,
                         tr("Failed to open target body list XML [%1]").arg(TargetBodyListXmlPath),
                         _FILEINFO_);
    }
 
    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
}