WorkOrder.h

Go to the documentation of this file.

#ifndef WorkOrder_H
#define WorkOrder_H
 
/* SPDX-License-Identifier: CC0-1.0 */
 
 
#include <QAction>
#include <QDateTime>
// This is needed for the QVariant macro
#include <QMetaType>
#include <QPointer>
#include <QUndoCommand>
 
 
 
#include "CorrelationMatrix.h"
#include "FileItem.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 Template;
  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(Template *currentTemplate);
      virtual bool isExecutable(GuiCameraQsp guiCamera);
      virtual bool isExecutable(FileItemQsp fileItem);
      virtual bool isExecutable(ProjectItem *item);
 
      void read(XmlStackedHandlerReader *xmlReader);
      void save(QXmlStreamWriter &stream) const;
 
      virtual void setData(Context);
      virtual void setData(QString data);
      virtual void setData(ImageList *images);
      virtual void setData(ShapeList *shapes);
      virtual void setData(ControlList *controls);
      virtual void setData(Template *currentTemplate);
      virtual void setData(CorrelationMatrix);
      virtual void setData(TargetBodyQsp targetBody);
      virtual void setData(GuiCameraQsp guiCamera);
      virtual void setData(FileItemQsp fileItem);
      virtual void setData(ProjectItem *item);
 
 
 
      void setNext(WorkOrder *nextWorkOrder);
      void setPrevious(WorkOrder *previousWorkOrder);
 
      QString bestText() const;
      bool isUndoable() const;
      bool isSavedToHistory() const;
      bool isSynchronous() 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:
      void enableWorkOrder();
      void disableWorkOrder();
 
      virtual bool setupExecution();
 
      virtual void 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();
 
      Template *getTemplate();
 
      TargetBodyQsp targetBody();
 
      GuiCameraQsp guiCamera();
 
      FileItemQsp fileItem();
 
      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 postExecution();
      virtual void undoExecution();
      virtual void postUndoExecution();
 
    protected slots:
      void addCloneToProject();
 
    private:
      bool isInStableState() const;
      void listenForImageDestruction();
      void listenForShapeDestruction();
      void resetProgressBar();
      void setProgressToFinalText();
 
    private slots:
      void attemptQueuedAction();
      void executionFinished();
      void clearImageList();
      void clearShapeList();
      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;
      };
 
    protected:
      bool m_isUndoable;
 
       bool m_isSynchronous;
 
       bool m_isSavedToHistory;
 
       WorkOrderStatus m_status;
 
    private:
      WorkOrder &operator=(const WorkOrder &rhs);
 
      bool m_createsCleanState;
 
      bool m_modifiesDiskState;
 
      QueuedWorkOrderAction m_queuedAction;
 
      int m_progressRangeMinValue;
      int m_progressRangeMaxValue;
      int m_progressValue;
 
      Context m_context;
      QString m_data;
      QPointer<ImageList> m_imageList;
      QPointer<ShapeList> m_shapeList;
      QPointer<ControlList> m_controlList;
      CorrelationMatrix m_correlationMatrix;
      GuiCameraQsp m_guiCamera;
 
 
      Template *m_template;
 
 
      TargetBodyQsp m_targetBody;
 
 
      FileItemQsp m_fileItem;
 
 
      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