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 "vtkObject.h"
#include "vtkRect.h"                     // For vtkRecti ivar
#include "vtkRenderingContext2DModule.h" // For export macro
#include "vtkRenderingCoreEnums.h"       // For marker enum
#include "vtkVector.h"                   // For vtkVector2i ivar
 
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