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(Project *project) : {…}
 

  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(const ImportControlNetWorkOrder &other) : {…}
 

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

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

  bool ImportControlNetWorkOrder::isExecutable(ProjectItem *item) {
 
    if (item) {
      return (item->text() == "Control Networks");
    }
    return false;
  }
  bool ImportControlNetWorkOrder::isExecutable(ProjectItem *item) {…}
 

  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;
  }
  bool ImportControlNetWorkOrder::setupExecution() {…}

  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::execute() {…}

  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();
  }
  void ImportControlNetWorkOrder::postExecution() {…}

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

  IException ImportControlNetWorkOrder::CreateControlsFunctor::errors() const {
    IException result;
 
    result.append(*m_errors);
 
    return result;
  }
  IException ImportControlNetWorkOrder::CreateControlsFunctor::errors() const  {…}
 

  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;
  }
  Control *ImportControlNetWorkOrder::CreateControlsFunctor::operator()( {…}
 

  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;
    }
  }
  void ImportControlNetWorkOrder::cnetReady(int ready) {…}
}