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