ViewportBuffer.h

#ifndef ViewportBuffer_h
#define ViewportBuffer_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <vector>
 
#include <QRect>
 
#include "Cube.h"
#include "Brick.h"
 
// parent
#include <QObject>
 
template<class T > class QQueue;
class QRect;
 
namespace Isis {
  class CubeDataThread;
  class Brick;
  class CubeViewport;
  class ViewportBufferAction;
  class ViewportBufferFill;
  class ViewportBufferStretch;
  class ViewportBufferTransform;
 
  class ViewportBuffer : public QObject {
      Q_OBJECT
 
    public:
      ViewportBuffer(CubeViewport *viewport, CubeDataThread *cubeData,
                     int cubeId);
      virtual ~ViewportBuffer();
 
      const std::vector<double> &getLine(int line);
 
      void resizedViewport();
      void pan(int deltaX, int deltaY);
 
      void scaleChanged();
 
      void fillBuffer(QRect rect);
      void fillBuffer(QRect rect, const Brick *data);
 
      void emptyBuffer(bool force = false);
 
      QRect bufferXYRect();
 
      void setBand(int band);
 
      int getBand() {
        return p_band;
      }
 
      void enable(bool enabled);
 
      void addStretchAction();
 
      double currentProgress();
      double totalUnfilledArea();
 
      bool enabled() {
        return p_enabled;
      }
      bool working();
 
      bool hasEntireCube();
 
    public slots:
      void DataReady(void *requester, int cubeId, const Isis::Brick *brick);
 
    signals:
      void ReadCube(int cubeId, int startSample, int startLine,
                    int endSample, int endLine, int band, void *caller);
 
      void DoneWithData(int, const Isis::Brick *);
 
    private:
      QRect getXYBoundingRect();
      QList<double> getSampLineBoundingRect();
      void updateBoundingRects();
      void doQueuedActions();
      void doTransformAction(ViewportBufferTransform *action);
      void doStretchAction(ViewportBufferStretch *action);
      void startFillAction(ViewportBufferFill *action);
 
      ViewportBufferFill *createViewportBufferFill(QRect, bool);
 
      void requestCubeLine(ViewportBufferFill *fill);
 
      void resizeBuffer(unsigned int width, unsigned int height);
      void shiftBuffer(int deltaX, int deltaY);
      void reinitialize();
      bool actionsPreserveData();
      bool reinitializeActionExists();
      void enqueueAction(ViewportBufferAction *);
 
      CubeViewport *p_viewport;  
      int p_cubeId; 
      CubeDataThread *p_dataThread;  
 
      int p_band; 
 
      bool p_enabled; 
      std::vector< std::vector<double> > p_buffer; 
      bool p_bufferInitialized; 
 
      QRect p_XYBoundingRect;
      QRect p_oldXYBoundingRect; 
 
      QList< double > p_sampLineBoundingRect;
      QList< double > p_oldSampLineBoundingRect; 
      int p_viewportHeight; 
      int p_oldViewportHeight; 
      int p_vertScrollBarPos; 
      int p_oldVertScrollBarPos; 
      bool p_initialStretchDone; 
      double p_requestedFillArea; 
 
      enum sampLineRectPosition {
        rectLeft = 0, 
        rectTop,  
        rectRight, 
        rectBottom 
      };
 
      QQueue< ViewportBufferAction * > * p_actions;
 
      bool p_bricksOrdered;
  };
}
 
#endif