relative_point.hpp

Go to the documentation of this file.

#pragma once
 
// RelativePoint — expression-based positioning primitive.
//
// Pulp's flex + grid layout covers most authored layouts; RelativePoint
// fills the remaining "I want this anchored to another element's edge" cases
// without forcing a full constraint solver.
//
// Grammar:
//
//   point      ::= expr ',' expr             // (x, y) pair
//   expr       ::= term  (('+' | '-') term)*
//   term       ::= factor (('*' | '/') factor)*
//   factor     ::= number
//                | identifier               // 'left', 'right', 'top', 'bottom',
//                                           //   'width', 'height',
//                                           //   'centerx', 'centery'
//                | qualified                // <name>.<identifier> e.g.
//                                           //   parent.right, prev.left
//                | '(' expr ')'
//                | '-' factor                // unary minus
//   number     ::= [0-9]+ ('.' [0-9]+)?
//   identifier ::= [a-zA-Z_][a-zA-Z0-9_]*
//   qualified  ::= identifier '.' identifier
//
// Built-in names (unqualified) refer to the `parent` rectangle. Qualified
// names route to the `named` map at evaluate time. Unknown qualified
// names cause `evaluate()` to throw — that's a runtime error, not a
// parse error, because the named-rect environment is only known at
// layout time.
//
// Numeric values are treated as device pixels (no DimensionUnit support —
// keep this primitive narrow; if you need %/vw/vh, compose with the
// existing Dimension type at the caller).
 
#include "pulp/view/geometry.hpp"
 
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <variant>
#include <vector>
 
namespace pulp::view {
 
class RelativeExpression {
public:
    float evaluate(const Rect& parent,
                   const std::map<std::string, Rect>& named = {}) const;

    std::string to_string() const;

    static float evaluate(const std::string& source,
                          const Rect& parent,
                          const std::map<std::string, Rect>& named = {});

    static RelativeExpression parse(const std::string& source);
 
    // Internal AST node (public for to_string traversal). Hidden from
    // generic consumers behind opaque ptr.
    struct Node;
 
private:
    explicit RelativeExpression(std::shared_ptr<Node> root) : root_(std::move(root)) {}
    std::shared_ptr<Node> root_;
};
 
class RelativePoint {
public:
    static RelativePoint parse(const std::string& source);

    Point evaluate(const Rect& parent,
                   const std::map<std::string, Rect>& named = {}) const;
 
    const RelativeExpression& x() const noexcept { return x_; }
    const RelativeExpression& y() const noexcept { return y_; }
 
private:
    RelativePoint(RelativeExpression x, RelativeExpression y)
        : x_(std::move(x)), y_(std::move(y)) {}
    RelativeExpression x_;
    RelativeExpression y_;
};
 
} // namespace pulp::view