WorkOrder.cpp

Go to the documentation of this file.

#include "IsisDebug.h"

#include "WorkOrder.h"

#include <QDebug>
#include <QFutureWatcher>
#include <QMutex>
#include <QMutexLocker>
#include <QtConcurrentRun>
#include <QTimer>
#include <QXmlStreamWriter>

#include "ControlList.h"
#include "IException.h"
#include "ImageList.h"
#include "IString.h"
#include "ProgressBar.h"
#include "Project.h"
#include "ProjectItem.h"
#include "ShapeList.h"
#include "Template.h"
#include "XmlStackedHandlerReader.h"


namespace Isis {
  WorkOrder::WorkOrder(Project *project) : QAction(project) {
    m_project = project;

    m_context = NoContext;
    m_data = "";
    m_imageList = new ImageList;
    m_shapeList = new ShapeList;
    m_controlList = NULL;
    m_correlationMatrix = CorrelationMatrix();
    m_guiCamera = GuiCameraQsp();
    m_targetBody = TargetBodyQsp();
    m_template = NULL;
    m_fileItem = FileItemQsp();

    m_isUndoable = true;
    m_isSavedToHistory = true;
    m_isSynchronous = true;

    m_createsCleanState = false;
    m_modifiesDiskState = false;
    m_status = WorkOrderNotStarted;
    m_queuedAction = NoQueuedAction;
    m_transparentConstMutex = NULL;
    m_elapsedTimer = NULL;

    m_futureWatcher = new QFutureWatcher<void>;
    m_transparentConstMutex = new QMutex;

    m_progressRangeMinValue = 0;
    m_progressRangeMaxValue = 100;
    m_progressValue = 0;

    m_secondsElapsed = 0.0;

    if (!m_project) {
        throw IException(IException::Programmer,
            tr("Work orders cannot be created without a project."), _FILEINFO_);
    }

    connect(this, SIGNAL(triggered()),
            this, SLOT(addCloneToProject()));
    connect(m_futureWatcher, SIGNAL(finished()),
            this, SLOT(executionFinished()));
  }


  WorkOrder::WorkOrder(const WorkOrder &other) :
      QAction(other.icon(), ((QAction &)other).text(), other.parentWidget()),
      QUndoCommand(((QUndoCommand &)other).text()) {
    // Copy the action's what's this and tool tip (hover text).
    QAction::setWhatsThis(other.whatsThis());
    QAction::setToolTip(other.toolTip());

    m_transparentConstMutex = NULL;
    m_elapsedTimer = NULL;
    m_project = other.project();
    m_context = other.m_context;
    m_imageIds = other.m_imageIds;
    m_imageList = new ImageList(*other.m_imageList);
    m_shapeIds = other.m_shapeIds;
    m_shapeList = new ShapeList(*other.m_shapeList);
    m_correlationMatrix = other.m_correlationMatrix;
    m_controlList = other.m_controlList;
    m_guiCamera = other.m_guiCamera;
    m_targetBody = other.m_targetBody;
    m_fileItem = other.m_fileItem;
    m_internalData = other.m_internalData;
    m_template = other.m_template;

    m_isUndoable = other.m_isUndoable;
    m_isSavedToHistory = other.m_isSavedToHistory;
    m_isSynchronous = other.m_isSynchronous;

    m_createsCleanState = other.m_createsCleanState;
    m_modifiesDiskState = other.m_modifiesDiskState;

    m_executionTime = other.m_executionTime;

    m_status = other.m_status;
    m_queuedAction = other.m_queuedAction;

    m_secondsElapsed = other.m_secondsElapsed;

    m_progressRangeMinValue = other.m_progressRangeMinValue;
    m_progressRangeMaxValue = other.m_progressRangeMaxValue;
    m_progressValue = other.m_progressValue;

    m_futureWatcher = new QFutureWatcher<void>;
    m_transparentConstMutex = new QMutex;

    if (!other.isInStableState()) {
      throw IException(IException::Unknown,
          tr("Can not copy work order [%1] because it is currently running")
            .arg(((QUndoCommand &)other).text()),
          _FILEINFO_);
    }

    connect(this, SIGNAL(triggered()),
            this, SLOT(addCloneToProject()));
    connect(m_futureWatcher, SIGNAL(finished()),
            this, SLOT(executionFinished()));

    listenForImageDestruction();
    listenForShapeDestruction();
  }


