Polyline.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef BOARD_POLYLINE_H
#define BOARD_POLYLINE_H
 
#include <board/ShapeWithStyle.h>
 
namespace LibBoard
{
 
struct Polyline : public ShapeWithStyle {
 
  inline Polyline(const std::vector<Point> & points, Path::OpenClosed openClosed, Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(),
                  double lineWidth = Style::defaultLineWidth(), const LineStyle lineStyle = Style::defaultLineStyle(), const LineCap cap = Style::defaultLineCap(),
                  const LineJoin join = Style::defaultLineJoin());
 
  inline Polyline(const std::vector<Point> & points, Path::OpenClosed openClosed, const Style & style);
 
  inline Polyline(const Path & path, Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(), double lineWidth = Style::defaultLineWidth(),
                  const LineStyle lineStyle = Style::defaultLineStyle(), const LineCap cap = Style::defaultLineCap(), const LineJoin join = Style::defaultLineJoin());
 
  inline Polyline(const Path & path, const Style & style);
 
  inline Polyline(Path::OpenClosed openClosed, Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(), double lineWidth = Style::defaultLineWidth(),
                  const LineStyle lineStyle = Style::defaultLineStyle(), const LineCap cap = Style::defaultLineCap(), const LineJoin join = Style::defaultLineJoin());
 
  inline Polyline(Path::OpenClosed openClosed, const Style & style);
 
  const std::string & name() const override;
 
  Polyline & operator<<(const Point & p);
 
  Point & operator[](const std::size_t n) { return _path[n]; }
 
  const Point & operator[](const std::size_t n) const { return _path[n]; }
 
  Polyline & rotate(double angle, const Point & center) override;
 
  Polyline rotated(double angle, const Point & center) const;
 
  Polyline & rotate(double angle) override;
 
  Polyline rotated(double angle) const;
 
  Polyline & translate(double dx, double dy) override;
 
  Polyline translated(double dx, double dy) const;
 
  Polyline & scale(double sx, double sy) override;
 
  Polyline & scale(double s) override;
 
  Polyline scaled(double sx, double sy) const;
 
  Polyline scaled(double s) const;
 
  void scaleAll(double s) override;
 
  Polyline resized(double w, double h, LineWidthFlag lineWidthFlag) const;
 
  void addHole(const Path & path);
 
  void flushPostscript(std::ostream & stream, const TransformEPS & transform) const override;
 
  void flushFIG(std::ostream & stream, const TransformFIG & transform, std::map<Color, int> & colormap) const override;
 
  void flushSVG(std::ostream & stream, const TransformSVG & transform) const override;
 
  void flushTikZ(std::ostream & stream, const TransformTikZ & transform) const override;
 
  virtual void accept(ShapeVisitor & visitor) override;
 
  virtual void accept(const ShapeVisitor & visitor) override;
 
  virtual void accept(ConstShapeVisitor & visitor) const override;
 
  virtual void accept(const ConstShapeVisitor & visitor) const override;
 
  virtual Shape * accept(CompositeShapeTransform & transform) const override;
 
  virtual Shape * accept(const CompositeShapeTransform & transform) const override;
 
  Rect boundingBox(LineWidthFlag) const override;
 
  Polyline * clone() const override;
 
  inline std::size_t vertexCount() const;
 
  inline const Path & path() const;
 
  void setRectangleFlag();
 
  Polyline(const Polyline &) = default;
  Polyline(Polyline &&) = default;
  Polyline & operator=(Polyline &&) = default;
  Polyline & operator=(const Polyline &) = default;
  ~Polyline() override = default;
 
private:
  static const std::string _name; 
  bool _isCreatedRectangle;
  void flushRectangleFIG(std::ostream & stream, const TransformFIG & transform, std::map<Color, int> & colormap) const;
  void flushRectangleSVG(std::ostream & stream, const TransformSVG & transform) const;
 
protected:
  Path _path;
  std::vector<Path> _holes;
};
 
Polyline rectangle(double left, double top, double width, double height, Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(),
                   double lineWidth = Style::defaultLineWidth(), const LineStyle lineStyle = Style::defaultLineStyle(), const LineCap cap = Style::defaultLineCap(),
                   const LineJoin join = Style::defaultLineJoin());
 
Polyline rectangle(double left, double top, double width, double height, const Style & style);
 
Polyline rectangle(const Rect & rect, Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(), double lineWidth = Style::defaultLineWidth(),
                   const LineStyle lineStyle = Style::defaultLineStyle(), const LineCap cap = Style::defaultLineCap(), const LineJoin join = Style::defaultLineJoin());
 
Polyline rectangle(const Rect & rect, const Style & style);
 
Polyline triangle(const Point & p1, const Point & p2, const Point & p3, Color penColor = Style::defaultPenColor(), Color fillColor = Style::defaultFillColor(),
                  double lineWidth = Style::defaultLineWidth(), const LineStyle lineStyle = Style::defaultLineStyle(), const LineCap cap = Style::defaultLineCap(),
                  const LineJoin join = Style::defaultLineJoin());
 
Polyline triangle(const double x1, const double y1, const double x2, const double y2, const double x3, const double y3, Color penColor = Style::defaultPenColor(),
                  Color fillColor = Style::defaultFillColor(), double lineWidth = Style::defaultLineWidth(), const LineStyle lineStyle = Style::defaultLineStyle(),
                  const LineCap cap = Style::defaultLineCap(), const LineJoin join = Style::defaultLineJoin());
 
Polyline triangle(const Point & p1, const Point & p2, const Point & p3, const Style & style);
 
struct GouraudTriangle : public Polyline {
 
