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 "BoardConfig.h"
#include "board/Arrow.h"
#include "board/Bezier.h"
#include "board/BoardFontText.h"
#include "board/Dot.h"
#include "board/Ellipse.h"
#include "board/Exception.h"
#include "board/Group.h"
#include "board/Image.h"
#include "board/Line.h"
#include "board/Path.h"
#include "board/Point.h"
#include "board/Polyline.h"
#include "board/RoughVisitor.h"
#include "board/Shape.h"
#include "board/ShapeList.h"
#include "board/SketchFilter.h"
#include "board/Style.h"
#include "board/Text.h"
 
namespace LibBoard
{
 
struct 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;
 
  enum AspectRatioFlag
  {
    IgnoreAspectRatio,
    KeepAspectRatio
  };
 
  Board(const Color & backgroundColor = Color::Null);
 
  Board(const Board & other);
 
  ~Board() override;
 
  Board & operator=(const Board & other);
 
  Board & operator<<(const Shape & shape);
 
  void clear(const Color & color = Color::Null);
 
  inline void clear(unsigned char red, unsigned char green, unsigned char blue);
 
  Board & rotate(double angle, const Point & center) override;
 
  Board & rotate(double angle) override;
 
  Board & translate(double dx, double dy) override;
 
  Board & scale(double sx, double sy) override;
 
  Board & scale(double s) override;
 
  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 drawDot(double x, double y);
 
  void drawLine(double x1, double y1, double x2, double y2);
 
  void drawLine(Point p, Point q);
 
  void drawArrow(double x1, double y1, double x2, double y2, Arrow::ExtremityType type = Arrow::Plain);
 
  void drawArrow(Point p, Point q, Arrow::ExtremityType type = Arrow::Plain);
 
  void drawTriangle(double x1, double y1, double x2, double y2, double x3, double y3);
 
  void drawTriangle(const Point & p1, const Point & p2, const Point & p3);
 
  void fillTriangle(double x1, double y1, double x2, double y2, double x3, double y3);
 
