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 controlPointChanged(QString pointId);
      void controlPointAdded(QString pointId);

      void deleteControlPoint(QString pointId);
      void controlPointDeleted();

    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