Board/Shapes.h

/* -*- mode: c++ -*- */
/*
 * \@copyright This File is part of the Board library which is
 * licensed under the terms of the GNU Lesser General Public Licence.
 * See the LICENCE file for further details.
 */
#ifndef _BOARD_SHAPES_H_
#define _BOARD_SHAPES_H_
 
#include "Board/Point.h"
#include "Board/Rect.h"
#include "Board/Path.h"
#include "Board/Transforms.h"
#include "Board/PSFonts.h"
#include "Board/Tools.h"
#include <string>
#include <vector>
#include <iostream>
#include <map>
#include <cmath>
 
#include "DGtal/io/Color.h"
 
#ifdef WITH_CAIRO
// cairo
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"
#endif
#include <cairo.h>
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
#endif
 
#ifndef M_PI
#define M_PI           3.14159265358979323846
#endif
 
#ifndef M_PI_2
#define M_PI_2         1.57079632679489661923
#endif
 
namespace LibBoard {
  
 
struct Shape {
 
  enum LineCap { ButtCap = 0, RoundCap, SquareCap };
  enum LineJoin { MiterJoin = 0, RoundJoin, BevelJoin };
  enum LineStyle { SolidStyle = 0,
       DashStyle, 
       DotStyle,
       DashDotStyle,
       DashDotDotStyle,
       DashDotDotDotStyle };
 
  inline Shape( DGtal::Color penColor, DGtal::Color fillColor,
    double lineWidth, 
    LineStyle style,
    const LineCap cap,
    const LineJoin join,
    int depth );
  
  virtual ~Shape() { }
 
  virtual const std::string & name() const;
 
  virtual Shape * clone() const = 0;
  
  inline bool filled() const { return _fillColor != DGtal::Color::None; }
  
  virtual Point center() const = 0;
  
  virtual Shape & rotate( double angle, const Point & center ) = 0;
 
  virtual Shape & rotate( double angle ) = 0;
 
  inline Shape & rotateDeg( double angle, const Point & center );
  
  inline Shape & rotateDeg( double angle );
 
  virtual Shape & translate( double dx, double dy ) = 0;
 
  virtual Shape & scale( double sx, double sy ) = 0;
 
  virtual Shape & scale( double s ) = 0;
 
  virtual Rect boundingBox() const = 0;
 
  
  inline Rect bbox();
  
 
  inline Shape & operator--();
 
  inline Shape & operator++();
 
 
  virtual void scaleAll( double s ) = 0;
 
 
  virtual void flushPostscript( std::ostream & stream,
        const TransformEPS & transform ) const = 0;
 
  virtual void flushFIG( std::ostream & stream,
       const TransformFIG & transform,
       std::map<DGtal::Color,int> & colormap ) const = 0;
 
  virtual void flushSVG( std::ostream & stream,
       const TransformSVG & transform ) const = 0;
 
#ifdef WITH_CAIRO
  virtual void flushCairo( cairo_t *cr,
       const TransformCairo & transform ) const = 0;
#endif
 
  virtual void flushTikZ( std::ostream & stream,
       const TransformTikZ & transform ) const = 0;
 
  inline int depth() const;
 
  virtual void depth( int );
 
  virtual void shiftDepth( int shift );
  
  inline const DGtal::Color & penColor() const;
 
  inline const DGtal::Color & fillColor() const;
 
private:
  static const std::string _name; 
protected:
 
  int _depth;        
  DGtal::Color _penColor;    
  DGtal::Color _fillColor;    
  double _lineWidth;  
  LineStyle _lineStyle;  
  LineCap _lineCap;    
  LineJoin _lineJoin;  
  std::string svgProperties( const TransformSVG & transform ) const;
 
  
  std::string postscriptProperties() const;
 
#ifdef WITH_CAIRO
  // cairo
  void setCairoDashStyle(cairo_t *cr, LineStyle type) const;
#endif
 
