Board.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef _BOARD_BOARD_H_
#define _BOARD_BOARD_H_

#include <ostream>
#include <string>
#include <vector>

#include "board/Point.h"
#include "board/Path.h"
#include "board/Shapes.h"
#include "board/Image.h"
#include "board/ShapeList.h"

namespace LibBoard {

class Board : public ShapeList {
  
public:

  enum PageSize { BoundingBox = 0,
                  A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
                  Letter, Legal, Executive };

  enum Unit { UPoint, UInche, UCentimeter, UMillimeter };
  static const double Degree;
  
  Board( const Color & backgroundColor = Color::None );

  Board( const Board & other );

  ~Board();

  Board & operator=( const Board & other );


  Board & operator<<( const Shape & shape );

  Board & operator<<( Unit unit );
  
  void clear( const Color & color = Color::None );

  inline void clear( unsigned char red, unsigned char green, unsigned char blue );



  Board & rotate( double angle, const Point & center );

  Board & rotate( double angle );

  Board & translate( double dx, double dy );

  Board & scale( double sx, double sy );

  Board & scale( double s );

  Board rotated( double angle, const Point & center );

  Board rotated( double angle );

  Board translated( double dx, double dy );

  Board scaled( double sx, double sy );

  Board scaled( double s );



  void setUnit( Unit unit );

  void setUnit( double factor, Unit unit );

  void drawDot( double x, double y, int depth = -1 );

  void drawLine( double x1, double y1, double x2, double y2,
                 int depth = -1 );

  void drawArrow( double x1, double y1, double x2, double y2,
                  bool filled = true,
                  int depth = -1 );

  void drawTriangle( double x1, double y1,
                     double x2, double y2,
                     double x3, double y3,
                     int depth = -1 );

  void drawTriangle( const Point & p1,
                     const Point & p2,
                     const Point & p3,
                     int depth = -1 );

  void fillTriangle( double x1, double y1,
                     double x2, double y2,
                     double x3, double y3,
                     int depth = -1 );

  void fillGouraudTriangle( const Point & p1,
                            const Color & color1,
                            const Point & p2,
                            const Color & color2,
                            const Point & p3,
                            const Color & color3,
                            unsigned char divisions = 3,
                            int depth = -1 );

  inline void fillGouraudTriangle( const double x1, const double y1,
                                   const Color & color1,
                                   const double x2, const double y2,
                                   const Color & color2,
                                   const double x3, const double y3,
                                   const Color & color3,
                                   unsigned char divisions = 3,
                                   int depth = -1 );

  void fillGouraudTriangle( const Point & p1,
                            const float brightness1,
                            const Point & p2,
                            const float brightness2,
                            const Point & p3,
                            const float brightness3,
                            unsigned char divisions = 3,
                            int depth = -1 );

  inline void fillGouraudTriangle( const double x1, const double y1,
                                   const float brightness1,
                                   const double x2, const double y2,
                                   const float brightness2,
                                   const double x3, const double y3,
                                   const float brightness3,
                                   unsigned char divisions = 3,
                                   int depth = -1 );


  void fillTriangle( const Point & p1,
                     const Point & p2,
                     const Point & p3,
                     int depth = -1 );
  
  void drawRectangle( double left, double top,
                      double width, double height,
                      int depth = -1 );

  void fillRectangle( double left, double top,
                      double width, double height,
                      int depth = -1 );

  void drawCircle( double x, double y, double radius,
                   int depth = -1 );

  void fillCircle( double x, double y, double radius,
                   int depth = -1);

  void drawEllipse( double x, double y,
                    double xRadius, double yRadius,
                    int depth = -1);

  void fillEllipse( double x, double y,
                    double xRadius, double yRadius,
                    int depth = -1);

  void drawPolyline( const std::vector<Point> & points,
                     int depth = -1 );
  
  void drawClosedPolyline( const std::vector<Point> & points,
                           int depth = -1 );

  void fillPolyline( const std::vector<Point> & points,
                     int depth = -1 );

