FeatureNomenclatureTool.h

#ifndef FeatureNomenclatureTool_h
#define FeatureNomenclatureTool_h
 
#include "Tool.h"
 
#include <QPointer>
#include <QProgressDialog>
#include "FeatureNomenclature.h"
 
class QCheckBox;
class QComboBox;
class QDialog;
class QLabel;
class QLineEdit;
class QMenu;
class QProgressBar;
class QPushButton;
class QString;
 
template <typename A, typename B> class QMap;
template <typename A, typename B> struct QPair;
 
namespace Isis {
  class MdiCubeViewport;
  class UniversalGroundMap;

  class FeatureNomenclatureTool : public Tool {
      Q_OBJECT
 
    public:

      enum VectorType {
        None,
        Arrows4,
        Arrows8,
        Box       
      };
      
      FeatureNomenclatureTool(QWidget *parent);
      ~FeatureNomenclatureTool();
 
      void addTo(QMenu *menu);
      void paintViewport(MdiCubeViewport *vp, QPainter *painter);
 
      bool defaultEnabled() const;
      QColor fontColor() const;
      int fontSize() const;
      bool showApprovedOnly() const;
      VectorType vectorType() const;
 
      void setDefaultEnabled(bool defaultEnabled);
      void setFontColor(QColor color);
      void setFontSize(int newFontSize);
      void setShowApprovedOnly(bool approvedOnly);
      void setVectorType(VectorType show);
 
      QString menuName() const;
 
    protected:
      QWidget *createToolBarWidget(QStackedWidget *parent);
      QAction *toolPadAction(ToolPad *pad);
      void mouseButtonRelease(QPoint p, Qt::MouseButton s);
      void updateTool();
 
    private slots:
      void centerOnSelectedFeature();
      void configure();
      void featureSelected();
      void featuresIdentified(FeatureNomenclature *);
      void findNomenclatureStateChanged(int);
      void nomenclaturePositionsOutdated();
      void onToolActivated();
      void showDisclaimer();
 
    private:
      // This is an inner class defined below.
      class ViewportFeatureDisplay;
 
      void centerOnFeature(MdiCubeViewport *vp, FeatureNomenclature::Feature);
      void featuresForViewportFound(MdiCubeViewport *vp);
      void findMissingNomenclature();
      void findMissingNomenclature(MdiCubeViewport *vp);
      void rebuildFeaturesCombo();
      void removeFeatureDisplay(MdiCubeViewport *vp);
      void showFeatureDetails(FeatureNomenclature::Feature);
      void showFeatureWebsite(FeatureNomenclature::Feature);
      void toolStateChanged();
      void viewportDone(MdiCubeViewport *vp);
      ViewportFeatureDisplay *viewportFeatureDisplay(MdiCubeViewport *vp);
      const ViewportFeatureDisplay *
          viewportFeatureDisplay(MdiCubeViewport *vp) const;
      bool viewportFeaturesFound(MdiCubeViewport *vp) const;
      QList<MdiCubeViewport *> viewportsWithFoundNomenclature();
 
      void readSettings();
      void writeSettings();
 
    private:
      class FeaturePosition {
        public:
          FeaturePosition();
          FeaturePosition(MdiCubeViewport *, FeatureNomenclature::Feature, VectorType vectorType);
          FeaturePosition(const FeaturePosition &other);
          ~FeaturePosition();
 
          bool isValid() const;
 
          QPair<double, double> center() const;
          QList< QPair<double, double> > edges() const;
          FeatureNomenclature::Feature &feature();
          const FeatureNomenclature::Feature &feature() const;
          void applyExtentType(VectorType vectorType);
          
          void swap(FeaturePosition &other);
          FeaturePosition &operator=(const FeaturePosition &rhs);
 
        private:
          double m_centerLine;
          double m_centerSample;

          UniversalGroundMap *m_gmap;

          QList< QPair<double, double> > *m_featureEdgeLineSamples;
          FeatureNomenclature::Feature m_feature;
      };
 

      class FeatureDisplayPosition {
        public:
          FeatureDisplayPosition();
          FeatureDisplayPosition(QRect textRect, QRect fullDisplayRect,
              QList<QPoint> edgePoints);
          FeatureDisplayPosition(const FeatureDisplayPosition &other);
          ~FeatureDisplayPosition();
 
          QRect textArea() const;
          QRect displayArea() const;
          QList<QPoint> edgePoints() const;
 
          void swap(FeatureDisplayPosition &other);
          FeatureDisplayPosition &operator=(const FeatureDisplayPosition &rhs);
        private:
 
        private:
          QRect *m_textRect;
          QRect *m_fullDisplayRect;
          QList<QPoint> *m_edgePoints;
      };
 

      class ViewportFeatureDisplay {
        public:
          ViewportFeatureDisplay();
          ViewportFeatureDisplay(FeatureNomenclatureTool *tool,
              MdiCubeViewport *sourceViewport,
              QList<FeatureNomenclature::Feature> features,
              VectorType vectorType);
          ViewportFeatureDisplay(const ViewportFeatureDisplay &other);
          ~ViewportFeatureDisplay();
 
          void applyExtentType(VectorType vectorType);
          void centerFeature(FeatureNomenclature::Feature);
          QList<FeatureNomenclature::Feature> features();
          QList<FeaturePosition> featurePositions();
          MdiCubeViewport *sourceViewport() const;
          void paint(QPainter *painter, bool showVectors,
                     VectorType vectorType, bool approvedOnly)const;
 
          void handleMouseClicked(FeatureNomenclatureTool *tool, QPoint p,
                                  Qt::MouseButton s);
          void handleViewChanged(FeatureNomenclatureTool *tool);
 
          void swap(ViewportFeatureDisplay &other);
          ViewportFeatureDisplay &operator=(
              const ViewportFeatureDisplay &rhs);
 
        private:
          QPair<QPointF, QPointF> viewportCubeRange() const;
 
        private:
          MdiCubeViewport *m_sourceViewport;
          QList<FeaturePosition> *m_features;
          QList<FeatureDisplayPosition> *m_featureScreenAreas;
          QPair<QPointF, QPointF> *m_viewportCubeRange;
      };
 
    private:
      QPointer<QAction> m_action;

      QPointer<QCheckBox> m_findNomenclatureCheckBox;
      QPointer<QComboBox> m_foundFeaturesCombo;
      QPointer<QPushButton> m_nomenclatureCenterBtn;
      QPointer<QPushButton> m_nomenclatureOptionsBtn;
      QPointer<QPushButton> m_disclaimerBtn;
      QPointer<QProgressBar> m_queryingProgress;

      QList<ViewportFeatureDisplay> * m_foundNomenclature;
      QMap< MdiCubeViewport *,
            FeatureNomenclature *> * m_nomenclatureSearchers;

      bool m_nomenclatureEnabled;

      QString m_disclaimerText;

      int m_fontSize;
      QColor *m_fontColor;
      bool m_defaultEnabled;
      bool m_disclaimedAlready;
      VectorType m_extentType;
      bool m_showApprovedOnly;
  };
}
 
#endif