  std::string tikzProperties( const TransformTikZ & transform ) const;
};
 
  
inline Rect
Shape::bbox()
{
  return this->boundingBox();
}
  
  
inline Shape &
Shape::operator++()
{
  ++_depth;
  return *this;
}
 
inline Shape &
Shape::operator--()
{
  --_depth;
  return *this;
}
 
 
inline int
Shape::depth() const
{
  return _depth;
}
 
inline const DGtal::Color &
Shape::penColor() const
{
  return _penColor;
}
 
const DGtal::Color &
Shape::fillColor() const
{
  return _fillColor;
}
 
Shape &
Shape::rotateDeg( double angle, const Point & aCenter )
{
  return rotate( angle * ( M_PI / 180.0 ), aCenter ); 
}
 
Shape &
Shape::rotateDeg( double angle )
{
  return rotate( angle * ( M_PI / 180.0 ), center() ); 
}
 
struct Dot : public Shape { 
  
  inline Dot( double x, double y,
        DGtal::Color color, 
        double lineWidth,
        int depth = -1 );
 
  const std::string & name() const;
  
  Point center() const;
 
  Dot & rotate( double angle, const Point & center );
 
  Dot rotated( double angle, const Point & center ) const;
 
  Dot & rotate( double angle );
 
  Dot rotated( double angle ) const;
 
  Dot & translate( double dx, double dy );
 
  Dot translated( double dx, double dy ) const;
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
 
  Dot scaled( double sx, double sy ) const;
 
  Dot scaled( double s ) const;
 
  void scaleAll( double s );
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
  
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
  
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
  
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Rect boundingBox() const;
 
  Dot * clone() const;
 
private:
  static const std::string _name; 
protected:
  double _x;      
  double _y;      
};
 
 
 
struct Line : public Shape { 
  
  inline Line( double x1, double y1, double x2, double y2, 
         DGtal::Color color, 
         double lineWidth,
         const LineStyle style = SolidStyle,
         const LineCap cap = ButtCap,
         const LineJoin join = MiterJoin,
         int depth = -1 );
 
  const std::string & name() const;
 
  Point center() const;
 
  Line & rotate( double angle, const Point & center );
 
  Line rotated( double angle, const Point & center ) const;
 
  Line & rotate( double angle );
 
  Line rotated( double angle ) const;
 
  Line & translate( double dx, double dy );
 
  Line translated( double dx, double dy ) const;
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
 
  Line scaled( double sx, double sy ) const;
 
  Line scaled( double s ) const;
  
  void scaleAll( double s );
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
  
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Rect boundingBox() const;
 
  Line * clone() const;
 
private:
  static const std::string _name; 
protected:
  double _x1;      
  double _y1;      
  double _x2;       
  double _y2;      
};
 
 
 
 
struct Arrow : public Line { 
 
  inline Arrow( double x1, double y1, double x2, double y2,
    DGtal::Color penColor, DGtal::Color fillColor,
    double lineWidth, 
    const LineStyle style = SolidStyle,
    const LineCap cap = ButtCap,
    const LineJoin join = MiterJoin,
    int depth = -1 );
 
  const std::string & name() const;
  
  Arrow rotated( double angle, const Point & center ) const;
  
  Arrow rotated( double angle ) const;
 
  Arrow translated( double dx, double dy ) const;
 
  Arrow scaled( double sx, double sy ) const;
 
  Arrow scaled( double s ) const;
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
  
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Arrow * clone() const;
 
private:
  static const std::string _name; 
};
 
struct Polyline : public Shape { 
  inline Polyline( const std::vector<Point> & points, 
       bool closed,
       DGtal::Color penColor, DGtal::Color fillColor,
       double lineWidth,
       const LineStyle lineStyle = SolidStyle,
       const LineCap cap = ButtCap,
       const LineJoin join = MiterJoin,
       int depth = -1 );
 
  inline Polyline( const Path & path, 
       DGtal::Color penColor, DGtal::Color fillColor,
       double lineWidth,
       const LineStyle lineStyle = SolidStyle,
       const LineCap cap = ButtCap,
       const LineJoin join = MiterJoin,
       int depth = -1 );
 
