GuiCameraList.cpp

Go to the documentation of this file.

#include "GuiCameraList.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 "GuiCamera.h"
#include "IException.h"
#include "IString.h"
#include "Project.h"
#include "XmlStackedHandlerReader.h"

namespace Isis {
  GuiCameraList::GuiCameraList(QString name, QString path, QObject *parent) : QObject(parent) {
    m_name = name;
    m_path = path;
  }


  GuiCameraList::GuiCameraList(QObject *parent) : QObject(parent) {
  }


  GuiCameraList::GuiCameraList(QList<GuiCameraQsp> guiCameras, QObject *parent) : QObject(parent) {
    append(guiCameras);
  }


  GuiCameraList::GuiCameraList(Project *project, XmlStackedHandlerReader *xmlReader,
                                 QObject *parent) : QObject(parent) {
    xmlReader->pushContentHandler(new XmlHandler(this, project));
  }


  GuiCameraList::GuiCameraList(const GuiCameraList &src) :
      QList<GuiCameraQsp>(src) {
    m_name = src.m_name;
    m_path = src.m_path;
  }


//  GuiCameraList::GuiCameraList(QStringList &fileNames) {
//    foreach (QString fileName, fileNames) {
//      try {
//        GuiCameraQsp guiCamera = GuiCameraQsp(new GuiCamera(fileName);
//        append(guiCamera);
//      }
//      catch (IException &) {
//      }
//    }
//  }


  GuiCameraList::~GuiCameraList() {
  }


  void GuiCameraList::append(GuiCameraQsp const &value) {
    QList<GuiCameraQsp>::append(value);
    emit countChanged(count());
  }


  void GuiCameraList::append(const QList<GuiCameraQsp> &value) {
    QList<GuiCameraQsp>::append(value);
    emit countChanged(count());
  }


  void GuiCameraList::clear() {
    bool countChanging = count();
    QList<GuiCameraQsp>::clear();
    if (countChanging) {
      emit countChanged(count());
    }
  }


  QList<GuiCameraQsp>::iterator GuiCameraList::erase(iterator pos) {
    iterator result = QList<GuiCameraQsp>::erase(pos);
    emit countChanged(count());
    return result;
  }


  QList<GuiCameraQsp>::iterator GuiCameraList::erase(iterator begin, iterator end) {
    iterator result = QList<GuiCameraQsp>::erase(begin, end);
    emit countChanged(count());
    return result;
  }


  void GuiCameraList::insert(int i, GuiCameraQsp const &value) {
    QList<GuiCameraQsp>::insert(i, value);

    emit countChanged(count());
  }


  QList<GuiCameraQsp>::iterator GuiCameraList::insert(iterator before, GuiCameraQsp const & value) {
    iterator result = QList<GuiCameraQsp>::insert(before, value);
    emit countChanged(count());
    return result;
  }


  void GuiCameraList::prepend(GuiCameraQsp const &value) {
    QList<GuiCameraQsp>::prepend(value);
    emit countChanged(count());
  }


  void GuiCameraList::push_back(GuiCameraQsp const &value) {
    QList<GuiCameraQsp>::push_back(value);
    emit countChanged(count());
  }


  void GuiCameraList::push_front(GuiCameraQsp const &value) {
    QList<GuiCameraQsp>::push_front(value);
    emit countChanged(count());
  }


  int GuiCameraList::removeAll(GuiCameraQsp const &value) {
    int result = QList<GuiCameraQsp>::removeAll(value);

    if (result != 0) {
      emit countChanged(count());
    }

    return result;
  }


  void GuiCameraList::removeAt(int i) {
    QList<GuiCameraQsp>::removeAt(i);
    emit countChanged(count());
  }


  void GuiCameraList::removeFirst() {
    QList<GuiCameraQsp>::removeFirst();
    emit countChanged(count());
  }


  void GuiCameraList::removeLast() {
    QList<GuiCameraQsp>::removeLast();
    emit countChanged(count());
  }


  bool GuiCameraList::removeOne(GuiCameraQsp const &value) {
    bool result = QList<GuiCameraQsp>::removeOne(value);

    if (result) {
      emit countChanged(count());
    }

    return result;
  }


  void GuiCameraList::swap(QList<GuiCameraQsp> &other) {
    QList<GuiCameraQsp>::swap(other);

    if (count() != other.count()) {
      emit countChanged(count());
    }
  }


