Object/Programmer/_project_8h_source.html

#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