  inline Polyline( bool closed, DGtal::Color penColor, DGtal::Color fillColor,
       double lineWidth,
       const LineStyle lineStyle = SolidStyle,
       const LineCap cap = ButtCap,
       const LineJoin join = MiterJoin,
       int depth = -1 );
      
  const std::string & name() const;
 
  Point center() const;
 
  Polyline & operator<<( const Point & p );
 
  Point & operator[]( const unsigned int n ) {
    return _path[ n ];
  }
 
 
  Polyline & rotate( double angle, const Point & center );
 
  Polyline rotated( double angle, const Point & center ) const;
 
  Polyline & rotate( double angle );
  
  Polyline rotated( double angle ) const;
 
  Polyline & translate( double dx, double dy );
  
  Polyline translated( double dx, double dy ) const;
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
  
  Polyline scaled( double sx, double sy )  const;
 
  Polyline scaled( double s )  const;
 
  void scaleAll( double s );
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
 
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Rect boundingBox() const;
 
  Polyline * clone() const;
 
private:
  static const std::string _name; 
protected:
  Path _path;
};
 
struct Rectangle : public Polyline {
 
  inline Rectangle( double x, double y, double width, double height,
       DGtal::Color penColor, DGtal::Color fillColor,
       double lineWidth, 
       const LineStyle style = SolidStyle,
       const LineCap cap = ButtCap,
       const LineJoin join = MiterJoin,
        int depth = -1 );
 
  inline Rectangle( const Rect & rect,
        DGtal::Color penColor, DGtal::Color fillColor,
        double lineWidth,
        const LineStyle style = SolidStyle,
        const LineCap cap = ButtCap,
        const LineJoin join = MiterJoin,
        int depth = -1 );
 
  const std::string & name() const;
 
  double x() const { return _path[0].x; }
  double y() const { return _path[0].y; }
  double width() { return (_path[1] - _path[0]).norm(); }
  double height() { return (_path[0] - _path[3]).norm(); }
  Point topLeft() { return Point( _path[0].x, _path[0].y ); }
  Point topRight() { return Point( _path[1].x, _path[1].y ); }
  Point bottomLeft() { return Point( _path[3].x, _path[3].y ); }
  Point bottomRight() { return Point( _path[2].x, _path[2].y ); }
 
 
  Rectangle rotated( double angle, const Point & center )  const;
  
  Rectangle rotated( double angle ) const;
 
  Rectangle translated( double dx, double dy ) const;
 
  Rectangle scaled( double sx, double sy ) const;
 
  Rectangle scaled( double s ) const;
 
  void scaleAll( double s );
 
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Rectangle * clone() const;
 
private:
  static const std::string _name; 
protected:
  bool _isRectangle;
};
 
 
 
struct Image : public Rectangle { 
  
  inline Image( double x0, double y0, double width, double height, 
    std::string fileName, int depthValue, double alpha=1.0 );
  const std::string & name() const;
 
  Image * clone() const;
  
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
     
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
 
private:
  static const std::string _name; 
protected:
  double _x0;      
  double _y0;      
  double _width;
  double _height;
  std::string _filename;
  double _alpha;
};
 
 
 
struct Triangle : public Polyline {
 
  Triangle( const Point & p1, const Point & p2, const Point & p3,
      DGtal::Color pen,
      DGtal::Color fill,
      double lineWidth,
      const LineStyle style = SolidStyle,
      const LineCap cap = ButtCap,
      const LineJoin join = MiterJoin,
      int depthValue = -1 )
    : Polyline( std::vector<Point>(), true, pen, fill, lineWidth, style, cap, join, depthValue ) {
    _path << p1;
    _path << p2;
    _path << p3;
  }
 
  Triangle( const double x1, const double y1, 
      const double x2, const double y2, 
      const double x3, const double y3,
      DGtal::Color pen,
      DGtal::Color fill,
      double lineWidth,
      const LineStyle style = SolidStyle,
      const LineCap cap = ButtCap,
      const LineJoin join = MiterJoin,
      int depthValue = -1 )
    : Polyline( std::vector<Point>(), true, pen, fill, lineWidth, style, cap, join, depthValue ) {
    _path << Point( x1, y1 );
    _path << Point( x2, y2 );
    _path << Point( x3, y3 );
  }
 