  GuiCameraQsp GuiCameraList::takeAt(int i) {
    GuiCameraQsp result = QList<GuiCameraQsp>::takeAt(i);
    emit countChanged(count());
    return result;
  }


  GuiCameraQsp GuiCameraList::takeFirst() {
    GuiCameraQsp result = QList<GuiCameraQsp>::takeFirst();
    emit countChanged(count());
    return result;
  }


  GuiCameraQsp GuiCameraList::takeLast() {
    GuiCameraQsp result = QList<GuiCameraQsp>::takeLast();
    emit countChanged(count());
    return result;
  }


  GuiCameraList &GuiCameraList::operator+=(const QList<GuiCameraQsp> &other) {
    QList<GuiCameraQsp>::operator+=(other);

    if (other.count()) {
      emit countChanged(count());
    }

    return *this;
  }


  GuiCameraList &GuiCameraList::operator+=(GuiCameraQsp const &other) {
    QList<GuiCameraQsp>::operator+=(other);
    emit countChanged(count());
    return *this;
  }


  GuiCameraList &GuiCameraList::operator<<(const QList<GuiCameraQsp> &other) {
    QList<GuiCameraQsp>::operator<<(other);

    if (other.count()) {
      emit countChanged(count());
    }

    return *this;
  }


  GuiCameraList &GuiCameraList::operator<<(GuiCameraQsp const &other) {
    QList<GuiCameraQsp>::operator<<(other);
    emit countChanged(count());
    return *this;
  }


  GuiCameraList &GuiCameraList::operator=(const QList<GuiCameraQsp> &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<GuiCameraQsp>::operator=(rhs);

    if (countChanging) {
      emit countChanged(count());
    }

    return *this;
  }


  GuiCameraList &GuiCameraList::operator=(const GuiCameraList &rhs) {
    bool countChanging = (rhs.count() != count());
    QList<GuiCameraQsp>::operator=(rhs);

    m_name = rhs.m_name;
    m_path = rhs.m_path;

    if (countChanging) {
      emit countChanged(count());
    }

    return *this;
  }


//  QList<QAction *> GuiCameraList::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, GuiCameraListActionWorkOrder::ChangeTransparency);
//      if (!project) {
//        connect(alphaAction, SIGNAL(triggered()),
//                this, SLOT(askAndUpdateAlpha()));
//      }
//      actions.append(alphaAction);

//      QAction *colorAction = createWorkOrder(project, GuiCameraListActionWorkOrder::ChangeColor);
//      if (!project) {
//        connect(colorAction, SIGNAL(triggered()),
//                this, SLOT(askAndUpdateColor()));
//      }
//      actions.append(colorAction);


//      QAction *ranColorAction = createWorkOrder(project, GuiCameraListActionWorkOrder::RandomizeColor);
//      if (!project) {
//        connect(ranColorAction, SIGNAL(triggered()),
//                this, SLOT(showRandomColor()));
//      }
//      actions.append(ranColorAction);
//    }


//    if (allSupport(ImageDisplayProperties::ShowLabel)) {
//      QAction *labelVisibleAction = createWorkOrder(project,
//                                                    GuiCameraListActionWorkOrder::ToggleShowLabel);
//      if (!project) {
//        connect(labelVisibleAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowLabel()));
//      }
//      actions.append(labelVisibleAction);
//    }


//    if (allSupport(ImageDisplayProperties::ShowFill)) {
//      QAction *fillAction = createWorkOrder(project, GuiCameraListActionWorkOrder::ToggleShowFilled);
//      if (!project) {
//        connect(fillAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowFill()));
//      }
//      actions.append(fillAction);
//    }


//    if (allSupport(ImageDisplayProperties::ShowDNs)) {
//      QAction *cubeDataAction = createWorkOrder(project,
//                                                GuiCameraListActionWorkOrder::ToggleShowCubeData);
//      if (!project) {
//        connect(cubeDataAction, SIGNAL(triggered()),
//                this, SLOT(saveAndToggleShowDNs()));
//      }
//      actions.append(cubeDataAction);
//    }


//    if (allSupport(ImageDisplayProperties::ShowOutline)) {
//      QAction *outlineAction = createWorkOrder(project,
//                                               GuiCameraListActionWorkOrder::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 GuiCameraList::allSupport(ImageDisplayProperties::Property prop) {
//    if (isEmpty())
//      return false;

//    foreach (Image *image, *this) {
//      if (!image->displayProperties()->supports(prop))
//        return false;
//    }

//    return true;
//  }


  void GuiCameraList::setName(QString newName) {
    m_name = newName;
  }