  WorkOrder::~WorkOrder() {

    delete m_imageList;
    delete m_shapeList;
    delete m_futureWatcher;
    delete m_progressBarDeletionTimer;
    delete m_progressBarUpdateTimer;
    delete m_transparentConstMutex;

    m_nextWorkOrder = NULL;
    m_previousWorkOrder = NULL;
    m_project = NULL;
    m_transparentConstMutex = NULL;
  }


  bool WorkOrder::isExecutable(Context context) {
    return false;
  }


  bool WorkOrder::isExecutable(ImageList *images) {
    return false;
  }


  bool WorkOrder::isExecutable(ShapeList *shapes) {
    return false;
  }


//bool WorkOrder::isExecutable(Control *control) {
//  return false;
//}


  bool WorkOrder::isExecutable(ControlList *controls) {
    return false;
  }


  bool WorkOrder::isExecutable(CorrelationMatrix correlationMatrix) {
    return false;
  }


  void WorkOrder::setData(Context context) {
    m_context = context;
  }

  void WorkOrder::setData(QString data) {
    m_data = data;
  }


  void WorkOrder::setData(ImageList *images) {
    m_imageIds.clear();
    delete m_imageList;

    m_imageList = new ImageList(*images);
    listenForImageDestruction();
  }


  void WorkOrder::setData(ShapeList *shapes) {
    m_shapeIds.clear();
    delete m_shapeList;

    m_shapeList = new ShapeList(*shapes);
    listenForShapeDestruction();
  }


//void WorkOrder::setData(Control *control) {
//  m_control = control;
//}


  void WorkOrder::setData(ControlList *controls) {
    m_controlList = controls;
  }


  void WorkOrder::setData(CorrelationMatrix correlationMatrix) {
    m_correlationMatrix = correlationMatrix;
  }




  void WorkOrder::setData(TargetBodyQsp targetBody) {
    m_targetBody = targetBody;
  }


  void WorkOrder::setData(Template *currentTemplate) {
    m_template = currentTemplate;
  }


  void WorkOrder::setData(GuiCameraQsp guiCamera) {
    m_guiCamera = guiCamera;
  }


  void WorkOrder::setData(FileItemQsp fileItem) {
    m_fileItem = fileItem;
  }


  void WorkOrder::setData(ProjectItem *item) {
    if ( item->isProject() ) {
      setData( ProjectContext );
    }
    else if ( item->isImageList() ) {
      setData( item->imageList() );
    }
    else if ( item->isImage() ) {
      ImageList *imageList = new ImageList(this);
      imageList->append( item->image() );
      setData(imageList);
    }
    else if ( item->isShapeList() ) {
      setData( item->shapeList() );
    }
    else if ( item->isShape() ) {
      ShapeList *shapeList = new ShapeList(this);
      shapeList->append( item->shape() );
      setData(shapeList);
    }
    else if (item->isControlList()) {
      setData( item->controlList() );
    }
    else if ( item->isControl() ) {
      ControlList *controlList = new ControlList(this);
      controlList->append( item->control() );
      setData(controlList);
//    //setData(*controlList);
    }
    else if ( item->isCorrelationMatrix() ) {
      setData( item->correlationMatrix() );
    }
    else if ( item->isTargetBody() ) {
      setData( item->targetBody() );
    }
    else if ( item->isGuiCamera() ) {
      setData( item->guiCamera() );
    }
    else if ( item->isFileItem() ) {
      setData( item->fileItem() );
    }
    else if ( item->isTemplate() ) {
      setData( item->getTemplate() );
    }
  }





  bool WorkOrder::isExecutable(TargetBodyQsp targetBody) {
    return false;
  }


  bool WorkOrder::isExecutable(Template *currentTemplate) {
    return false;
  }


  bool WorkOrder::isExecutable(GuiCameraQsp guiCamera) {
    return false;
  }


  bool WorkOrder::isExecutable(FileItemQsp fileItem) {
    return false;
  }


