vtkContextDevice2D.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkContextDevice2D.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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 vtkContextDevice2D_h
#define vtkContextDevice2D_h

#include "vtkRenderingContext2DModule.h" // For export macro
#include "vtkObject.h"
#include "vtkVector.h" // For vtkVector2i ivar
#include "vtkRect.h"   // For vtkRecti ivar
#include "vtkRenderingCoreEnums.h" // For marker enum

class vtkWindow;
class vtkViewport;
class vtkStdString;
class vtkUnicodeString;
class vtkTextProperty;
class vtkPoints2D;
class vtkImageData;
class vtkMatrix3x3;
class vtkAbstractContextBufferId;
class vtkPen;
class vtkBrush;
class vtkRectf;
class vtkPolyData;
class vtkUnsignedCharArray;

class VTKRENDERINGCONTEXT2D_EXPORT vtkContextDevice2D : public vtkObject
{
public:
  vtkTypeMacro(vtkContextDevice2D, vtkObject);
  void PrintSelf(ostream &os, vtkIndent indent) override;

  static vtkContextDevice2D * New();

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

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

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

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

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

  virtual void DrawQuad(float *, int) { ; }

  virtual void DrawQuadStrip(float *, int) { ; }

  virtual void DrawPolygon(float *p, int n) { this->DrawColoredPolygon(p, n); }
  virtual void DrawColoredPolygon(float *points, int numPoints,
                                  unsigned char *colors = nullptr,
                                  int nc_comps = 0);
  virtual void DrawEllipseWedge(float x, float y, float outRx, float outRy,
                                float inRx, float inRy, float startAngle,
                                float stopAngle)=0;

  virtual void DrawEllipticArc(float x, float y, float rX, float rY,
                               float startAngle, float stopAngle)=0;

  virtual void DrawString(float *point, const vtkStdString &string) = 0;

  virtual void ComputeStringBounds(const vtkStdString &string,
                                   float bounds[4]) = 0;

  virtual void DrawString(float *point, const vtkUnicodeString &string) = 0;

  virtual void ComputeStringBounds(const vtkUnicodeString &string,
                                   float bounds[4]) = 0;

  virtual void ComputeJustifiedStringBounds(const char* string, float bounds[4]) = 0;

  virtual void DrawMathTextString(float *point, const vtkStdString &string) = 0;

  virtual bool MathTextIsSupported();

  virtual void DrawImage(float p[2], float scale, vtkImageData *image) = 0;

  virtual void DrawImage(const vtkRectf& pos, vtkImageData *image) = 0;

  virtual void DrawPolyData(float p[2], float scale, vtkPolyData* polyData,
    vtkUnsignedCharArray* colors, int scalarMode);

  virtual void ApplyPen(vtkPen *pen);


  vtkGetObjectMacro(Pen, vtkPen);

  virtual void ApplyBrush(vtkBrush *brush);


  vtkGetObjectMacro(Brush, vtkBrush);

  virtual void ApplyTextProp(vtkTextProperty *prop);


  vtkGetObjectMacro(TextProp, vtkTextProperty);

  virtual void SetColor4(unsigned char color[4]) = 0;

  enum TextureProperty {
    Nearest = 0x01,
    Linear  = 0x02,
    Stretch = 0x04,
    Repeat  = 0x08
  };
  virtual void SetTexture(vtkImageData* image, int properties) = 0;

  virtual void SetPointSize(float size) = 0;

  virtual void SetLineWidth(float width) = 0;

  virtual void SetLineType(int type) = 0;

  virtual int GetWidth() { return this->Geometry[0]; }

  virtual int GetHeight() { return this->Geometry[1]; }

  virtual void SetMatrix(vtkMatrix3x3 *m) = 0;

  virtual void GetMatrix(vtkMatrix3x3 *m) = 0;

  virtual void MultiplyMatrix(vtkMatrix3x3 *m) = 0;

  virtual void PushMatrix() = 0;

  virtual void PopMatrix() = 0;

  virtual void SetClipping(int *x) = 0;

  virtual void DisableClipping() { this->EnableClipping(false); }

  virtual void EnableClipping(bool enable) = 0;

  virtual void Begin(vtkViewport*) { }

  virtual void End() { }

  virtual bool GetBufferIdMode() const;

  virtual void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId);

  virtual void BufferIdModeEnd();

  virtual void SetViewportSize(const vtkVector2i &size)
  {
    this->ViewportSize = size;
  }
  vtkGetMacro(ViewportSize, vtkVector2i)

  virtual void SetViewportRect(const vtkRecti &rect)
  {
    this->ViewportRect = rect;
  }
  vtkGetMacro(ViewportRect, vtkRecti)

protected:
  vtkContextDevice2D();
  ~vtkContextDevice2D() override;

  int Geometry[2];

  vtkVector2i ViewportSize;

  vtkRecti ViewportRect;

  vtkAbstractContextBufferId *BufferId;

  vtkPen *Pen;                // Outlining
  vtkBrush *Brush;            // Fills
  vtkTextProperty *TextProp;  // Text property

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

};

#endif //vtkContextDevice2D_h