vtkBoundingRectContextDevice2D.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
/*
 * @class   vtkBoundingRectContextDevice2D
 * @brief   Utility class for computing the bounds of items drawn by a
 * vtkContext2D.

 * vtkBoundingRectContextDevice2D is a utility class that can be used to
 * determine the bounding box of items drawn in a vtkContext2D. It overrides all
 * the member functions for drawing primitives, and instead of drawing anything,
 * it expands a running bounding box so that the bounding box contains the
 * rendered primitive. The running bounding box can be reset using Reset(), and
 * it can be queried with GetBoundingRect().
 *
 * This class delegates the task of computing the bounds of some primitives,
 * such as text strings, to a delegate device using SetDelegateDevice().
 *
 * Example usage:
 * \code{.cpp}
 * vtkContextScene* scene = ...;
 * vtkViewport* viewport = ...;
 * vtkNew<vtkContextDevice2D> contextDevice;
 * vtkNew<vtkBoundingRectContextDevice2D> bbDevice;
 * bbDevice->SetDelegateDevice(contextDevice.Get());
 * bbDevice->Begin(viewport);
 * vtkNew<vtkContextDevice2D> context;
 * context->Begin(bbDevice.Get());
 * scene->Paint(context.Get());
 * context->End();
 * bbDevice->End();
 *
 * \warning Currently ignores transformation matrices.
 * \endcode
 */

#ifndef vtkBoundingRectContextDevice2D_h
#define vtkBoundingRectContextDevice2D_h

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

#include "vtkContextDevice2D.h"

class vtkAbstractContextItem;

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

  vtkSetObjectMacro(DelegateDevice, vtkContextDevice2D);
  vtkGetObjectMacro(DelegateDevice, vtkContextDevice2D);

  void Reset();

  static vtkRectf GetBoundingRect(vtkAbstractContextItem* item, vtkViewport* viewport);

  vtkRectf GetBoundingRect();

  void DrawString(float* point, const vtkStdString& string) override;

  void DrawMathTextString(float* point, const vtkStdString& string) override;

  void DrawImage(float p[2], float scale, vtkImageData* image) override;

  void DrawImage(const vtkRectf& pos, vtkImageData* image) override;

  void DrawPolyData(float vtkNotUsed(p)[2], float vtkNotUsed(scale),
    vtkPolyData* vtkNotUsed(polyData), vtkUnsignedCharArray* vtkNotUsed(colors),
    int vtkNotUsed(scalarMode)) override
  {
  }

  void SetColor4(unsigned char color[4]) override;

  void SetTexture(vtkImageData* image, int properties) override;

  void SetPointSize(float size) override;

  void SetLineWidth(float width) override;

  void SetLineType(int type) override;

  void SetMatrix(vtkMatrix3x3* m) override;

  void GetMatrix(vtkMatrix3x3* m) override;

  void MultiplyMatrix(vtkMatrix3x3* m) override;

  void PushMatrix() override;

  void PopMatrix() override;

  void EnableClipping(bool enable) override;

  void SetClipping(int* x) override;

  void ApplyPen(vtkPen* pen) override;

  vtkPen* GetPen() override;

  void ApplyBrush(vtkBrush* brush) override;

  vtkBrush* GetBrush() override;

  void ApplyTextProp(vtkTextProperty* prop) override;

  vtkTextProperty* GetTextProp() override;

  void DrawPoly(float* points, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawLines(float* f, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawPoints(float* points, int n, unsigned char* colors = nullptr, int nc_comps = 0) override;

  void DrawPointSprites(vtkImageData* sprite, float* points, int n, unsigned char* colors = nullptr,
    int nc_comps = 0) override;

  void DrawMarkers(int shape, bool highlight, float* points, int n, unsigned char* colors = nullptr,
    int nc_comps = 0) override;

  void DrawEllipseWedge(float x, float y, float outRx, float outRy, float inRx, float inRy,
    float startAngle, float stopAngle) override;

  void DrawEllipticArc(
    float x, float y, float rX, float rY, float startAngle, float stopAngle) override;

  void ComputeStringBounds(const vtkStdString& string, float bounds[4]) override;

  void ComputeJustifiedStringBounds(const char* string, float bounds[4]) override;

  void Begin(vtkViewport*) override;

  void End() override;

  bool GetBufferIdMode() const override;

  void BufferIdModeBegin(vtkAbstractContextBufferId* bufferId) override;

  void BufferIdModeEnd() override;

protected:
  vtkBoundingRectContextDevice2D();
  ~vtkBoundingRectContextDevice2D() override;

  bool Initialized;

  vtkRectf BoundingRect;

  vtkContextDevice2D* DelegateDevice;

  void AddPoint(float x, float y);
  void AddPoint(float point[2]);

  void AddRect(const vtkRectf& rect);

private:
  vtkBoundingRectContextDevice2D(const vtkBoundingRectContextDevice2D&) = delete;
  void operator=(const vtkBoundingRectContextDevice2D&) = delete;
};

#endif // vtkBoundingRectContextDevice2D_h