  GouraudTriangle(const Point & p0, const Color & color0, const Point & p1, const Color & color1, const Point & p2, const Color & color2, int subdivisions);
 
  GouraudTriangle(const Point & p0, float brightness0, const Point & p1, float brightness1, const Point & p2, float brightness2, const Color & fillColor, int subdivisions);
 
  const std::string & name() const override;
 
  GouraudTriangle & rotate(double angle, const Point & center) override;
 
  GouraudTriangle rotated(double angle, const Point & center) const;
 
  GouraudTriangle & rotate(double angle) override;
 
  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) override;
 
  GouraudTriangle resized(double w, double h, LineWidthFlag lineWidthFlag) const;
 
  void flushPostscript(std::ostream & stream, const TransformEPS & transform) const override;
 
  void flushFIG(std::ostream & stream, const TransformFIG & transform, std::map<Color, int> & colormap) const override;
 
  void flushSVG(std::ostream & stream, const TransformSVG & transform) const override;
 
  void flushTikZ(std::ostream & stream, const TransformTikZ & transform) const override;
 
  GouraudTriangle * clone() const override;
 
private:
  static const std::string _name; 
protected:
  Color _color0;
  Color _color1;
  Color _color2;
  int _subdivisions;
};
 
Polyline mix(const Polyline & a, const Polyline & b, double time);
 
} // namespace LibBoard
 
/*
 * Inline methods
 */
namespace LibBoard
{
 
Polyline::Polyline(const std::vector<Point> & points, Path::OpenClosed openClosed, //
                   Color penColor, Color fillColor, double lineWidth,              //
                   const LineStyle lineStyle, const LineCap cap, const LineJoin join)
    : ShapeWithStyle(penColor, fillColor, lineWidth, lineStyle, cap, join), _path(points, openClosed)
{
  _isCreatedRectangle = false;
}
 
Polyline::Polyline(const std::vector<Point> & points, Path::OpenClosed openClosed, const Style & style) //
    : ShapeWithStyle(style), _path(points, openClosed)
{
  _isCreatedRectangle = false;
}
 
Polyline::Polyline(const Path & path, Color penColor, Color fillColor, //
                   double lineWidth, const LineStyle lineStyle, const LineCap cap, const LineJoin join)
    : ShapeWithStyle(penColor, fillColor, lineWidth, lineStyle, cap, join), _path(path)
{
  _isCreatedRectangle = false;
}
 
Polyline::Polyline(const Path & path, const Style & style) //
    : ShapeWithStyle(style), _path(path)
{
  _isCreatedRectangle = false;
}
 
Polyline::Polyline(Path::OpenClosed openClosed, Color penColor, Color fillColor, double lineWidth, //
                   const LineStyle lineStyle, const LineCap cap, const LineJoin join)
    : ShapeWithStyle(penColor, fillColor, lineWidth, lineStyle, cap, join), _path(openClosed)
{
  _isCreatedRectangle = false;
}
 
Polyline::Polyline(Path::OpenClosed openClosed, const Style & style) //
    : ShapeWithStyle(style), _path(openClosed)
{
  _isCreatedRectangle = false;
}
 
std::size_t Polyline::vertexCount() const
{
  return _path.size();
}
 
const Path & Polyline::path() const
{
  return _path;
}
} // namespace LibBoard
 
#endif /* BOARD_POLYLINE_H */