vtkContext2D.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkContext2D.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 vtkContext2D_h
#define vtkContext2D_h

#include "vtkRenderingContext2DModule.h" // For export macro
#include "vtkObject.h"

class vtkWindow;

class vtkContext3D;
class vtkStdString;
class vtkUnicodeString;
class vtkTextProperty;

class vtkPoints2D;
class vtkVector2f;
class vtkRectf;
class vtkUnsignedCharArray;
class vtkContextDevice2D;
class vtkPen;
class vtkBrush;
class vtkImageData;
class vtkTransform2D;
class vtkAbstractContextBufferId;

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

  static vtkContext2D *New();

  bool Begin(vtkContextDevice2D *device);

  vtkGetObjectMacro(Device, vtkContextDevice2D);

  bool End();

  bool GetBufferIdMode() const;

  void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId);

  void BufferIdModeEnd();

  void DrawLine(float x1, float y1, float x2, float y2);

  void DrawLine(float p[4]);

  void DrawLine(vtkPoints2D *points);

  void DrawPoly(float *x, float *y, int n);

  void DrawPoly(vtkPoints2D *points);

  void DrawPoly(float *points, int n);

  void DrawPoly(float *points, int n,
                unsigned char *colors, int nc_comps);

  void DrawLines(vtkPoints2D *points);

  void DrawLines(float *points, int n);

  void DrawPoint(float x, float y);

  void DrawPoints(float *x, float *y, int n);

  void DrawPoints(vtkPoints2D *points);

  void DrawPoints(float *points, int n);

  void DrawPointSprites(vtkImageData *sprite, vtkPoints2D *points);


  void DrawPointSprites(vtkImageData *sprite, vtkPoints2D *points,
                        vtkUnsignedCharArray *colors);
  void DrawPointSprites(vtkImageData *sprite, float *points, int n,
                        unsigned char *colors, int nc_comps);

  void DrawPointSprites(vtkImageData *sprite, float *points, int n);


  virtual void DrawMarkers(int shape, bool highlight, float *points, int n,
                           unsigned char *colors, int nc_comps);
  virtual void DrawMarkers(int shape, bool highlight, float *points, int n);
  virtual void DrawMarkers(int shape, bool highlight, vtkPoints2D *points);
  virtual void DrawMarkers(int shape, bool highlight, vtkPoints2D *points,
                           vtkUnsignedCharArray *colors);

  void DrawRect(float x, float y, float w, float h);


  void DrawQuad(float x1, float y1, float x2, float y2,
                float x3, float y3, float x4, float y4);
  void DrawQuad(float *p);


  void DrawQuadStrip(vtkPoints2D *points);
  void DrawQuadStrip(float *p, int n);

  void DrawPolygon(float *x, float *y, int n);

  void DrawPolygon(vtkPoints2D *points);

  void DrawPolygon(float *points, int n);

  void DrawEllipse(float x, float y, float rx, float ry);

  void DrawWedge(float x, float y, float outRadius,
                 float inRadius,float startAngle,
                 float stopAngle);

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


  void DrawArc(float x, float y, float r, float startAngle,
               float stopAngle);

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


  void DrawImage(float x, float y, vtkImageData *image);

  void DrawImage(float x, float y, float scale, vtkImageData *image);

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


  void DrawStringRect(vtkPoints2D *rect, const vtkStdString &string);
  void DrawStringRect(vtkPoints2D *rect, const vtkUnicodeString &string);
  void DrawStringRect(vtkPoints2D *rect, const char* string);


  void DrawString(vtkPoints2D *point, const vtkStdString &string);
  void DrawString(float x, float y, const vtkStdString &string);
  void DrawString(vtkPoints2D *point, const vtkUnicodeString &string);
  void DrawString(float x, float y, const vtkUnicodeString &string);
  void DrawString(vtkPoints2D *point, const char* string);
  void DrawString(float x, float y, const char* string);


  void ComputeStringBounds(const vtkStdString &string, vtkPoints2D *bounds);
  void ComputeStringBounds(const vtkStdString &string, float bounds[4]);
  void ComputeStringBounds(const vtkUnicodeString &string, vtkPoints2D *bounds);
  void ComputeStringBounds(const vtkUnicodeString &string, float bounds[4]);
  void ComputeStringBounds(const char* string, vtkPoints2D *bounds);
  void ComputeStringBounds(const char* string, float bounds[4]);

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

  int ComputeFontSizeForBoundedString(const vtkStdString &string, float width,
                                      float height);


  void DrawMathTextString(vtkPoints2D *point, const vtkStdString &string);
  void DrawMathTextString(float x, float y, const vtkStdString &string);
  void DrawMathTextString(vtkPoints2D *point, const char *string);
  void DrawMathTextString(float x, float y, const char *string);


  void DrawMathTextString(vtkPoints2D *point, const vtkStdString &string,
                          const vtkStdString &fallback);
  void DrawMathTextString(float x, float y, const vtkStdString &string,
                          const vtkStdString &fallback);
  void DrawMathTextString(vtkPoints2D *point, const char *string,
                          const char *fallback);
  void DrawMathTextString(float x, float y, const char *string,
                          const char *fallback);


  bool MathTextIsSupported();

  void ApplyPen(vtkPen *pen);

  vtkPen* GetPen();

  void ApplyBrush(vtkBrush *brush);

  vtkBrush* GetBrush();

  void ApplyTextProp(vtkTextProperty *prop);

  vtkTextProperty* GetTextProp();

  void SetTransform(vtkTransform2D *transform);

  vtkTransform2D* GetTransform();

  void AppendTransform(vtkTransform2D *transform);


  void PushMatrix();
  void PopMatrix();

  void ApplyId(vtkIdType id);

  static int FloatToInt(float x);


  vtkGetObjectMacro(Context3D, vtkContext3D)
  virtual void SetContext3D(vtkContext3D *context);

protected:
  vtkContext2D();
  ~vtkContext2D();

  vtkContextDevice2D *Device; // The underlying device
  vtkTransform2D *Transform;  // Current transform

  vtkAbstractContextBufferId *BufferId;
  vtkContext3D *Context3D; // May be very temporary - get at a 3D version.

private:
  vtkContext2D(const vtkContext2D &) VTK_DELETE_FUNCTION;
  void operator=(const vtkContext2D &) VTK_DELETE_FUNCTION;

  vtkVector2f CalculateTextPosition(vtkPoints2D* rect);

  vtkVector2f CalculateTextPosition(float rect[4]);

};

inline int vtkContext2D::FloatToInt(float x)
{
  // Use a tolerance of 1/256 of a pixel when converting.
  // A float has only 24 bits of precision, so we cannot
  // make the tolerance too small.  For example, a tolerance
  // of 2^-8 means that the tolerance will be significant
  // for float values up to 2^16 or 65536.0.  But a
  // tolerance of 2^-16 would only be significant for
  // float values up to 2^8 or 256.0.  A small tolerance
  // disappears into insignificance when added to a large float.
  float tol = 0.00390625; // 1.0/256.0
  tol = (x >= 0 ? tol : -tol);
  return static_cast<int>(x + tol);
}

#endif //vtkContext2D_h