vtkContext2DScalarBarActor.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    vtkContext2DScalarBarActor.h

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkContext2DScalarBarActor_h
#define vtkContext2DScalarBarActor_h

#include "vtkRemotingViewsModule.h" // needed for export macro
#include "vtkScalarBarActor.h"

#include "vtkCoordinate.h"   // for Position and Position 2
#include "vtkRect.h"         // for functions that return vtkRects
#include "vtkSmartPointer.h" // for smart pointers

class vtkAxis;
class vtkColorLegend;
class vtkColorTransferFunctionItem;
class vtkContextActor;
class vtkContext2D;
class vtkContextScene;
class vtkDoubleArray;
class vtkImageData;
class vtkPoints2D;
class vtkScalarsToColors;
class vtkTextProperty;
class vtkViewport;

class VTKREMOTINGVIEWS_EXPORT vtkContext2DScalarBarActor : public vtkScalarBarActor
{
public:
  vtkTypeMacro(vtkContext2DScalarBarActor, vtkScalarBarActor);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkContext2DScalarBarActor* New();


  vtkGetMacro(TitleJustification, int);
  vtkSetClampMacro(TitleJustification, int, VTK_TEXT_LEFT, VTK_TEXT_RIGHT);


  vtkSetMacro(ForceHorizontalTitle, bool);
  vtkGetMacro(ForceHorizontalTitle, bool);
  vtkBooleanMacro(ForceHorizontalTitle, bool);

  enum
  {
    PrecedeScalarBar = 0,
    SucceedScalarBar
  };

  enum OutOfRangeType
  {
    BELOW_RANGE = 0,
    ABOVE_RANGE = 1,
  };


  vtkSetClampMacro(ScalarBarThickness, int, 0, VTK_INT_MAX);
  vtkGetMacro(ScalarBarThickness, int);


  vtkSetClampMacro(ScalarBarLength, double, 0, 1);
  vtkGetMacro(ScalarBarLength, double);


  vtkSetMacro(DrawScalarBarOutline, bool);
  vtkGetMacro(DrawScalarBarOutline, bool);
  vtkBooleanMacro(DrawScalarBarOutline, bool);


  vtkSetVector3Macro(ScalarBarOutlineColor, double);
  vtkGetVector3Macro(ScalarBarOutlineColor, double);


  vtkSetClampMacro(ScalarBarOutlineThickness, int, 0, VTK_INT_MAX);
  vtkGetMacro(ScalarBarOutlineThickness, int);


  vtkSetVector4Macro(BackgroundColor, double);
  vtkGetVector4Macro(BackgroundColor, double);


  vtkSetMacro(BackgroundPadding, double);
  vtkGetMacro(BackgroundPadding, double);


  vtkSetMacro(ReverseLegend, bool);
  vtkGetMacro(ReverseLegend, bool);
  vtkBooleanMacro(ReverseLegend, bool);


  vtkGetMacro(AutomaticLabelFormat, int);
  vtkSetMacro(AutomaticLabelFormat, int);
  vtkBooleanMacro(AutomaticLabelFormat, int);


  vtkSetMacro(AddRangeLabels, int);
  vtkGetMacro(AddRangeLabels, int);


  vtkSetMacro(AutomaticAnnotations, int);
  vtkGetMacro(AutomaticAnnotations, int);
  vtkBooleanMacro(AutomaticAnnotations, int);


  vtkGetMacro(AddRangeAnnotations, int);
  vtkSetMacro(AddRangeAnnotations, int);
  vtkBooleanMacro(AddRangeAnnotations, int);


  vtkSetMacro(DrawTickMarks, bool);
  vtkGetMacro(DrawTickMarks, bool);


  vtkSetStringMacro(RangeLabelFormat);
  vtkGetStringMacro(RangeLabelFormat);


  vtkSetStringMacro(DataRangeLabelFormat);
  vtkGetStringMacro(DataRangeLabelFormat);


  void SetNumberOfCustomLabels(vtkIdType numLabels);
  vtkIdType GetNumberOfCustomLabels();

  void SetCustomLabel(vtkIdType index, double value);

  int RenderOverlay(vtkViewport* viewport) override;

  int RenderOpaqueGeometry(vtkViewport* viewport) override;

  void ReleaseGraphicsResources(vtkWindow* window) override;

  virtual bool Paint(vtkContext2D* painter);

  vtkRectf GetBoundingRect();

  int GetEstimatedNumberOfAnnotations();


  vtkSetMacro(DrawDataRange, bool);
  vtkGetMacro(DrawDataRange, bool);
  vtkBooleanMacro(DrawDataRange, bool);


  vtkSetMacro(DataRangeMin, double);
  vtkGetMacro(DataRangeMin, double);


  vtkSetMacro(DataRangeMax, double);
  vtkGetMacro(DataRangeMax, double);

protected:
  vtkContext2DScalarBarActor();
  ~vtkContext2DScalarBarActor() override;

  bool DrawDataRange;


  double DataRangeMin = 0;
  double DataRangeMax = 0;

  int VerticalOffset = 0;

private:
  vtkContext2DScalarBarActor(const vtkContext2DScalarBarActor&) = delete;
  void operator=(const vtkContext2DScalarBarActor&) = delete;

  vtkContextActor* ActorDelegate;

  int TitleJustification;

  bool ForceHorizontalTitle;

  double ScalarBarOutlineColor[3];

  int ScalarBarThickness;

  double BackgroundColor[4];

  double BackgroundPadding;

  double ScalarBarLength;

  int AutomaticLabelFormat;

  int AddRangeLabels;
  int AutomaticAnnotations;
  int AddRangeAnnotations;
  char* RangeLabelFormat;
  char* DataRangeLabelFormat;

  bool DrawScalarBarOutline;

  int ScalarBarOutlineThickness;

  double Spacer;

  bool DrawTickMarks;

  bool ReverseLegend;

  class vtkScalarBarItem;
  vtkScalarBarItem* ScalarBarItem;

  vtkViewport* CurrentViewport;

  vtkAxis* Axis;

  bool InGetBoundingRect;

  vtkRectf CurrentBoundingRect;

  void UpdateScalarBarTexture(vtkImageData* image);

  void GetSize(double size[2], vtkContext2D* painter);

  vtkRectf GetColorBarRect(double size[2], bool includeSwatch = true);

  vtkRectf GetFullColorBarRect(double size[2]);

  vtkRectf GetAboveRangeColorRect(double size[2]);

  vtkRectf GetBelowRangeColorRect(double size[2]);

  vtkRectf GetOutOfRangeColorRectInternal(
    vtkContext2DScalarBarActor::OutOfRangeType type, double size[2]);

  vtkRectf GetNaNColorRect(double size[2]);

  void UpdateTextProperties();

  void PaintColorBar(vtkContext2D* painter, double size[2]);

  void PaintAxis(vtkContext2D* painter, double size[2]);

  void PaintTitle(vtkContext2D* painter, double size[2]);

  void PaintRange(vtkContext2D* painter, double size[2]);

  class vtkAnnotationMap;

  void PaintAnnotations(vtkContext2D* painter, double size[2], const vtkAnnotationMap& map);

  void PaintAnnotationsVertically(
    vtkContext2D* painter, double size[2], const vtkAnnotationMap& map);

  void PaintAnnotationsHorizontally(
    vtkContext2D* painter, double size[2], const vtkAnnotationMap& map);

  float HorizontalAnnotationHeight;

  float VerticalRangeDataHeight;
};

#endif // vtkContext2DScalarBarActor_h