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:
  static const double Degree;
 
  enum class AspectRatio
  {
    Ignore,  
    Preserve 
  };
 
  Board(const Color & backgroundColor = Color::Null);
 
  Board(const Board & other);
 
  ~Board() override;
 
  Board & operator=(const Board & other);
 
  Board & operator<<(const Shape & shape);
 
  template <typename S> //
  Board & operator<<(const std::vector<S> & shapes);
 
  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::ExtremityType::Plain);
 
  void drawArrow(Point p, Point q, Arrow::ExtremityType type = Arrow::ExtremityType::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 setBackgroundColor(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 = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void save(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveEPS(std::ostream & out, PageSize size = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter, const std::string & title = std::string()) const;
 
  void saveEPS(const char * filename, PageSize size = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter, const std::string & title = std::string()) const;
 
  void saveEPS(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter, const std::string & title = std::string()) const;
 
  void saveEPS(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter, const std::string & title = std::string()) const;
 
  void saveFIG(const char * filename, PageSize size = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveFIG(std::ostream & out, PageSize size = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveFIG(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveFIG(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveSVG(const char * filename, PageSize size = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveSVG(std::ostream & out, PageSize size = PageSize::BoundingBox, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveSVG(const char * filename, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveSVG(std::ostream & out, double pageWidth, double pageHeight, double margin = 0.0, Unit unit = Unit::Millimeter) const;
 
  void saveTikZ(const char * filename, PageSize size = PageSize::BoundingBox, double margin = 0.0) const;
 
  void saveTikZ(std::ostream & out, PageSize size = PageSize::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);
 
  static Rect pageRect(PageSize size, Unit unit);
 
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,            //
             double margin = 0.0,            //
             const Color & penColor = Style::defaultPenColor(),   //
             const Color & fillColor = Style::defaultFillColor(), //
             double lineWidth = Style::defaultLineWidth(),        //
             LineStyle lineStyle = Style::defaultLineStyle(),     //
             int sketchyCount = 0);
 
Group tiling(const Shape & shape, Point topLeftCorner, int columns, int rows, double spacing = 0.0, LineWidthFlag lineWidthFlag = UseLineWidth);
 
Group circled(const Shape & shape, double margin = 0.0,                                               //
              Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(), //
              double lineWidth = Style::defaultLineWidth(), LineStyle lineStyle = Style::defaultLineStyle());
 
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);
}
 
template <typename S> //
Board & Board::operator<<(const std::vector<S> & shapes)
{
  return static_cast<Board &>(ShapeList::operator<<(shapes));
}
 
} // namespace LibBoard
 
// TODO : Add rectangle tilling from a vector of colors (2A array) ( https://github.com/c-koi/libboard/pull/7 )
 
#endif