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