  const std::string & name() const;
 
  Triangle rotated( double angle ) const;
 
  Triangle translated( double dx, double dy ) const;
 
  Triangle scaled( double sx, double sy ) const;
 
  Triangle scaled( double s ) const;
 
  Triangle * clone() const;
  
private:
  static const std::string _name; 
protected:
};
 
struct QuadraticBezierCurve : public Triangle { 
  
  inline QuadraticBezierCurve( double x1, double y1, double x2, double y2, double x3, double y3,  
         DGtal::Color pen,
         DGtal::Color fill,
         double lineWidth,
         const LineStyle style = SolidStyle,
         const LineCap cap = ButtCap,
         const LineJoin join = MiterJoin,
         int depthValue = -1 )
    : Triangle(x1, y1, x2, y2, x3, y3, pen, fill, lineWidth, style, cap, join, depthValue) {}
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
  
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  const std::string & name() const;
 
private:
  static const std::string _name; 
};
 
struct GouraudTriangle : public Polyline {
 
 
  GouraudTriangle( const Point & p0, const DGtal::Color & color0,
       const Point & p1, const DGtal::Color & color1,
       const Point & p2, const DGtal::Color & color2,
       int subdivisions,
       int depth = -1 );
 
  GouraudTriangle( const Point & p0, float brightness0,
       const Point & p1, float brightness1,
       const Point & p2, float brightness2,
       const DGtal::Color & fillColor,
       int subdivisions,
       int depth = -1 );
 
  const std::string & name() const;
 
  Point center() const;
 
  GouraudTriangle & rotate( double angle, const Point & center );  
 
  GouraudTriangle rotated( double angle, const Point & center ) const;  
 
  GouraudTriangle & rotate( double angle );
 
  GouraudTriangle rotated( double angle ) const;
 
  GouraudTriangle translated( double dx, double dy ) const;
 
  GouraudTriangle scaled( double sx, double sy ) const;
 
  GouraudTriangle scaled( double s ) const;
 
 
  void scaleAll( double s );
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
 
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  GouraudTriangle * clone() const;
 
private:
  static const std::string _name; 
protected:
  DGtal::Color _color0;
  DGtal::Color _color1;
  DGtal::Color _color2;
  int _subdivisions;
};
 
struct Ellipse : public Shape {
  
  Ellipse( double x, double y, 
     double xRadius, double yRadius, 
     DGtal::Color pen, DGtal::Color fill,
     double lineWidth,
     const LineStyle lineStyle = SolidStyle,
     int depthValue = -1 )
    : Shape( pen, fill,
       lineWidth, lineStyle, ButtCap, MiterJoin, depthValue ),
      _center( x, y ), _xRadius( xRadius ), _yRadius( yRadius ),
      _angle( 0.0 ),
      _circle( false ) {
    while ( _angle > M_PI_2 ) _angle -= M_PI;
    while ( _angle < -M_PI_2 ) _angle += M_PI;
  }
 
  const std::string & name() const;
 
  Point center() const;
 
  Ellipse & rotate( double angle, const Point & center );
 
  Ellipse rotated( double angle, const Point & center ) const;
 
  Ellipse & rotate( double angle );
 
  Ellipse rotated( double angle ) const;
  
  Ellipse & translate( double dx, double dy );
 
  Ellipse translated( double dx, double dy ) const;
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
 
  Ellipse scaled( double sx, double sy ) const;
 
  Ellipse scaled( double s ) const;
  
  void scaleAll( double s );
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
 
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Rect boundingBox() const;
 
  Ellipse * clone() const;
 
private:
  static const std::string _name; 
protected:
  Point _center;
  double _xRadius; 
  double _yRadius;
  double _angle;
  bool _circle;
};
 
struct Circle : public Ellipse {
 
  Circle( double x, double y, double radius, 
    DGtal::Color pen, DGtal::Color fill,
    double lineWidth,
    const LineStyle style = SolidStyle,
    int depthValue = -1 )
    : Ellipse( x, y, radius, radius, pen, fill, lineWidth, style, depthValue )
  { _circle = true; }
 
