MosaicSceneWidget.h

#ifndef MosaicSceneWidget_H
#define MosaicSceneWidget_H
 
#include <QWidget>
 
#include "ImageList.h"
#include "Pvl.h"
 
template <typename A> class QList;
 
class QGraphicsPolygonItem;
class QGraphicsRectItem;
class QGraphicsScene;
class QGraphicsSceneContextMenuEvent;
class QMenu;
class QProgressBar;
class QRubberBand;
class QStatusBar;
class QToolBar;
class QToolButton;
 
namespace Isis {
  class ControlPoint;
  class Directory;
  class Image;
  class MosaicGraphicsView;
  class MosaicSceneItem;
  class MosaicTool;
  class ProgressBar;
  class Projection;
  class PvlGroup;
  class PvlObject;
  class ToolPad;
 
  class MosaicSceneWidget : public QWidget {
      Q_OBJECT
 
    public:
      MosaicSceneWidget(QStatusBar *status,
                        bool showTools, bool internalizeToolBarsAndProgress,
                        Directory *directory, QWidget *parent = 0);
      virtual ~MosaicSceneWidget();
 
      MosaicGraphicsView *getView() const {
        return m_graphicsView;
      }
 
      QGraphicsScene *getScene() const {
        return m_graphicsScene;
      }
 
      Projection *getProjection() const {
        return m_projection;
      }
 
      QList<MosaicSceneItem *> allMosaicSceneItems() {
        return *m_mosaicSceneItems;
      }
 
      void addTo(QMenu *menu);
      void addTo(ToolPad *toolPad);
      void addToPermanent(QToolBar *toolBar);
      void addTo(QToolBar *toolBar);
 
      using QWidget::contextMenuEvent;
      bool contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
 
      MosaicSceneItem *cubeToMosaic(Image *);
 
      bool cubesSelectable() const {
        return m_cubesSelectable;
      }
 
      void enableRubberBand(bool);
      bool blockSelectionChange(bool);
 
      bool userHasTools() const {
        return m_userToolControl;
      }
 
      QProgressBar *getProgress();
      PvlObject toPvl() const;
      void fromPvl(const PvlObject &);
      void load(XmlStackedHandlerReader *xmlReader);
      void save(QXmlStreamWriter &stream, Project *project, FileName newProjectRoot) const;
 
//    QPointF currentLatLonPosition();
      QRectF cubesBoundingRect() const;
      QStringList cubeFileNames();
      Directory *directory() const;
 
      ImageList images();
      ImageList selectedImages();
 
      QList<QAction *> getExportActions();
      QList<QAction *> getViewActions();
      QList<QAction *> supportedActions(ImageList *);
 
      double moveDownOne(MosaicSceneItem *);
      double moveDownOne(Image *);
      QList<double> moveDownOne(ImageList *);
 
      double moveToBottom(MosaicSceneItem *);
      double moveToBottom(Image *);
      QList<double> moveToBottom(ImageList *);
 
      double moveUpOne(MosaicSceneItem *);
      double moveUpOne(Image *);
      QList<double> moveUpOne(ImageList *);
 
      double moveToTop(MosaicSceneItem *);
      double moveToTop(Image *);
      QList<double> moveToTop(ImageList *);
 
      double moveZ(MosaicSceneItem *sceneItem, double newZ, bool newZValueMightExist = true);
      double moveZ(Image *image, double newZ, bool newZValueMightExist = true);
 
      template <typename DataType>
      QList<QAction *> supportedActions(DataType) {
        return QList<QAction *>();
      }
 
      bool isControlNetToolActive();
 
      static QWidget *getControlNetHelp(QWidget *cnetToolContainer = NULL);
      static QWidget *getGridHelp(QWidget *gridToolContainer = NULL);
      static QWidget *getLongHelp(QWidget *mosaicSceneContainer = NULL);
      static QWidget *getMapHelp(QWidget *mapContainer = NULL);
      static QWidget *getPreviewHelp(QWidget *worldViewContainer = NULL);
 
