/mnt/nas/libepaper/include/epaper/draw/builders.hpp

Fluent builder for constructing LineCommand.

Fluent builder for constructing LineCommand.Provides a fluent interface for specifying line drawing parameters. Call build() to produce a LineCommand that can be passed to Display::draw().

Method Overloads:

• Coordinate setters accept both Point and (x, y) pairs for flexibility
• All parameters optional with sensible defaults (Black, 1x1 width, Solid style)

Defaults:

• from: (0, 0)
• to: (0, 0)
• color: Black
• width: Pixel1x1
• style: Solid

// Minimal usage (uses defaults)
auto cmd1 = LineBuilder().from({10, 10}).to({100, 100}).build();
 
// Full specification
auto cmd2 = LineBuilder()
    .from({10, 10})
    .to({100, 100})
    .color(Color::Black)
    .width(DotPixel::Pixel2x2)
    .style(LineStyle::Dotted)
    .build();
display.draw(cmd2);
 
// Using coordinate pairs instead of Point
auto cmd3 = LineBuilder().from(0, 0).to(100, 100).build();
 
// Applying reusable style
LineStyleSpec dashed_red{Color::Red, DotPixel::Pixel1x1, LineStyle::Dotted};
auto cmd4 = LineBuilder().from(a).to(b).with_style(dashed_red).build();

See also

LineCommand, LineStyleSpec, Display::draw()

#pragma once
 
#include "epaper/core/geometry.hpp"
#include "epaper/draw/commands.hpp"
#include "epaper/draw/styles.hpp"
#include "epaper/graphics/font.hpp"
#include <cstdint>
#include <string>
#include <string_view>
 
namespace epaper {
 
class LineBuilder {
public:
  LineBuilder() noexcept = default;
 
  auto from(Point pt) noexcept -> LineBuilder & {
    from_ = pt;
    return *this;
  }
 
  auto from(std::size_t x, std::size_t y) noexcept -> LineBuilder & {
    from_ = Point{x, y};
    return *this;
  }
 
  auto to(Point pt) noexcept -> LineBuilder & {
    to_ = pt;
    return *this;
  }
 
  auto to(std::size_t x, std::size_t y) noexcept -> LineBuilder & {
    to_ = Point{x, y};
    return *this;
  }
 
  auto color(Color c) noexcept -> LineBuilder & {
    color_ = c;
    return *this;
  }
 
  auto width(DotPixel w) noexcept -> LineBuilder & {
    width_ = w;
    return *this;
  }
 
  auto style(LineStyle s) noexcept -> LineBuilder & {
    style_ = s;
    return *this;
  }
 
  auto with_style(const LineStyleSpec &line_style) noexcept -> LineBuilder & {
    color_ = line_style.color;
    width_ = line_style.width;
    style_ = line_style.style;
    return *this;
  }
 
  [[nodiscard]] auto build() const noexcept -> LineCommand { return LineCommand{from_, to_, color_, width_, style_}; }
 
private:
  Point from_{0, 0};
  Point to_{0, 0};
  Color color_ = Color::Black;
  DotPixel width_ = DotPixel::Pixel1x1;
  LineStyle style_ = LineStyle::Solid;
};
 
class RectangleBuilder {
public:
  RectangleBuilder() noexcept = default;
 
  auto top_left(Point pt) noexcept -> RectangleBuilder & {
    top_left_ = pt;
    return *this;
  }
 
  auto top_left(std::size_t x, std::size_t y) noexcept -> RectangleBuilder & {
    top_left_ = Point{x, y};
    return *this;
  }
 
  auto bottom_right(Point pt) noexcept -> RectangleBuilder & {
    bottom_right_ = pt;
    return *this;
  }
 
  auto bottom_right(std::size_t x, std::size_t y) noexcept -> RectangleBuilder & {
    bottom_right_ = Point{x, y};
    return *this;
  }
 
  auto at(Point pt) noexcept -> RectangleBuilder & {
    top_left_ = pt;
    return *this;
  }
 
  auto at(std::size_t x, std::size_t y) noexcept -> RectangleBuilder & {
    top_left_ = Point{x, y};
    return *this;
  }
 
  auto size(Size sz) noexcept -> RectangleBuilder & {
    bottom_right_ = Point{top_left_.x + sz.width, top_left_.y + sz.height};
    return *this;
  }
 
  auto size(std::size_t w, std::size_t h) noexcept -> RectangleBuilder & {
    bottom_right_ = Point{top_left_.x + w, top_left_.y + h};
    return *this;
  }
 
  auto color(Color c) noexcept -> RectangleBuilder & {
    color_ = c;
    return *this;
  }
 
  auto border_width(DotPixel w) noexcept -> RectangleBuilder & {
    border_width_ = w;
    return *this;
  }
 
  auto fill(DrawFill f) noexcept -> RectangleBuilder & {
    fill_ = f;
    return *this;
  }
 
  auto with_style(const ShapeStyleSpec &shape_style) noexcept -> RectangleBuilder & {
    color_ = shape_style.color;
    border_width_ = shape_style.border_width;
    fill_ = shape_style.fill;
    return *this;
  }
 