  const std::string & name() const;
 
  Point center() const;
 
  Circle & rotate( double angle, const Point & center );
 
  Circle rotated( double angle, const Point & center ) const;
 
  Circle & rotate( double angle );
 
  Circle rotated( double angle ) const;
  
  Circle & translate( double dx, double dy );
 
  Circle translated( double dx, double dy ) const;
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
 
  Circle scaled( double sx, double sy ) const;
 
  Circle scaled( double s ) const;
 
  void scaleAll( double s );
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Circle * clone() const;
 
private:
  static const std::string _name; 
};
 
struct Arc : public Circle {
 
  Arc( double x, double y, double radius, double angle1, double angle2, bool negative,
    DGtal::Color pen, DGtal::Color fill,
    double lineWidth,
    const LineStyle style = SolidStyle,
    int depthValue = -1 )
    : Circle( x, y, radius, pen, fill, lineWidth, style, depthValue )
  { _angle1 = angle1; _angle2 = angle2; _negative = negative; }
 
  const std::string & name() const;
  void
  flushPostscript( std::ostream & stream,
                   const TransformEPS & transform ) const;
  void
  flushSVG( std::ostream & stream,
                   const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void
  flushTikZ( std::ostream & stream,
             const TransformTikZ & transform ) const;
 
private:
  static const std::string _name; 
protected:
  double _angle1;
  double _angle2;
  bool _negative;
};
 
 
struct Text : public Shape {
  
  Text( double x, double y,
  const std::string & text,
  const Fonts::Font font,
  double size,
  DGtal::Color color = DGtal::Color::Black,
  int depthValue = -1 )
    : Shape( color, DGtal::Color::None, 1.0, SolidStyle, ButtCap, MiterJoin, depthValue ),
      _position( x, y ), _text( text ), _font( font ),
      _angle( 0.0 ), _size( size ),
      _xScale( 1.0 ), _yScale( 1.0 ) { }
 
  
  Text( double x, double y,
  const std::string & text,
  const Fonts::Font font,
  const std::string & svgFont,
  double size,
  DGtal::Color color = DGtal::Color::Black,
  int depthValue = -1 )
    : Shape( color, DGtal::Color::None, 1.0, SolidStyle, ButtCap, MiterJoin, depthValue ),
      _position( x, y ),
      _text( text ), _font( font ), _svgFont( svgFont ),
      _angle( 0.0 ),
      _size( size ),
      _xScale( 1.0 ), _yScale( 1.0 ) { }
  
  const std::string & name() const;
 
  Point center() const;
 
  Text & rotate( double angle, const Point & center );
 
  Text rotated( double angle, const Point & center ) const;
 
  Text & rotate( double angle );
 
  Text rotated( double angle ) const;
  
  Text & translate( double dx, double dy );
 
  Text translated( double dx, double dy ) const;
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
 
  Text scaled( double sx, double sy ) const;
 
  Text scaled( double s ) const;
  
  void scaleAll( double s );
 
  void flushPostscript( std::ostream & stream,
      const TransformEPS & transform ) const;
 
  void flushFIG( std::ostream & stream,
     const TransformFIG & transform,
     std::map<DGtal::Color,int> & colormap ) const;
 
  void flushSVG( std::ostream & stream,
     const TransformSVG & transform ) const;
 
#ifdef WITH_CAIRO
  void flushCairo( cairo_t *cr,
     const TransformCairo & transform ) const;
#endif
 
  void flushTikZ( std::ostream & stream,
     const TransformTikZ & transform ) const;
 
  Rect boundingBox() const;
 
  Text * clone() const;
 
private:
  static const std::string _name; 
protected:
  Point _position;
  std::string _text;
  Fonts::Font _font;
  std::string _svgFont;
  double _angle;
  double _size;
  double _xScale;
  double _yScale;
};
 
bool shapeGreaterDepth( const Shape *s1, const Shape *s2 );
 
 
} // namespace LibBoard
 
/*
 * Inline methods
 */
#include "Shapes.ih"
 
 
#endif /* _SHAPE_H_ */