  bool WorkOrder::isExecutable(ProjectItem *item) {
    if ( !item ) {
      return false;
    }
    else if ( item->isProject() ) {
      return isExecutable( ProjectContext );
    }
    else if ( item->isImageList() ) {
      return isExecutable( item->imageList() );
    }
    else if ( item->isImage() ) {
      ImageList *imageList = new ImageList();
      imageList->append( item->image() );
      bool ret = isExecutable(imageList);
      imageList->deleteLater();
      return ret;
    }
    else if ( item->isShapeList() ) {
      return isExecutable( item->shapeList() );
    }
    else if ( item->isShape() ) {
      ShapeList *shapeList = new ShapeList();
      shapeList->append( item->shape() );
      bool ret = isExecutable(shapeList);
      shapeList->deleteLater();
      return ret;
    }
    else if ( item->isControlList() ) {
      return isExecutable (item -> controlList() );
    }
    else if ( item->isControl() ) {
      ControlList *controlList = new ControlList();
      controlList->append( item->control() );
      bool ret = isExecutable(controlList);
      controlList->deleteLater();
      return ret;
    }
    else if ( item->isCorrelationMatrix() ) {
      return isExecutable( item->correlationMatrix() );
    }
    else if ( item->isTargetBody() ) {
      //return isExecutable( item->targetBody() ) || isExecutable( item->targetBody().data() );
        return isExecutable(item->targetBody());
    }
    else if ( item->isGuiCamera() ) {
      //return isExecutable( item->guiCamera() ) || isExecutable( item->guiCamera().data() );
      return isExecutable( item->guiCamera() );
    }
    else if ( item->isFileItem() ) {
      return isExecutable( item->fileItem() );
    }
    else if ( item->isTemplate() ) {
      return isExecutable( item->getTemplate() );
    }

    return false;
  }


  void WorkOrder::read(XmlStackedHandlerReader *xmlReader) {
    xmlReader->pushContentHandler(new XmlHandler(this));
  }


  void WorkOrder::save(QXmlStreamWriter &stream) const {
    if (!isInStableState()) {
      throw IException(IException::Programmer,
                       tr("Can not store an unstable work order. The work order [%1] is currently "
                          "working").arg(bestText()),
                       _FILEINFO_);
    }

    stream.writeStartElement("workOrder");

    stream.writeAttribute("actionText", QAction::text());
    stream.writeAttribute("undoText", QUndoCommand::text());
    stream.writeAttribute("executionTime", m_executionTime.toString());
    stream.writeAttribute("type", metaObject()->className());
    stream.writeAttribute("status", toString(m_status));

    if (m_imageIds.count()) {
      stream.writeStartElement("images");

      foreach (QString imageId, m_imageIds) {
        stream.writeStartElement("image");
        stream.writeAttribute("id", imageId);
        stream.writeEndElement();
      }

      stream.writeEndElement();
    }

    if (m_shapeIds.count()) {
      stream.writeStartElement("shapes");

      foreach (QString shapeId, m_shapeIds) {
        stream.writeStartElement("shape");
        stream.writeAttribute("id", shapeId);
        stream.writeEndElement();
      }

      stream.writeEndElement();
    }

    if (m_internalData.count()) {
      stream.writeStartElement("internalDataValues");

      foreach (QString str, m_internalData) {
        stream.writeStartElement("dataValue");
        stream.writeAttribute("value", str);
        stream.writeEndElement();
      }

      stream.writeEndElement();
    }

    if (m_context != NoContext) {
      stream.writeStartElement("context");

      QString contextStr = "ProjectContext";
      stream.writeAttribute("value", contextStr);

      stream.writeEndElement();
    }

    stream.writeEndElement();
  }


  void WorkOrder::setNext(WorkOrder *nextWorkOrder) {
    m_nextWorkOrder = nextWorkOrder;
  }


  void WorkOrder::setPrevious(WorkOrder *previousWorkOrder) {
    m_previousWorkOrder = previousWorkOrder;
  }


  ImageList *WorkOrder::imageList() {
    QMutexLocker locker(project()->workOrderMutex());
    if (!m_imageList) {
      bool anyImagesAreNull = false;

      m_imageList = new ImageList;

      foreach (QString id, m_imageIds) {
        Image *image = project()->image(id);
        m_imageList->append(image);

        if (!image) {
          anyImagesAreNull = true;
        }
      }

      if (anyImagesAreNull) {
        delete m_imageList;
      }
      else {
        listenForImageDestruction();
      }
    }

    return m_imageList;
  }


