Control.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Control.h"
 
#include <QDebug>
#include <QDir>
#include <QFileInfo>
#include <QMutex>
#include <QString>
#include <QUuid>
#include <QXmlStreamWriter>
 
#include "ControlDisplayProperties.h"
#include "ControlNet.h"
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "Project.h"
#include "PvlObject.h"
#include "XmlStackedHandlerReader.h"
 
namespace Isis {
  Control::Control(QString cNetFileName, QObject *parent) : QObject(parent) {
 
    m_fileName = cNetFileName;
 
    m_controlNet = NULL;
    m_displayProperties = NULL;
    m_project = NULL;
    m_modified = false;
 
    try {
      openControlNet();
    }
    catch (IException &e) {
      throw IException(e, IException::Programmer, "Error opening control net.", _FILEINFO_);
    }
 
    m_displayProperties
        = new ControlDisplayProperties(FileName(m_fileName).name(), this);
 
    m_id = new QUuid(QUuid::createUuid());
  }
 
 
  Control::Control(Project *project, QString cNetFileName, QObject *parent) : QObject(parent) {
 
    m_fileName = cNetFileName;
 
    m_controlNet = NULL;
    m_displayProperties = NULL;
    m_project = project;
    m_modified = false;
 
    m_displayProperties
        = new ControlDisplayProperties(FileName(m_fileName).name(), this);
 
    m_id = new QUuid(QUuid::createUuid());
  }
 
 
  Control::Control(ControlNet *controlNet, QString cnetFileName, QObject *parent) :
      QObject(parent) {
 
    m_fileName = cnetFileName;
 
    m_controlNet = controlNet;
    m_displayProperties = NULL;
    m_project = NULL;
    m_modified = false;
 
    m_displayProperties
        = new ControlDisplayProperties(FileName(m_fileName).name(), this);
 
    m_id = new QUuid(QUuid::createUuid());
  }
 
 
  Control::Control(FileName cnetFolder, XmlStackedHandlerReader *xmlReader, QObject *parent) :
      QObject(parent) {
    m_controlNet = NULL;
    m_displayProperties = NULL;
    m_id = NULL;
    m_project = NULL;
    m_modified = false;
 
    xmlReader->pushContentHandler(new XmlHandler(this, cnetFolder));
  }
 
 
  Control::~Control() {
    delete m_controlNet;
    m_controlNet = NULL;
 
    delete m_id;
    m_id = NULL;
 
    //  Image is a "Qt" parent of display properties, so the Image QObject
    //    destructor will take care of deleting the display props. See call to
    //    DisplayProperties' constructor.
    m_displayProperties = NULL;
 
    // TODO: If control net is modified, prompt for save before destroying??
 
  }
 
 
  ControlNet *Control::controlNet() {
    if (!m_controlNet) {
      openControlNet();
    }
 
    return m_controlNet;
  }
 
 
  void Control::openControlNet() {
    if (!m_controlNet) {
      try {
        m_controlNet = new ControlNet(m_fileName);
        if (m_project) {
          m_controlNet->SetMutex(m_project->mutex());
        }
        m_modified = false;
 
      }
      catch (IException &e) {
        throw IException(e, IException::Programmer, "Error opening control net.", _FILEINFO_);
      }
    }
  }
 
 
  bool Control::write() {
 
    if (!m_controlNet) {
      return false;
    }
 
    try {
      m_controlNet->Write(fileName());
    }
    catch (IException &e) {
      throw IException(e, IException::Programmer, "Cannot write control net.", _FILEINFO_);
    }
 
    m_modified = false;
    return true;
  }
 
 
  void Control::closeControlNet() {
    if (m_controlNet) {
      delete m_controlNet;
      m_controlNet = NULL;
    }
    m_modified = false;
  }
 
 
  bool Control::isModified() {
    return m_modified;
  }
 
 
  void Control::setModified(bool modified) {
 
    m_modified = modified;
  }
 
 
  ControlDisplayProperties *Control::displayProperties() {
    return m_displayProperties;
  }
 
 
  const ControlDisplayProperties *Control::displayProperties() const {
    return m_displayProperties;
  }
 
 
  QString Control::fileName() const {
    return m_fileName;
  }
 
 
  QString Control::id() const {
    return m_id->toString().remove(QRegExp("[{}]"));
  }
 
 
  void Control::copyToNewProjectRoot(const Project *project, FileName newProjectRoot) {
 
    if (FileName(newProjectRoot).toString() != FileName(project->projectRoot()).toString()) {
 
      QString newNetworkPath =  project->cnetRoot(newProjectRoot.toString()) + "/" +
                  FileName(m_fileName).dir().dirName() + "/" + FileName(m_fileName).name();
 
      // If there is active control & it has been modified, write to disk instead of copying
      //  Leave control net at old location in unmodified state
      if (isModified()) {
        controlNet()->Write(newNetworkPath);
        setModified(false);
      }
      else {
        QString oldNetworkPath = project->cnetRoot(project->projectRoot()) + "/" +
                    FileName(m_fileName).dir().dirName() + "/" + FileName(m_fileName).name();
        if (!QFile::copy(oldNetworkPath,newNetworkPath) ) {
          throw IException(IException::Io, "Error saving control net.", _FILEINFO_);
        }
      }
    }
    //   Project "Save" to current location, if active control exists & is modified, write to disk
    //  Note:  It does not look like this code is ever executed.  If project is saved with a
    //         "Save" this method is not called.
    else {
      if (isModified()) {
        write();
        setModified(false);
      }
    }
 
  }
 
 
  void Control::deleteFromDisk() {
 
    if (!QFile::remove(m_fileName)) {
      throw IException(IException::Io,
                       tr("Could not remove file [%1]").arg(m_fileName),
                       _FILEINFO_);
    }
 
    // If we're the last thing in the folder, remove the folder too.
    QDir dir;
    dir.rmdir(FileName(m_fileName).path());
    m_modified = false;
  }
 
 
  void Control::updateFileName(Project *project) {
    closeControlNet();
 
    FileName original(m_fileName);
    FileName newName(project->cnetRoot() + "/" +
                     original.dir().dirName() + "/" + original.name());
    m_fileName = newName.expanded();
  }
 
 
  void Control::save(QXmlStreamWriter &stream, const Project *project,
                     FileName newProjectRoot) const {
    stream.writeStartElement("controlNet");
    stream.writeAttribute("id", m_id->toString());
    //  Change filename to new path
    stream.writeAttribute("fileName", FileName(m_fileName).name());
 
    m_displayProperties->save(stream, project, newProjectRoot);
 
    stream.writeEndElement();
  }
 
 
  Control::XmlHandler::XmlHandler(Control *control, FileName cnetFolder) {
    m_xmlHandlerControl = control;
    m_xmlHandlerCnetFolderName = cnetFolder;
  }
 
 
  bool Control::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                         const QString &qName, const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "controlNet") {
        QString id = atts.value("id");
        QString path = atts.value("path");
        QString fileName = atts.value("fileName");
 
        if (!id.isEmpty()) {
          delete m_xmlHandlerControl->m_id;
          m_xmlHandlerControl->m_id = NULL;
          m_xmlHandlerControl->m_id = new QUuid(id.toLatin1());
        }
 
        if (!fileName.isEmpty()) {
          m_xmlHandlerControl->m_fileName = m_xmlHandlerCnetFolderName.expanded() + "/" + fileName;
        }
      }
      else if (localName == "displayProperties") {
        m_xmlHandlerControl->m_displayProperties = new ControlDisplayProperties(reader());
      }
    }
 
    return true;
  }
}