WorkOrder.h

Go to the documentation of this file.

#ifndef WorkOrder_H
#define WorkOrder_H

#include <QAction>
#include <QDateTime>
// This is needed for the QVariant macro
#include <QMetaType>
#include <QPointer>
#include <QUndoCommand>



#include "CorrelationMatrix.h"
#include "GuiCamera.h"
#include "TargetBody.h"
#include "XmlStackedHandler.h"

template<typename T> class QFutureWatcher;
class QMutex;
class QXmlStreamWriter;

namespace Isis {
  class Control;
  class ControlList;
  class Directory;
  class ImageList;
  class ProgressBar;
  class Project;
  class ProjectItem;
  class ShapeList;
  class XmlStackedHandlerReader;

  class WorkOrder : public QAction, public QUndoCommand {
    Q_OBJECT
    public:



      enum WorkOrderStatus {
        WorkOrderUnknownStatus = 0,
        WorkOrderNotStarted,
        WorkOrderRedoing,
        WorkOrderRedone,
        WorkOrderUndoing,
        WorkOrderUndone,
        WorkOrderFinished,
        WorkOrderLastStatus = WorkOrderFinished
      };

      enum Context {
        NoContext,
        ProjectContext
      };

      WorkOrder(Project *project);
      virtual ~WorkOrder();

      virtual WorkOrder *clone() const = 0;

      virtual bool isExecutable(Context);
      virtual bool isExecutable(ImageList *images);
      virtual bool isExecutable(ShapeList *shapes);
      virtual bool isExecutable(ControlList *controls);
      virtual bool isExecutable(CorrelationMatrix);
      virtual bool isExecutable(TargetBodyQsp targetBody);
      virtual bool isExecutable(GuiCameraQsp guiCamera);
      virtual bool isExecutable(ProjectItem *item);

      void read(XmlStackedHandlerReader *xmlReader);
      void save(QXmlStreamWriter &stream) const;

      virtual void setData(Context);
      virtual void setData(ImageList *images);
      virtual void setData(ShapeList *shapes);
      virtual void setData(ControlList *controls);
      virtual void setData(CorrelationMatrix);
      virtual void setData(TargetBodyQsp targetBody);
      virtual void setData(GuiCameraQsp guiCamera);
      virtual void setData(ProjectItem *item);


      void setNext(WorkOrder *nextWorkOrder);
      void setPrevious(WorkOrder *previousWorkOrder);

      QString bestText() const;
      bool createsCleanState() const;
      QDateTime executionTime() const;
      bool isFinished() const;
      bool isRedoing() const;
      bool isRedone() const;
      bool isUndoing() const;
      bool isUndone() const;
      bool modifiesDiskState() const;
      WorkOrder *next() const;
      WorkOrder *previous() const;
      QString statusText() const;

      ProgressBar *progressBar();

      static WorkOrderStatus fromStatusString(QString);
      static QString toString(WorkOrderStatus);

    signals:
      void creatingProgress(WorkOrder *);
      // This is necessary because QTreeWidget doesn't support us just deleting the progress bar..
      //   HistoryWidget relies on this signal.
      void deletingProgress(WorkOrder *);
      void finished(WorkOrder *);
      void statusChanged(WorkOrder *);

    public slots:
      virtual bool execute();

      virtual void redo();
      virtual void undo();

    protected:
      WorkOrder(const WorkOrder &other);

      ImageList *imageList();
      const ImageList *imageList() const;

      ShapeList *shapeList();
      const ShapeList *shapeList() const;

      CorrelationMatrix correlationMatrix();
      
      QPointer<ControlList> controlList();

      TargetBodyQsp targetBody();

      GuiCameraQsp guiCamera();

      virtual bool dependsOn(WorkOrder *other) const;

      Directory *directory() const;
      Project *project() const;

      void setCreatesCleanState(bool createsCleanState);
      void setModifiesDiskState(bool changesProjectOnDisk);
      void setInternalData(QStringList data);

      int progressMin() const;
      int progressMax() const;
      int progressValue() const;
      void setProgressRange(int, int);
      void setProgressValue(int);

      QStringList internalData() const;
      virtual void syncRedo();
      virtual void asyncRedo();
      virtual void postSyncRedo();
      virtual void syncUndo();
      virtual void asyncUndo();
      virtual void postSyncUndo();

    protected slots:
      void addCloneToProject();

    private:
      bool isInStableState() const;
      void listenForImageDestruction();
      void listenForShapeDestruction();
      void resetProgressBar();
      void setProgressToFinalText();

    private slots:
      void attemptQueuedAction();
      void asyncFinished();
      void clearImageList();
      void clearShapeList();
      void deleteProgress();
      void updateProgress();
      void startRedo();

    private:
      enum QueuedWorkOrderAction {
        NoQueuedAction,
        RedoQueuedAction,
        UndoQueuedAction
      };

      class XmlHandler : public XmlStackedHandler {
        public:
          XmlHandler(WorkOrder *workOrder);

          virtual bool startElement(const QString &namespaceURI, const QString &localName,
                                    const QString &qName, const QXmlAttributes &atts);

        private:
          Q_DISABLE_COPY(XmlHandler);

          WorkOrder *m_workOrder;
      };


    private:
      WorkOrder &operator=(const WorkOrder &rhs);

      bool m_createsCleanState;

      bool m_modifiesDiskState;

      WorkOrderStatus m_status;
      QueuedWorkOrderAction m_queuedAction;

      int m_progressRangeMinValue;
      int m_progressRangeMaxValue;
      int m_progressValue;

      Context m_context;
      QPointer<ImageList> m_imageList;
      QPointer<ShapeList> m_shapeList;
      QPointer<ControlList> m_controlList;
      CorrelationMatrix m_correlationMatrix;
      GuiCameraQsp m_guiCamera;


      TargetBodyQsp m_targetBody;


      QStringList m_imageIds;

      QStringList m_shapeIds;

      QStringList m_internalData;

      QPointer<WorkOrder> m_nextWorkOrder;

      QPointer<WorkOrder> m_previousWorkOrder;

      QPointer<Project> m_project;

      QMutex *m_transparentConstMutex;

      QDateTime m_executionTime;

      QPointer< QFutureWatcher<void> > m_futureWatcher;



      QPointer<ProgressBar> m_progressBar;

      QPointer<QTimer> m_progressBarUpdateTimer;

      QPointer<QTimer> m_progressBarDeletionTimer;


      QTime *m_elapsedTimer;

      double m_secondsElapsed;
  };
}

Q_DECLARE_METATYPE(Isis::WorkOrder *);

#endif