  void fillGouraudTriangle(const Point & p1, const Color & color1, //
                           const Point & p2, const Color & color2, //
                           const Point & p3, const Color & color3, unsigned char divisions = 3);
 
  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);
 
  void fillGouraudTriangle(const Point & p1, const float brightness1, //
                           const Point & p2, const float brightness2, //
                           const Point & p3, const float brightness3, unsigned char divisions = 3);
 
  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);
 
  void fillTriangle(const Point & p1, const Point & p2, const Point & p3);
 
  void drawRectangle(double left, double top, double width, double height);
 
  void drawRectangle(const Rect & rect);
 
  void fillRectangle(double left, double top, double width, double height);
 
  void fillRectangle(const Rect & rect);
 
  void drawCircle(double x, double y, double radius);
 
  void fillCircle(double x, double y, double radius);
 
  void drawEllipse(double x, double y, double xRadius, double yRadius);
 
  void fillEllipse(double x, double y, double xRadius, double yRadius);
 
  void drawPolyline(const std::vector<Point> & points);
 
  void drawClosedPolyline(const std::vector<Point> & points);
 
  void fillPolyline(const std::vector<Point> & points);
 
  void drawText(double x, double y, const char * text);
 
  void drawText(Point p, const char * text);
 
  void drawText(double x, double y, const std::string & text);
 
  void drawText(Point p, const std::string & str);
 
  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 & setFillColorHSV(float hue, float saturation, float value, float alpha = 1.0f);
 
  Board & setFillColor(const Color & color);
 
  Board & setLineWidth(double width);
 
  Board & setLineStyle(LineStyle style);
 
  inline Board & setLineCap(LineCap cap);
 
  inline Board & setLineJoin(LineJoin join);
 
  void backgroundColor(const Color & color);
 
  void drawBoundingBox(LineWidthFlag lineWidthFlag);
 
  void setClippingRectangle(double x, double y, double width, double height);
 
  void setClippingRectangle(const Rect & rect);
 
  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 = 0.0, Unit unit = UMillimeter) const;
 
  void save(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveEPS(std::ostream & out, PageSize size = Board::BoundingBox, double margin = 0.0, Unit unit = UMillimeter, const std::string & title = std::string()) const;
 
  void saveEPS(const char * filename, PageSize size = Board::BoundingBox, double margin = 0.0, Unit unit = UMillimeter, const std::string & title = std::string()) const;
 
  void saveEPS(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter, const std::string & title = std::string()) const;
 
  void saveEPS(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter, const std::string & title = std::string()) const;
 
  void saveFIG(const char * filename, PageSize size = Board::BoundingBox, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveFIG(std::ostream & out, PageSize size = Board::BoundingBox, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveFIG(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveFIG(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveSVG(const char * filename, PageSize size = Board::BoundingBox, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveSVG(std::ostream & out, PageSize size = Board::BoundingBox, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveSVG(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveSVG(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = UMillimeter) const;
 
  void saveTikZ(const char * filename, PageSize size = Board::BoundingBox, double margin = 0.0) const;
 
  void saveTikZ(std::ostream & out, PageSize size = Board::BoundingBox, double margin = 0.0) const;
 
  void saveTikZ(const char * filename, double pageWidth, double pageHeight, double margin = 0.0) const;
 
  void saveTikZ(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0) const;
 
  inline const Color & penColor() const;
 
  inline const Color & fillColor() const;
 
  inline const Style & style() const;
 
  static void enableLineWidthScaling();
 
  static void disableLineWidthScaling();
 
  static void setLineWidthScaling(bool);
 
protected:
  static double toMillimeter(double x, Unit unit);
 
  struct State {
    Style style;      
    Fonts::Font font; 
    double fontSize;  
    State();
  };
  State _state;           
  Color _backgroundColor; 
  Path _clippingPath;
};
 
// Helper functions
 
Group grid(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);
 
Group grid(Point topLeft, size_t columns, size_t rows, double width, double height, const Style & style = Style::defaultStyle());
 
Group cross(Point p, const Style & style = Style::defaultStyle());
 
Group array(Point topLeft, const std::vector<Color> & colors, unsigned int columns, unsigned int rows, double pixelWidth, double pixelHeight = 0.0, double lineWidth = 0.0);
 
Group framed(const Shape & shape, const Color & color = Style::defaultPenColor(), double lineWidth = Style::defaultLineWidth(), double margin = 0.0, int sketchyCount = 0);
 
Polyline bezierControls(const Bezier & bezier, const Style & style = Style::defaultStyle());
 
// Inline methods and functions
 
inline void Board::clear(unsigned char red, unsigned char green, unsigned char blue)
{
  clear(Color(red, green, blue));
}
 
inline Board & Board::setLineStyle(LineStyle style)
{
  _state.style.lineStyle = style;
  return *this;
}
 
inline Board & Board::setLineCap(LineCap cap)
{
  _state.style.lineCap = cap;
  return *this;
}
 
inline Board & Board::setLineJoin(LineJoin join)
{
  _state.style.lineJoin = join;
  return *this;
}
 
const Color & Board::penColor() const
{
  return _state.style.penColor;
}
 
const Color & Board::fillColor() const
{
  return _state.style.fillColor;
}
 
const Style & Board::style() const
{
  return _state.style;
}
 
inline void Board::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)
{
  fillGouraudTriangle(Point(x1, y1), color1, Point(x2, y2), color2, Point(x3, y3), color3, divisions);
}
 
inline void Board::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)
{
  fillGouraudTriangle(Point(x1, y1), brightness1, Point(x2, y2), brightness2, Point(x3, y3), brightness3, divisions);
}
 
} // namespace LibBoard
 
// TODO : Add rectangle tilling from a vector of colors (2A array) ( https://github.com/c-koi/libboard/pull/7 )
 
#endif