  ShapeList *WorkOrder::shapeList() {
    QMutexLocker locker(project()->workOrderMutex());
    if (!m_shapeList) {
      bool anyShapesAreNull = false;

      m_shapeList = new ShapeList;

      foreach (QString id, m_shapeIds) {
        Shape *shape = project()->shape(id);
        m_shapeList->append(shape);

        if (!shape) {
          anyShapesAreNull = true;
        }
      }

      if (anyShapesAreNull) {
        delete m_shapeList;
      }
      else {
        listenForShapeDestruction();
      }
    }

    return
      m_shapeList;
  }


  CorrelationMatrix WorkOrder::correlationMatrix() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_correlationMatrix;
  }


  QPointer<ControlList> WorkOrder::controlList() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_controlList;
  }


  const ImageList *WorkOrder::imageList() const {
    QMutexLocker lock(m_transparentConstMutex);
    return const_cast<WorkOrder *>(this)->imageList();
  }


  const ShapeList *WorkOrder::shapeList() const {
    QMutexLocker lock(m_transparentConstMutex);
    return const_cast<WorkOrder *>(this)->shapeList();
  }


  Template *WorkOrder::getTemplate() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_template;
  }


  TargetBodyQsp WorkOrder::targetBody() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_targetBody;
  }


  GuiCameraQsp WorkOrder::guiCamera() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_guiCamera;
  }


  FileItemQsp WorkOrder::fileItem() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_fileItem;
  }


  bool WorkOrder::dependsOn(WorkOrder *) const {
    return true;
  }


  QString WorkOrder::bestText() const {
    QString result = QUndoCommand::text().remove("&").remove("...");

    // if the QUndoCommand has no text, create a warning
    if (result.isEmpty()) {
      // get the name of the work order
      result = QString(metaObject()->className()).remove("Isis::").remove("WorkOrder")
                   .replace(QRegExp("([a-z0-9])([A-Z])"), "\\1 \\2");
      qWarning() << QString("WorkOrder::bestText(): Work order [%1] has no QUndoCommand text")
                    .arg(result);
    }

    return result;
  }


  bool WorkOrder::isUndoable() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_isUndoable;
  }


  bool WorkOrder::isSavedToHistory() const {
     QMutexLocker locker(project()->workOrderMutex());
     return m_isSavedToHistory;
  }


  bool WorkOrder::isSynchronous() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_isSynchronous;
  }


  bool WorkOrder::createsCleanState() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_createsCleanState;
  }


  QDateTime WorkOrder::executionTime() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_executionTime;
  }


  bool WorkOrder::isFinished() const {
    return m_status == WorkOrderFinished;
  }


  bool WorkOrder::isRedoing() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_status == WorkOrderRedoing;
  }


  bool WorkOrder::isRedone() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_status == WorkOrderRedone;
  }


  bool WorkOrder::isUndoing() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_status == WorkOrderUndoing;
  }


  bool WorkOrder::isUndone() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_status == WorkOrderUndone;
  }


  bool WorkOrder::modifiesDiskState() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_modifiesDiskState;
  }


  WorkOrder *WorkOrder::next() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_nextWorkOrder;
  }


  WorkOrder *WorkOrder::previous() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_previousWorkOrder;
  }


  QString WorkOrder::statusText() const {
    QMutexLocker locker(project()->workOrderMutex());
    QString result = toString(m_status);

    if (m_secondsElapsed) {
      // QTime can't format in the way that I want (0-n minutes, 00-59 seconds, no hours
      //   displayed)... so do it manually.
      // Expected output format examples: 0:01, 0:55, 1:30, 55:55, 90:00, 100:12
      int seconds = qRound(m_secondsElapsed) % 60;
      int minutes = qRound(m_secondsElapsed) / 60;
      result += tr(" (elapsed: %1:%2)").arg(minutes).arg(seconds, 2, 10, QChar('0'));
    }

    return result;
  }


  ProgressBar *WorkOrder::progressBar() {
    QMutexLocker locker(project()->workOrderMutex());
    return m_progressBar;
  }


  WorkOrder::WorkOrderStatus WorkOrder::fromStatusString(QString statusString) {
    statusString = statusString.toUpper();
    WorkOrderStatus result = WorkOrderUnknownStatus;

    for (WorkOrderStatus possibleResult = WorkOrderUnknownStatus;
         possibleResult <= WorkOrderLastStatus;
         possibleResult = (WorkOrderStatus)(possibleResult + 1)) {
      if (statusString == toString(possibleResult).toUpper()) {
        result = possibleResult;
      }
    }

    return result;
  }


  QString WorkOrder::toString(WorkOrderStatus status) {
    QString result;

    switch (status) {
      case WorkOrderUnknownStatus:
        result = tr("Unknown");
        break;
      case WorkOrderNotStarted:
        result = tr("Not Started");
        break;
      case WorkOrderRedoing:
        result = tr("In Progress");
        break;
      case WorkOrderRedone:
        result = tr("Completed");
        break;
      case WorkOrderUndoing:
        result = tr("Undoing");
        break;
      case WorkOrderUndone:
        result = tr("Undone");
        break;
      case WorkOrderFinished:
        result = tr("Finished");
        break;
    }

    return result;
  }


  void WorkOrder::redo() {
    if (!isInStableState()) {
      m_queuedAction = RedoQueuedAction;
    }

    if (!isRedone()) {
      bool mustQueueThisRedo = false;

      WorkOrder *dependency = NULL;
      WorkOrder *current = this;
      while (current->previous() && !dependency) {
        if (!current->previous()->isRedone() && !current->previous()->isFinished()) {
          WorkOrder *possibleDependency = current->previous();

          if (dependsOn(possibleDependency)) {
            connect(possibleDependency, SIGNAL(finished(WorkOrder *)),
                    this, SLOT(attemptQueuedAction()));
            dependency = possibleDependency;
            mustQueueThisRedo = true;
          }
        }

        current = current->previous();
      }

      if (!imageList()) {
        connect(project(), SIGNAL(imagesAdded(ImageList *)),
                this, SLOT(attemptQueuedAction()));
        mustQueueThisRedo = true;
      }

      if (!shapeList()) {
        connect(project(), SIGNAL(shapesAdded(ShapeList *)),
                this, SLOT(attemptQueuedAction()));
        mustQueueThisRedo = true;
      }

      if (mustQueueThisRedo && !isUndoing() && !isRedoing()) {

        m_queuedAction = RedoQueuedAction;

        QString queueStatusText;

        if (dependency) {
          QString dependencyText = dependency->bestText();

          if (dependencyText.count() > 5) {
            dependencyText = dependencyText.mid(0, 5) + "...";
          }

          queueStatusText = tr("Wait for [%1]").arg(dependencyText);
        }
        else if (!imageList()) {
          queueStatusText = tr("Wait for images");
        }
        else if (!shapeList()) {
          queueStatusText = tr("Wait for shapes");
        }

        resetProgressBar();
        m_progressBar->setValue(m_progressBar->minimum());
        m_progressBar->setText(queueStatusText);
        m_progressBar->update();
      }

      if (m_queuedAction == NoQueuedAction) {
        m_status = WorkOrderRedoing;
        emit statusChanged(this);

        resetProgressBar();
        m_progressBar->setText("Starting...");
        m_progressBar->update();

        delete m_elapsedTimer;
        m_elapsedTimer = new QTime;
        m_elapsedTimer->start();

        if (isSynchronous()) {
          execute();
          executionFinished();
        }
        else {
          m_progressBar->setText("Running...");
          m_progressBar->update();
          // queue the workorder for asynchronous execution
          QFuture<void> future = QtConcurrent::run(this, &WorkOrder::execute);
          // executionFinished() is called via the finished signal.  The
          // connection is setup in the constructor.
          m_futureWatcher->setFuture(future);
        }
      }
    }
    else {
      setProgressToFinalText();
    }
  }


  void WorkOrder::undo() {
    if (!isInStableState()) {
      m_queuedAction = UndoQueuedAction;
    }

    if (!isUndone() && m_status != WorkOrderNotStarted) {
      WorkOrder *dependency = NULL;
      WorkOrder *current = this;
      while (current->next() && !dependency) {
        if (!current->next()->isUndone() && !current->next()->isFinished() &&
            current->next()->m_status != WorkOrderNotStarted) {
          connect(current->next(), SIGNAL(finished(WorkOrder *)),
                  this, SLOT(attemptQueuedAction()));
          m_queuedAction = UndoQueuedAction;
          dependency = current->next();
        }

        current = current->next();
      }

      if (dependency && !isUndoing() && !isRedoing()) {
        QString prevText = dependency->bestText();

        if (prevText.count() > 5) {
          prevText = prevText.mid(0, 5) + "...";
        }

        resetProgressBar();
        m_progressBar->setValue(m_progressBar->minimum());
        m_progressBar->setText(tr("Undo after [%1]").arg(prevText));
        m_progressBar->update();
      }

      if (m_queuedAction == NoQueuedAction) {
        m_status = WorkOrderUndoing;
        emit statusChanged(this);

        resetProgressBar();
        m_progressBar->setText("Starting Undo...");
        m_progressBar->update();

        delete m_elapsedTimer;
        m_elapsedTimer = new QTime;
        m_elapsedTimer->start();

        if (isSynchronous()) {
          undoExecution();
          executionFinished();
        }
        else {
          m_progressBar->setText("Undoing...");
          m_progressBar->update();
          // queue the workorder for asynchronous execution
          QFuture<void> future = QtConcurrent::run(this, &WorkOrder::undoExecution);
          // executionFinished() is called via the finished signal.  The
          // connection is setup in the constructor.
          m_futureWatcher->setFuture(future);
        }
      }
    }
    else {
      setProgressToFinalText();
    }
  }

  void WorkOrder::enableWorkOrder() {
    setEnabled(true);
  }


  void WorkOrder::disableWorkOrder() {
    setEnabled(false);
  }


  bool WorkOrder::setupExecution() {
    // We're finished at this point if we save/open a project, we're not finished if we need to do
    //   redo()
    if (createsCleanState() || !isUndoable()) {
      m_status = WorkOrderFinished;

      emit statusChanged(this);
    }

    m_executionTime = QDateTime::currentDateTime();

    resetProgressBar();

    if (createsCleanState()  || !isUndoable()) {
      setProgressToFinalText();
    }
    else {
      m_progressBar->setText("Initializing...");
    }

    return true;
  }


  Directory *WorkOrder::directory() const {
    return project()->directory();
  }


  Project *WorkOrder::project() const {
    if (!m_project) {
      throw IException(IException::Programmer,
          "This work order no longer has a project.", _FILEINFO_);
    }

    return m_project;
  }


  void WorkOrder::setInternalData(QStringList data) {
    m_internalData = data;
  }


  int WorkOrder::progressMin() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_progressRangeMinValue;
  }


  int WorkOrder::progressMax() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_progressRangeMaxValue;
  }


  int WorkOrder::progressValue() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_progressValue;
  }


  void WorkOrder::setProgressRange(int minValue, int maxValue) {
    m_progressRangeMinValue = minValue;
    m_progressRangeMaxValue = maxValue;
  }


  void WorkOrder::setProgressValue(int value) {
    m_progressValue = value;
  }


  QStringList WorkOrder::internalData() const {
    QMutexLocker locker(project()->workOrderMutex());
    return m_internalData;
  }


  void WorkOrder::execute() {
  }


  void WorkOrder::postExecution() {
  }


  void WorkOrder::undoExecution() {
  }


  void WorkOrder::postUndoExecution() {
  }


  void WorkOrder::addCloneToProject() {
    if (project()) {
      project()->addToProject(clone());
    }
  }


  bool WorkOrder::isInStableState() const {
    bool result = true;

    if (isRedoing() || isUndoing() || m_queuedAction != NoQueuedAction) {
      result = false;
    }

    return result;
  }


  void WorkOrder::listenForImageDestruction() {
    m_imageIds.clear();
    foreach (Image *image, *m_imageList) {
      if (image) {
        m_imageIds.append(image->id());

        // If we lose any images, destroy the entire list. This will let us know that we need to
        //   rebuild it, if needed, when requested.
        connect(image, SIGNAL(destroyed(QObject *)),
                this, SLOT(clearImageList()));
      }
    }
  }


  void WorkOrder::listenForShapeDestruction() {
    m_shapeIds.clear();
    foreach (Shape *shape, *m_shapeList) {
      if (shape) {
        m_shapeIds.append(shape->id());

        // If we lose any shapes, destroy the entire list. This will let us know that we need to
        //   rebuild it, if needed, when requested.
        connect(shape, SIGNAL(destroyed(QObject *)),
                this, SLOT(clearShapeList()));
      }
    }
  }


  void WorkOrder::resetProgressBar() {
    delete m_progressBarDeletionTimer;

    if (!m_progressBar) {
      m_progressBar = new ProgressBar;
      emit creatingProgress(this);
    }

    if (!m_progressBarUpdateTimer) {
      m_progressBarUpdateTimer = new QTimer;
      connect(m_progressBarUpdateTimer, SIGNAL(timeout()),
              this, SLOT(updateProgress()));
      m_progressBarUpdateTimer->start(100);
    }

    m_progressRangeMinValue = 0;
    m_progressRangeMaxValue = 100;
    m_progressValue = 0;
  }


  void WorkOrder::setProgressToFinalText() {
    if (m_progressBar) {
      if (isRedone()) {
        m_progressBar->setText(tr("Finished"));
      }
      else if (isUndone() || m_status == WorkOrderNotStarted) {
        m_progressBar->setText(tr("Undone"));
      }

      if (m_progressBar->minimum() != 0 || m_progressBar->maximum() != 0) {
        m_progressBar->setValue(m_progressBar->maximum());
      }
      else {
        m_progressBar->setRange(0, 100);
        m_progressBar->setValue(100);
      }

      delete m_progressBarDeletionTimer;
      m_progressBarDeletionTimer = new QTimer;
      m_progressBarDeletionTimer->setSingleShot(true);

      m_progressBarDeletionTimer->start(5 * 1000); // 5 seconds

      m_progressBar->update();
    }
  }


  void WorkOrder::attemptQueuedAction() {
    QueuedWorkOrderAction queued = m_queuedAction;
    m_queuedAction = NoQueuedAction;

    if (queued == RedoQueuedAction && m_status != WorkOrderRedone) {
      redo();
    }
    else if (queued == UndoQueuedAction && m_status != WorkOrderUndone) {
      undo();
    }
  }


  void WorkOrder::executionFinished() {
    delete m_progressBarUpdateTimer;

    WorkOrderStatus finishedStatus = WorkOrderRedone;
    void (WorkOrder::*postMethod)() = &WorkOrder::postExecution;

    if (isUndoing()) {
      finishedStatus = WorkOrderUndone;
      postMethod = &WorkOrder::postUndoExecution;
    }

    (this->*postMethod)();

    m_status = finishedStatus;

    m_secondsElapsed = m_elapsedTimer->elapsed() / 1000.0;

    delete m_elapsedTimer;
    m_elapsedTimer = NULL;

    emit statusChanged(this);
    setProgressToFinalText();
    emit finished(this);

    attemptQueuedAction();
  }


  void WorkOrder::clearImageList() {
    delete m_imageList;
  }


  void WorkOrder::clearShapeList() {
    delete m_shapeList;
  }


  void WorkOrder::updateProgress() {
    if (m_progressBar && (isRedoing() || isUndoing())) {
      m_progressBar->setRange(m_progressRangeMinValue, m_progressRangeMaxValue);
      m_progressBar->setValue(m_progressValue);
    }
  }


  void WorkOrder::startRedo() {
  }


  void WorkOrder::setCreatesCleanState(bool createsCleanState) {
    m_createsCleanState = createsCleanState;
  }


  void WorkOrder::setModifiesDiskState(bool changesProjectOnDisk) {
    m_modifiesDiskState = changesProjectOnDisk;
  }


  WorkOrder::XmlHandler::XmlHandler(WorkOrder *workOrder) {
    m_workOrder = workOrder;
  }


  bool WorkOrder::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                           const QString &qName, const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "workOrder") {
        QString actionText = atts.value("actionText");
        QString undoText = atts.value("undoText");
        QString executionTime = atts.value("executionTime");
        QString statusStr = atts.value("status");

        if (!actionText.isEmpty()) {
          ((QAction *)m_workOrder)->setText(actionText);
        }

        if (!undoText.isEmpty()) {
          ((QUndoCommand *)m_workOrder)->setText(undoText);
        }

        if (!executionTime.isEmpty()) {
          m_workOrder->m_executionTime = QDateTime::fromString(executionTime);
        }

        if (!statusStr.isEmpty()) {
          m_workOrder->m_status = fromStatusString(statusStr);
        }
        else {
          if (m_workOrder->createsCleanState()) {
            m_workOrder->m_status = WorkOrderFinished;
          }
          else {
            m_workOrder->m_status = WorkOrderRedone;
          }
        }
      }
      else if (localName == "dataValue") {
        m_workOrder->m_internalData.append(atts.value("value"));
      }
      else if (localName == "context") {
        if (atts.value("value") == "ProjectContext") {
          m_workOrder->m_context = ProjectContext;
        }
      }
    }

    return true;
  }
}