Project.h

Go to the documentation of this file.

#ifndef Project_H
#define Project_H

#include <QDir>
#include <QObject>
#include <QPointer>
#include <QStringList>
#include <QUndoStack>
#include <QXmlDefaultHandler>

class QMutex;
class QProgressBar;
class QXmlAttributes;
class QXmlStreamWriter;

#include "ControlList.h"
#include "Directory.h"
#include "GuiCameraList.h"
#include "ImageList.h"
#include "ShapeList.h"
#include "TargetBody.h"
#include "TemplateList.h"
#include "XmlStackedHandler.h"

namespace Isis {
  class BundleSolutionInfo;
  class BundleSettings;
  class Control;
  class ControlList;
  class CorrelationMatrix;
  class FileName;
  class Shape;
  class ImageReader;
  class ProgressBar;
  class ShapeReader;
  class Template;
  class TemplateList;
  class WorkOrder;

  class Project : public QObject {
    Q_OBJECT
    public:
      Project(Directory &directory, QObject *parent = 0);
      ~Project();

      static QStringList images(QStringList);
      static QStringList shapes(QStringList);
//      static QStringList verifyCNets(QStringList);

      QList<QAction *> userPreferenceActions();

      bool hasTarget(QString id);
      bool hasCamera(QString id);

      QDir addBundleSolutionInfoFolder(QString folder);
      QDir addCnetFolder(QString prefix);
      void addControl(Control *control);
      QDir addImageFolder(QString prefix);
      void addImages(QStringList imageFiles);
      void addImages(ImageList newImages);
      void addImagesToIdMap(ImageList images);
      QDir addShapeFolder(QString prefix);
      void addShapes(QStringList shapeFiles);
      void addShapes(ShapeList newShapes);
      void addTemplates(TemplateList *templateFiles);
      QDir addTemplateFolder(QString prefix);
      void addBundleSolutionInfo(BundleSolutionInfo *bundleSolutionInfo);
      void addTarget(Target *target);
      void addCamera(Camera *camera);

      void loadBundleSolutionInfo(BundleSolutionInfo *bundleSolutionInfo);
      void clear();
      bool clearing(); 
      Control *control(QString id);
      Directory *directory() const;
      Image *image(QString id);
      ImageList *imageList(QString name);
      Shape *shape(QString id);
      ShapeList *shapeList(QString name);
      // CorrelationMatrix *correlationMatrix();
      bool isTemporaryProject() const;
      bool isOpen();
      bool isClean();
      WorkOrder *lastNotUndoneWorkOrder();
      const WorkOrder *lastNotUndoneWorkOrder() const;
      QString name() const;
      QMutex *workOrderMutex();
      QMutex *mutex();
      QString projectRoot() const;
      QString newProjectRoot() const;

      void setName(QString newName);
      QUndoStack *undoStack();
      void waitForImageReaderFinished();
      void waitForShapeReaderFinished();
      QList<WorkOrder *> workOrderHistory();
      void writeSettings(FileName projName) const;

      void setActiveControl(QString displayName);
      Control  *activeControl();
      void setActiveImageList(QString displayName);
      ImageList *activeImageList();

      static QString cnetRoot(QString projectRoot);
      QString cnetRoot() const;
      QList<ControlList *> controls();
      ControlList *controlList(QString name);

      static QString imageDataRoot(QString projectRoot);
      QString imageDataRoot() const;
      QList<ImageList *> images();

      static QString shapeDataRoot(QString projectRoot);
      QString shapeDataRoot() const;
      QList<ShapeList *> shapes();

      static QString targetBodyRoot(QString projectRoot);
      QString targetBodyRoot() const;
      TargetBodyList targetBodies();

      static QString resultsRoot(QString projectRoot);
      QString resultsRoot() const;
      static QString bundleSolutionInfoRoot(QString projectRoot);
      QString bundleSolutionInfoRoot() const;
      QList<BundleSolutionInfo *> bundleSolutionInfo();

      static QString templateRoot(QString projectRoot);
      QString templateRoot() const;
      QList<TemplateList *> templates();
      QList<TemplateList *> mapTemplates();
      QList<TemplateList *> regTemplates();
      void removeTemplate(FileName file);

      void deleteAllProjectFiles();
      void relocateProjectRoot(QString newRoot);

      BundleSettings *bundleSettings() {return m_bundleSettings;}

      static int maxRecentProjects() { return m_maxRecentProjects; }

      QProgressBar *progress();

      void removeImages(ImageList &imageList);

      bool save();
      void save(FileName projectPath, bool verifyPathDoesntExist = true);

      void addToProject(WorkOrder *);

      template<typename Data> void warn(QString text, Data relevantData);

      void warn(QString text);

    signals:
//      void allImagesClosed();

      void controlListAdded(ControlList *controls);

      void controlAdded(Control *control);

      void activeControlSet(bool boolean);

      void allControlsRemoved();

      void imageListAdded(ImageList *images);