  [[nodiscard]] auto build() const noexcept -> RectangleCommand {
    return RectangleCommand{top_left_, bottom_right_, color_, border_width_, fill_};
  }
 
private:
  Point top_left_{0, 0};
  Point bottom_right_{0, 0};
  Color color_ = Color::Black;
  DotPixel border_width_ = DotPixel::Pixel1x1;
  DrawFill fill_ = DrawFill::Empty;
};
 
class CircleBuilder {
public:
  CircleBuilder() noexcept = default;
 
  auto center(Point pt) noexcept -> CircleBuilder & {
    center_ = pt;
    return *this;
  }
 
  auto center(std::size_t x, std::size_t y) noexcept -> CircleBuilder & {
    center_ = Point{x, y};
    return *this;
  }
 
  auto radius(std::size_t r) noexcept -> CircleBuilder & {
    radius_ = r;
    return *this;
  }
 
  auto color(Color c) noexcept -> CircleBuilder & {
    color_ = c;
    return *this;
  }
 
  auto border_width(DotPixel w) noexcept -> CircleBuilder & {
    border_width_ = w;
    return *this;
  }
 
  auto fill(DrawFill f) noexcept -> CircleBuilder & {
    fill_ = f;
    return *this;
  }
 
  auto with_style(const ShapeStyleSpec &shape_style) noexcept -> CircleBuilder & {
    color_ = shape_style.color;
    border_width_ = shape_style.border_width;
    fill_ = shape_style.fill;
    return *this;
  }
 
  [[nodiscard]] auto build() const noexcept -> CircleCommand {
    return CircleCommand{center_, radius_, color_, border_width_, fill_};
  }
 
private:
  Point center_{0, 0};
  std::size_t radius_ = 0;
  Color color_ = Color::Black;
  DotPixel border_width_ = DotPixel::Pixel1x1;
  DrawFill fill_ = DrawFill::Empty;
};
 
class PointBuilder {
public:
  PointBuilder() noexcept = default;
 
  auto at(Point pt) noexcept -> PointBuilder & {
    position_ = pt;
    return *this;
  }
 
  auto at(std::size_t x, std::size_t y) noexcept -> PointBuilder & {
    position_ = Point{x, y};
    return *this;
  }
 
  auto color(Color c) noexcept -> PointBuilder & {
    color_ = c;
    return *this;
  }
 
  auto size(DotPixel s) noexcept -> PointBuilder & {
    pixel_size_ = s;
    return *this;
  }
 
  [[nodiscard]] auto build() const noexcept -> PointCommand { return PointCommand{position_, color_, pixel_size_}; }
 
private:
  Point position_{0, 0};
  Color color_ = Color::Black;
  DotPixel pixel_size_ = DotPixel::Pixel1x1;
};
 
class TextBuilder {
public:
  TextBuilder() noexcept : content_type_(TextContent::String), number_(0), decimal_(0.0), decimal_places_(0) {}
 
  explicit TextBuilder(std::string_view txt) noexcept
      : text_(txt), content_type_(TextContent::String), number_(0), decimal_(0.0), decimal_places_(0) {}
 
  auto text(std::string_view txt) noexcept -> TextBuilder & {
    text_ = txt;
    content_type_ = TextContent::String;
    return *this;
  }
 
  auto number(std::int32_t num) noexcept -> TextBuilder & {
    number_ = num;
    content_type_ = TextContent::Number;
    return *this;
  }
 
  auto decimal(double dec, std::uint8_t places) noexcept -> TextBuilder & {
    decimal_ = dec;
    decimal_places_ = places;
    content_type_ = TextContent::Decimal;
    return *this;
  }
 
  auto at(Point pt) noexcept -> TextBuilder & {
    position_ = pt;
    return *this;
  }
 
  auto at(std::size_t x, std::size_t y) noexcept -> TextBuilder & {
    position_ = Point{x, y};
    return *this;
  }
 
  auto font(const Font *f) noexcept -> TextBuilder & {
    font_ = f;
    return *this;
  }
 
  auto foreground(Color c) noexcept -> TextBuilder & {
    foreground_ = c;
    return *this;
  }
 
  auto background(Color c) noexcept -> TextBuilder & {
    background_ = c;
    return *this;
  }
 
  auto with_style(const TextStyleSpec &text_style) noexcept -> TextBuilder & {
    font_ = text_style.font;
    foreground_ = text_style.foreground;
    background_ = text_style.background;
    return *this;
  }
 
  [[nodiscard]] auto build() const -> TextCommand {
    switch (content_type_) {
    case TextContent::String:
      return TextCommand{position_, text_, font_, foreground_, background_};
    case TextContent::Number:
      return TextCommand{position_, number_, font_, foreground_, background_};
    case TextContent::Decimal:
      return TextCommand{position_, decimal_, decimal_places_, font_, foreground_, background_};
    }
    // Should never reach here, but return string version as fallback
    return TextCommand{position_, text_, font_, foreground_, background_};
  }
 
private:
  Point position_{0, 0};
  std::string text_;
  const Font *font_ = nullptr;
  Color foreground_ = Color::Black;
  Color background_ = Color::White;
  TextContent content_type_;
  std::int32_t number_;
  double decimal_;
  std::uint8_t decimal_places_;
};
 
} // namespace epaper