  void GuiCameraList::setPath(QString newPath) {
    m_path = newPath;
  }


  QString GuiCameraList::name() const {
    return m_name;
  }


  QString GuiCameraList::path() const {
    return m_path;
  }


//  void GuiCameraList::deleteFromDisk(Project *project) {
//    foreach (GuiCameraQsp guiCamera, *this) {
//      guiCamera->deleteFromDisk();
//    }

//    if (!m_path.isEmpty()) {
//      QFile::remove(project->imageDataRoot() + "/" + m_path + "/guicameras.xml");

//      QDir dir;
//      dir.rmdir(project->imageDataRoot() + "/" + m_path);
//    }
//  }


  void GuiCameraList::save(QXmlStreamWriter &stream, const Project *project,
                            FileName newProjectRoot) const {
//    stream.writeStartElement("GuiCameraList");
//    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 GuiCameraListContentsFile(settingsFileName.toString());

//    if (!GuiCameraListContentsFile.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(&GuiCameraListContentsFile);
//    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 (GuiCameraQsp targetBody, *this) {
//      targetBody->save(targetBodyDetailsWriter, project, newProjectRoot);
//    }

//    targetBodyDetailsWriter.writeEndElement();

//    targetBodyDetailsWriter.writeEndDocument();

//    stream.writeEndElement();
  }


//  GuiCameraList::CopyTargetBodyDataFunctor::CopyTargetBodyDataFunctor(const Project *project,
//                                                                       FileName newProjectRoot) {
//    m_project = project;
//    m_newProjectRoot = newProjectRoot;
//  }


//  GuiCameraList::CopyTargetBodyDataFunctor::CopyTargetBodyDataFunctor(const CopyTargetBodyDataFunctor &other) {
//    m_project = other.m_project;
//    m_newProjectRoot = other.m_newProjectRoot;
//  }


//  GuiCameraList::CopyTargetBodyDataFunctor::~CopyTargetBodyDataFunctor() {
//  }


//  void *GuiCameraList::CopyTargetBodyDataFunctor::operator()(GuiCameraQsp const &targetToCopy) {
//    targetToCopy->copyToNewProjectRoot(m_project, m_newProjectRoot);
//    return NULL;
//  }


//  GuiCameraList::CopyTargetBodyDataFunctor &GuiCameraList::CopyTargetBodyDataFunctor::operator=(
//      const CopyTargetBodyDataFunctor &rhs) {
//    m_project = rhs.m_project;
//    m_newProjectRoot = rhs.m_newProjectRoot;
//    return *this;
//  }


//  QStringList GuiCameraList::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;
//  }


  GuiCameraList::XmlHandler::XmlHandler(GuiCameraList *GuiCameraList, Project *project) {
    m_GuiCameraList = GuiCameraList;
    m_project = project;
  }


  bool GuiCameraList::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                               const QString &qName, const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "GuiCameraList") {
        QString name = atts.value("name");
        QString path = atts.value("path");

        if (!name.isEmpty()) {
          m_GuiCameraList->setName(name);
        }

        if (!path.isEmpty()) {
          m_GuiCameraList->setPath(path);
        }
      }
      else if (localName == "target") {
//        m_GuiCameraList->append(GuiCameraQsp(new TargetBody(m_project->targetBodyRoot() + "/" + m_GuiCameraList->path(),
//                                           reader())));
      }
    }

    return true;
  }


  bool GuiCameraList::XmlHandler::endElement(const QString &namespaceURI, const QString &localName,
                                             const QString &qName) {
    if (localName == "GuiCameraList") {
      XmlHandler handler(m_GuiCameraList, m_project);

      XmlStackedHandlerReader reader;
      reader.pushContentHandler(&handler);
      reader.setErrorHandler(&handler);

      QString GuiCameraListXmlPath = m_project->targetBodyRoot() + "/" + m_GuiCameraList->path() +
                                 "/targets.xml";
      QFile file(GuiCameraListXmlPath);

      if (!file.open(QFile::ReadOnly)) {
        throw IException(IException::Io,
                         QString("Unable to open [%1] with read access")
                           .arg(GuiCameraListXmlPath),
                         _FILEINFO_);
      }

      QXmlInputSource xmlInputSource(&file);
      if (!reader.parse(xmlInputSource))
        throw IException(IException::Io,
                         tr("Failed to open target body list XML [%1]").arg(GuiCameraListXmlPath),
                         _FILEINFO_);
    }

    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
}