      void imagesAdded(ImageList *images);

      void activeImageListSet();

      void activeControlAndImageListSet();

      void controlsAndImagesAvailable();

      void shapesAdded(ShapeList *shapes);

      void bundleSolutionInfoAdded(BundleSolutionInfo *bundleSolutionInfo);

      void targetsAdded(TargetBodyList *targets);

      void guiCamerasAdded(GuiCameraList *targets);

      void nameChanged(QString newName);

      void projectLoaded(Project *);

      void projectSaved(Project *);

      void projectRelocated(Project *);

      void workOrderStarting(WorkOrder *);

      void workOrderFinished(WorkOrder *);

      void templatesAdded(TemplateList *newTemplates);

      void discardActiveControlEdits();

      void activeControlModified();

      void cnetSaved(bool value);

    public slots:
      void open(QString);
      void setClean(bool value);
      void cnetModified();

    private slots:
      void controlClosed(QObject *control);
      void controlListDeleted(QObject *controlList);
      void imagesReady(ImageList);
      void imageClosed(QObject *image);
      void imageListDeleted(QObject *imageList);
      void bundleSolutionInfoClosed(QObject *bundleSolutionInfo);
      void targetBodyClosed(QObject *targetBodyObj);
      void shapesReady(ShapeList shapes);
      void shapeClosed(QObject *shape);
      void shapeListDeleted(QObject *shapeList);
      void checkActiveControlAndImageList();
      void checkControlsAndImagesAvailable();

    private:
      Project(const Project &other);
      Project &operator=(const Project &rhs);
      void createFolders();

      ControlList *createOrRetrieveControlList(QString name, QString path = "");
      ImageList *createOrRetrieveImageList(QString name, QString path = "");
      ShapeList *createOrRetrieveShapeList(QString name, QString path = "");

      void writeSettings();


      QString nextImageListGroupName();
//       void removeImage(Image *image);

      void save(QXmlStreamWriter &stream, FileName newProjectRoot) const;
      void saveHistory(QXmlStreamWriter &stream) const;
      void saveWarnings(QXmlStreamWriter &stream) const;

      void storeWarning(QString text);
      void storeWarning(QString text, const ImageList &relevantData);

    private:
      class XmlHandler : public XmlStackedHandler {
        public:
          XmlHandler(Project *project);

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

        private:
          Q_DISABLE_COPY(XmlHandler);

          Project *m_project;
          QList<ImageList *> m_imageLists;
          QList<ShapeList *> m_shapeLists;
          QList<ControlList *> m_controls;
          QList<BundleSolutionInfo *> m_bundleSolutionInfos;
          QList<TemplateList *> m_mapTemplateLists;
          QList<TemplateList *> m_regTemplateLists;
          WorkOrder *m_workOrder;
      };

    private:

      static const int m_maxRecentProjects = 5;
      QDir *m_projectRoot;
      QString m_newProjectRoot;
      QDir *m_cnetRoot;
      QDir m_currentCnetFolder;
      QPointer<Directory> m_directory;
      QList<ImageList *> *m_images;
      QList<ControlList *> *m_controls;
      QList<ShapeList *> *m_shapes;
      TargetBodyList *m_targets;
      QList<TemplateList *> *m_mapTemplates;
      QList<TemplateList *> *m_regTemplates;
      GuiCameraList *m_guiCameras;
      QList<BundleSolutionInfo *> *m_bundleSolutionInfo;

      QPointer<Control> m_activeControl;
      QPointer<ImageList> m_activeImageList;


      // TODO: kle testing - this will almost certainly be changed
      BundleSettings *m_bundleSettings;
//       CorrelationMatrix *m_correlationMatrix;

      QMap<QString, Control *> *m_idToControlMap;
      QMap<QString, Image *> *m_idToImageMap;
      QMap<QString, Shape *> *m_idToShapeMap;
      QMap<QString, BundleSolutionInfo *> *m_idToBundleSolutionInfoMap;
      QMap<QString, TargetBody *> *m_idToTargetBodyMap;
      QMap<QString, GuiCamera *> *m_idToGuiCameraMap;

      QString m_name;
      QStringList *m_warnings;
      QList< QPointer<WorkOrder> > *m_workOrderHistory;

      QPointer<ImageReader> m_imageReader;
      //QList<QPair<QString, Data> > m_storedWarnings;
      bool m_isTemporaryProject;
      bool m_isOpen; 
      bool m_isClean; 
      bool m_clearing; 
      int m_numImagesCurrentlyReading;

      QMutex *m_mutex;
      QMutex *m_workOrderMutex;
      QMutex *m_imageReadingMutex;

      int m_numShapesCurrentlyReading;
      QMutex *m_shapeMutex;
      QPointer<ShapeReader> m_shapeReader;
      QMutex *m_shapeReadingMutex;

      QUndoStack m_undoStack;

  };
}

Q_DECLARE_METATYPE(Isis::Project *);

#endif // Project_H