    signals:
      void mouseEnter();
      void mouseMove(QPointF);
      void mouseLeave();
      void mouseDoubleClick(QPointF);
      void mouseButtonPress(QPointF, Qt::MouseButton s);
      void mouseButtonRelease(QPointF, Qt::MouseButton s);
      void mouseWheel(QPointF, int delta);
      void projectionChanged(Projection *);
      void rubberBandComplete(QRectF r, Qt::MouseButton s);
      void visibleRectChanged(QRectF);
 
      void cubesChanged();
 
      void queueSelectionChanged();
 
      void modifyControlPoint(ControlPoint *controlPoint);
      void deleteControlPoint(ControlPoint *controlPoint);
      void createControlPoint(double latitude, double longitude);
 
      void controlPointSelected(ControlPoint *);
 
      void cnetModified();
      void controlPointChanged(QString pointId);
      void controlPointDeleted();
      
      void mosCubeClosed(Image *);
 
    public slots:
      void addImages(ImageList);
      void removeImages(ImageList);
      void refit();
      void setCubesSelectable(bool);
      void setProjection(Projection *);
      void setOutlineRect(QRectF);
 
    private slots:
      void exportView();
      void saveList();
 
      void removeMosItem(QObject *);
 
      void moveDownOne();
      void moveToBottom();
      void moveUpOne();
      void moveToTop();
      void fitInView();
 
      void onSelectionChanged();
      void onQueuedSelectionChanged();
 
      void configProjectionParameters();
      void quickConfigProjectionParameters();
      void sendVisibleRectChanged();
 
    protected:
      virtual bool eventFilter(QObject *obj, QEvent *ev);
 
    private:
      void setProjection(const PvlGroup &mappingGroup, Pvl label=Pvl());
      MosaicSceneItem *addImage(Image *image);
      void reprojectItems();
      double maximumZ();
      double minimumZ();
      void recalcSceneRect();
 
      MosaicSceneItem *getNextItem(MosaicSceneItem *item, bool up);
 
      PvlGroup createInitialProjection(Image *cube);
 
      MosaicSceneItem *cubeToMosaic(DisplayProperties *props);
 
      static bool zOrderGreaterThan(MosaicSceneItem *first,
                                    MosaicSceneItem *second);
 
    private:
      class XmlHandler : public XmlStackedHandler {
        public:
          XmlHandler(MosaicSceneWidget *scene);
          ~XmlHandler();
 
          virtual bool startElement(const QString &namespaceURI, const QString &localName,
                                    const QString &qName, const QXmlAttributes &atts);
          virtual bool characters(const QString &ch);
          virtual bool endElement(const QString &namespaceURI, const QString &localName,
                                  const QString &qName);
 
        private:
          Q_DISABLE_COPY(XmlHandler);
 
          QString m_characterData;
          MosaicSceneWidget *m_scene;
 
          int m_scrollBarXValue;
          int m_scrollBarYValue;
 
          ImageList *m_imagesToAdd;
          QList<double> m_imageZValues;
      };
 
    private:
      Directory *m_directory;
 
      bool m_cubesSelectable;
      bool m_customRubberBandEnabled;
      QRubberBand *m_customRubberBand;
      QPoint *m_rubberBandOrigin;
      QGraphicsScene *m_graphicsScene; 
      MosaicGraphicsView *m_graphicsView; 
      Projection *m_projection; 
      QList<MosaicSceneItem *> *m_mosaicSceneItems;
      QMap<DisplayProperties *, MosaicSceneItem *> m_displayPropsToMosaicSceneItemMap;
      QGraphicsRectItem *m_outlineRect;
 
      QToolButton *m_mapButton;
      QAction *m_quickMapAction;
 
      QList<MosaicTool *> *m_tools;
 
      ToolPad *m_toolpad;
 
      QToolBar *m_permToolbar;
      QToolBar *m_activeToolbar;
 
      ProgressBar *m_progress;
 
      QHash<QString, double> *m_projectImageZOrders;
 
      bool m_blockingSelectionChanged;
      bool m_userToolControl;
      bool m_ownProjection;
      bool m_queuedSelectionChanged;
      bool m_shouldRequeueSelectionChanged;
 
      double m_currentMinimumFootprintZ;
      double m_currentMaximumFootprintZ;
      
      PvlObject *m_projectViewTransform;
  };
}
 
#endif