ShapeList.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "ShapeList.h"
 
#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"
 
namespace Isis {
  ShapeList::ShapeList(QString name, QString path, QObject *parent) : QObject(parent) {
    m_name = name;
    m_path = path;
  }
 
 
  ShapeList::ShapeList(QObject *parent) : QObject(parent) {
  }
 
 
  ShapeList::ShapeList(QList<Shape *> shapes, QObject *parent) : QObject(parent) {
    append(shapes);
  }
 
 
  ShapeList::ShapeList(const ShapeList &other) :
      QList<Shape *>(other) {
    m_name = other.m_name;
    m_path = other.m_path;
  }
 
 
  ShapeList::ShapeList(QStringList &fileNames) {
    foreach (QString fileName, fileNames) {
      try {
        Shape *shape = new Shape(fileName);
        append(shape);
      }
      catch (IException &) {
      }
    }
  }
 
 
  ShapeList::~ShapeList() {
  }
 
 
  SerialNumberList ShapeList::serialNumberList() {
 
    SerialNumberList result;
 
    for (int i = 0; i < count(); i++) {
      result.add((*this)[i]->fileName());
    }
    return result;
  }
 
 
  void ShapeList::append(Shape * const &value) {
    QList<Shape *>::append(value);
    emit countChanged(count());
  }
 
 
  void ShapeList::append(const QList<Shape *> &value) {
    QList<Shape *>::append(value);
    emit countChanged(count());
  }
 
 
  void ShapeList::clear() {
    bool countChanging = count();
    QList<Shape *>::clear();
    if (countChanging) {
      emit countChanged(count());
    }
  }
 
 
  QList<Shape *>::iterator ShapeList::erase(iterator pos) {
    iterator result = QList<Shape *>::erase(pos);
    emit countChanged(count());
    return result;
  }
 
 
  QList<Shape *>::iterator ShapeList::erase(iterator begin, iterator end) {
    iterator result = QList<Shape *>::erase(begin, end);
    emit countChanged(count());
    return result;
  }
 
 
  void ShapeList::insert(int i, Shape * const &value) {
    QList<Shape *>::insert(i, value);
 
    emit countChanged(count());
  }
 
 
  QList<Shape *>::iterator ShapeList::insert(iterator before, Shape * const &value) {
    iterator result = QList<Shape *>::insert(before, value);
    emit countChanged(count());
    return result;
  }
 
 
  void ShapeList::prepend(Shape * const &value) {
    QList<Shape *>::prepend(value);
    emit countChanged(count());
  }
 
 
  void ShapeList::push_back(Shape * const &value) {
    QList<Shape *>::push_back(value);
    emit countChanged(count());
  }
 
 
  void ShapeList::push_front(Shape * const &value) {
    QList<Shape *>::push_front(value);
    emit countChanged(count());
  }
 
 
  int ShapeList::removeAll(Shape * const &value) {
    int result = QList<Shape *>::removeAll(value);
 
    if (result != 0) {
      emit countChanged(count());
    }
 
    return result;
  }
 
 
  void ShapeList::removeAt(int i) {
    QList<Shape *>::removeAt(i);
    emit countChanged(count());
  }
 
 
  void ShapeList::removeFirst() {
    QList<Shape *>::removeFirst();
    emit countChanged(count());
  }
 
 
  void ShapeList::removeLast() {
    QList<Shape *>::removeLast();
    emit countChanged(count());
  }
 
 
  bool ShapeList::removeOne(Shape * const &value) {
    bool result = QList<Shape *>::removeOne(value);
 
    if (result) {
      emit countChanged(count());
    }
 
    return result;
  }
 
 
  void ShapeList::swap(QList<Shape *> &other) {
    QList<Shape *>::swap(other);
 
    if (count() != other.count()) {
      emit countChanged(count());
    }
  }
 
 
  Shape *ShapeList::takeAt(int i) {
    Shape * result = QList<Shape *>::takeAt(i);
    emit countChanged(count());
    return result;
  }
 
 
  Shape *ShapeList::takeFirst() {
    Shape *result = QList<Shape *>::takeFirst();
    emit countChanged(count());
    return result;
  }
 
 
  Shape *ShapeList::takeLast() {
    Shape *result = QList<Shape *>::takeLast();
    emit countChanged(count());
    return result;
  }
 
 
  ShapeList &ShapeList::operator+=(const QList<Shape *> &other) {
    QList<Shape *>::operator+=(other);
 
    if (other.count()) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  ShapeList &ShapeList::operator+=(Shape * const &other) {
    QList<Shape *>::operator+=(other);
    emit countChanged(count());
    return *this;
  }
 
 
  ShapeList &ShapeList::operator<<(const QList<Shape *> &other) {
    QList<Shape *>::operator<<(other);
 
    if (other.count()) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  ShapeList &ShapeList::operator<<(Shape * const &other) {
    QList<Shape *>::operator<<(other);
    emit countChanged(count());
    return *this;
  }
 
 
  ShapeList &ShapeList::operator=(const QList<Shape *> &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<Shape *>::operator=(rhs);
 
    if (countChanging) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  ShapeList &ShapeList::operator=(const ShapeList &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<Shape *>::operator=(rhs);
 
    m_name = rhs.m_name;
    m_path = rhs.m_path;
 
    if (countChanging) {
      emit countChanged(count());
    }
 
    return *this;
  }
 
 
  void ShapeList::setName(QString newName) {
    m_name = newName;
  }
 
 
  void ShapeList::setPath(QString newPath) {
    m_path = newPath;
  }
 
 
  QString ShapeList::name() const {
    return m_name;
  }
 
 
  QString ShapeList::path() const {
    return m_path;
  }
 
 
  void ShapeList::deleteFromDisk(Project *project) {
    foreach (Shape *shape, *this) {
      shape->deleteFromDisk();
    }
 
    if (!m_path.isEmpty()) {
      QFile::remove(project->shapeDataRoot() + "/" + m_path + "/shapes.xml");
 
      QDir dir;
      dir.rmdir(project->shapeDataRoot() + "/" + m_path);
    }
  }
 
 
  void ShapeList::save(QXmlStreamWriter &stream, const Project *project, FileName newProjectRoot)
      const {
    stream.writeStartElement("shapeList");
    stream.writeAttribute("name", m_name);
    stream.writeAttribute("path", m_path);
 
    FileName settingsFileName(
        Project::shapeDataRoot(newProjectRoot.toString()) + "/" + m_path + "/shapes.xml");
 
    if (!settingsFileName.dir().mkpath(settingsFileName.path())) {
      throw IException(IException::Io,
                       QString("Failed to create directory [%1]")
                         .arg(settingsFileName.path()),
                       _FILEINFO_);
    }
 
    QFile shapeListContentsFile(settingsFileName.toString());
 
    if (!shapeListContentsFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
          QString("Unable to save shape information for [%1] because [%2] could not be opened for "
                  "writing")
            .arg(m_name).arg(settingsFileName.original()),
          _FILEINFO_);
    }
 
    QXmlStreamWriter shapeDetailsWriter(&shapeListContentsFile);
    shapeDetailsWriter.setAutoFormatting(true);
    shapeDetailsWriter.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);
 
    shapeDetailsWriter.writeStartElement("shapes");
    // Mapped is way faster than hundreds/thousands of run() calls... so use mapped for performance
    QFuture<void *> future = QtConcurrent::mapped(*this,
                                                  CopyShapeDataFunctor(project, newProjectRoot));
 
    for (int i = 0; i < count(); i++) {
      int newProgressValue = progressDialog.value() + 1;
      progressLabel->setText(
          tr("Saving Shape 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 (Shape *shape, *this) {
      shape->save(shapeDetailsWriter, project, newProjectRoot);
    }
 
    shapeDetailsWriter.writeEndElement();
 
    shapeDetailsWriter.writeEndDocument();
 
    stream.writeEndElement();
  }
 
 
  ShapeList::CopyShapeDataFunctor::CopyShapeDataFunctor(const Project *project,
                                                        FileName newProjectRoot) {
    m_project = project;
    m_newProjectRoot = newProjectRoot;
  }
 
 
  ShapeList::CopyShapeDataFunctor::CopyShapeDataFunctor(const CopyShapeDataFunctor &other) {
    m_project = other.m_project;
    m_newProjectRoot = other.m_newProjectRoot;
  }
 
 
  ShapeList::CopyShapeDataFunctor::~CopyShapeDataFunctor() {
  }
 
 
  void *ShapeList::CopyShapeDataFunctor::operator()(Shape * const &shapeToCopy) {
    shapeToCopy->copyToNewProjectRoot(m_project, m_newProjectRoot);
    return NULL;
  }
 
 
  ShapeList::CopyShapeDataFunctor &ShapeList::CopyShapeDataFunctor::operator=(
      const CopyShapeDataFunctor &rhs) {
    m_project = rhs.m_project;
    m_newProjectRoot = rhs.m_newProjectRoot;
    return *this;
  }
}