ImportControlNetWorkOrder.cpp

Go to the documentation of this file.

#include "ImportControlNetWorkOrder.h"

#include <QDebug>
#include <QFileDialog>
#include <QFileInfo>
#include <QMessageBox>
#include <QtConcurrentMap>

#include "Control.h"
#include "ControlList.h"
#include "ControlNet.h"
#include "IException.h"
#include "Progress.h"
#include "Project.h"
#include "ProjectItem.h"
#include "ProjectItemModel.h"

namespace Isis {

  ImportControlNetWorkOrder::ImportControlNetWorkOrder(Project *project) :
      WorkOrder(project) {

    // This is an asynchronous workorder
    m_isSynchronous = false;
    m_list = NULL;
    m_watcher = NULL;
    m_isUndoable = false;

    QAction::setText(tr("Import &Control Networks..."));

    setModifiesDiskState(true);

    m_watcher = new QFutureWatcher<Control *>;
    connect(m_watcher, SIGNAL(resultReadyAt(int)), this, SLOT(cnetReady(int)));
  }


  ImportControlNetWorkOrder::ImportControlNetWorkOrder(const ImportControlNetWorkOrder &other) :
      WorkOrder(other) {
    m_watcher = NULL;
    m_watcher = new QFutureWatcher<Control *>;
    connect(m_watcher, SIGNAL(resultReadyAt(int)), this, SLOT(cnetReady(int)));
  }


  ImportControlNetWorkOrder::~ImportControlNetWorkOrder() {
    delete m_watcher;
    m_watcher = NULL;
  }


  ImportControlNetWorkOrder *ImportControlNetWorkOrder::clone() const {
    return new ImportControlNetWorkOrder(*this);
  }


  bool ImportControlNetWorkOrder::isExecutable(ProjectItem *item) {

    if (item) {
      return (item->text() == "Control Networks");
    }
    return false;
  }


  bool ImportControlNetWorkOrder::setupExecution() {
    QUndoCommand::setText(tr("Import Control Networks"));

    WorkOrder::setupExecution();

    QStringList cnetFileNames = QFileDialog::getOpenFileNames(
        qobject_cast<QWidget *>(parent()),
        tr("Import Control Networks"), "",
        tr("Isis control nets (*.net);;All Files (*)"));

    if (!cnetFileNames.isEmpty()) {
      QUndoCommand::setText(tr("Import %1 Control Networks").arg(cnetFileNames.count()));
    }

    setInternalData(cnetFileNames);

    return internalData().count() > 0;
  }

  void ImportControlNetWorkOrder::execute() {
    QDir cnetFolder = project()->addCnetFolder("controlNetworks");

    QStringList cnetFileNames = internalData();

    QList< QPair<FileName, Progress *> > cnetFileNamesAndProgress;
    foreach (FileName fileName, cnetFileNames) {
      Progress *readProgress = new Progress;
      cnetFileNamesAndProgress.append(qMakePair(fileName, readProgress));
      readProgress->DisableAutomaticDisplay();
      m_readProgresses.append(readProgress);
    }

    CreateControlsFunctor functor(project(), cnetFolder);
    m_watcher->setFuture(QtConcurrent::mapped(cnetFileNamesAndProgress,
                                              functor));

    while (!m_watcher->isFinished()) {
      setProgressRange(0, 100 * m_readProgresses.count());
      int totalProgress = 0;

      for (int i = 0; i < m_readProgresses.count(); i++) {
        Progress *progress = m_readProgresses[i];

        if (m_watcher->future().isResultReadyAt(i)) {
          totalProgress += 100;
        }
        else if (progress->MaximumSteps() > 0) {
          double progressPercent = progress->CurrentStep() / (double)progress->MaximumSteps();
          //  Estimating the Read is 90% and Write 10% (ish)
          totalProgress += qRound(progressPercent * 90);
        }
      }

      setProgressValue(totalProgress);

      m_warning = functor.errors().toString();

      QThread::yieldCurrentThread();
    }
  }

  void ImportControlNetWorkOrder::postExecution() {

    if (m_warning != "") {
      project()->warn(m_warning);
    }

    foreach (Progress *progress, m_readProgresses) {
      delete progress;
    }
    m_status = WorkOrderFinished;
    m_readProgresses.clear();

    // If one control network was imported, no active control has been set, and no
    // other control networks exist in the project, then activeControl() will set
    // the active control to the newly imported control network.
    project()->activeControl();
  }

  ImportControlNetWorkOrder::CreateControlsFunctor::CreateControlsFunctor(
    Project *project, QDir destinationFolder) : m_errors(new IException) {
    m_project = project;
    m_destinationFolder = destinationFolder;
  }


  IException ImportControlNetWorkOrder::CreateControlsFunctor::errors() const {
    IException result;

    result.append(*m_errors);

    return result;
  }


  Control *ImportControlNetWorkOrder::CreateControlsFunctor::operator()(
    const QPair<FileName, Progress *> &cnetFileNameAndProgress) {

    Control *control = NULL;
    try {
      QString cnetFileName = cnetFileNameAndProgress.first.original();
      ControlNet *cnet = new ControlNet();
      cnet->SetMutex(m_project->mutex());
      cnet->ReadControl(cnetFileName, cnetFileNameAndProgress.second);

      QString baseFilename = FileName(cnetFileName).name();
      QString destination = m_destinationFolder.canonicalPath() + "/" + baseFilename;

      cnet->Write(destination);

      delete cnet;
      cnet = NULL;

      control = new Control(m_project, destination);
      control->closeControlNet();
    }
    catch (IException &e) {
      m_errors->append(e);
      return NULL;
    }
    return control;
  }


  void ImportControlNetWorkOrder::cnetReady(int ready) {
    QMutexLocker locker(project()->workOrderMutex());
    Control *control = m_watcher->resultAt(ready);

    if (control) {
      project()->addControl(control);
      m_list = project()->controls().last();
      project()->setClean(false);
    }
    else {
      m_list = NULL;
    }
  }
}