  void drawText( double x, double y, const char * text,
                 int depth = -1 );

  void drawText( double x, double y, const std::string & str,
                 int depth = -1 );

  Board & setFont( const Fonts::Font font, double fontSize );
  
  Board & setFontSize( double fontSize );

  Board & setPenColorRGBi( unsigned char red,
                           unsigned char green,
                           unsigned char blue,
                           unsigned char alpha = 255 );

  Board & setPenColorRGBf(  float red,
                            float green,
                            float blue,
                            float alpha = 1.0f );

  Board & setPenColor( const Color & color );
  

  Board & setFillColorRGBi( unsigned char red,
                            unsigned char green,
                            unsigned char blue,
                            unsigned char alpha = 255 );
  
  Board & setFillColorRGBf( float red, float green, float blue, float alpha = 1.0f );

  Board & setFillColor( const Color & color );
  
  Board & setLineWidth( double width );

  Board & setLineStyle( Shape::LineStyle style );
  
  inline Board & setLineCap( Shape::LineCap cap );

  inline Board & setLineJoin( Shape::LineJoin join );

  void backgroundColor( const Color & color );

  void drawBoundingBox( int depth = -1 );

  void setClippingRectangle(  double x, double y,
                              double width, double height );

  void setClippingPath(  const std::vector<Point> & points  );

  void setClippingPath( const Path & path );

  void addDuplicates( const Shape & shape,
                      std::size_t times,
                      double dx,
                      double dy,
                      double scale = 1.0 );

  void addDuplicates( const Shape & shape,
                      std::size_t times,
                      double dx, double dy,
                      double scaleX, double scaleY,
                      double angle = 0.0 );

  void save( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;
  
  void save( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const;

  void saveEPS( std::ostream & out, PageSize size = Board::BoundingBox, double margin = 10.0, const std::string & title = std::string() ) const ;

  void saveEPS( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0, const std::string & title = std::string() ) const ;

  void saveEPS( std::ostream & out, double pageWidth, double pageHeight, double margin = 10.0, const std::string & title = std::string() ) const ;

  void saveEPS( const char * filename, double pageWidth, double pageHeight, double margin = 10.0, const std::string & title = std::string()  ) const ;

  void saveFIG( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;

  void saveFIG( std::ostream & out, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;

  void saveFIG( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const ;

  void saveFIG( std::ostream & out, double pageWidth, double pageHeight, double margin = 10.0 ) const ;

  void saveSVG( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;

  void saveSVG( std::ostream & out, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;

  void saveSVG( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const ;

  void saveSVG( std::ostream & out, double pageWidth, double pageHeight, double margin = 10.0 ) const ;

  void saveTikZ( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;

  void saveTikZ( std::ostream & out, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;

  void saveTikZ( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const ;

  void saveTikZ( std::ostream & out, double pageWidth, double pageHeight, double margin = 10.0 ) const ;


  static Group makeGrid(Point topLeft, size_t columns, size_t rows,
                        double width, double height,
                        Color penColor, Color fillColor,
                        double lineWidth,
                        const LineStyle style = SolidStyle,
                        const LineCap cap = ButtCap,
                        const LineJoin join = MiterJoin,
                        int depth = -1 );

protected:
  
  struct State {
    Color penColor;             
    Color fillColor;            
    double lineWidth;           
    Shape::LineStyle lineStyle; 
    Shape::LineCap lineCap;     
    Shape::LineJoin lineJoin;   
    Fonts::Font font;           
    double fontSize;            
    double unitFactor;          
    State();
    double unit( const double & x ) { return x * unitFactor; }
    Point unit( const Point & p ) { return Point( p.x * unitFactor, p.y * unitFactor); }
    void unit( Shape & shape ) {  shape.scaleAll( unitFactor ); }
  };
  State _state;                 
  Color _backgroundColor;       
  Path _clippingPath;
};
} // namespace LibBoard

#include "board/Board.ih"

#endif