Object/Developer/_work_order_8h_source.html

#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