shape.cpp

#include "shape.h"

#include <QJsonValue>
#include <QPainterPathStroker>
#include <QUuid>

#include <algorithm>

namespace {

qreal clampScale(qreal value) {
    return std::clamp(value, 0.1, 20.0);
}

} // namespace

bool operator==(const ShapeStyle& lhs, const ShapeStyle& rhs) {
    return lhs.strokeColor == rhs.strokeColor
        && lhs.fillColor == rhs.fillColor
        && lhs.penWidth == rhs.penWidth;
}

bool ShapeSeed::isValid() const {
    return !geometry.isEmpty();
}

void Shape::regenerateId() {
    id = createShapeId();
}

void Shape::bindDefinition(const IShapeDefinition* shapeDefinition) {
    definition = shapeDefinition;
}

QString Shape::displayName() const {
    return definition ? definition->displayName() : typeId;
}

bool Shape::supportsFill() const {
    return definition && definition->supportsFill();
}

bool Shape::isValid() const {
    return definition && definition->isGeometryValid(geometry);
}

QPainterPath Shape::localPath() const {
    return definition ? definition->localPath(geometry) : QPainterPath();
}

QRectF Shape::localGeometryBounds() const {
    return localPath().boundingRect();
}

QJsonArray pointToJson(const QPointF& point) {
    return QJsonArray{point.x(), point.y()};
}

QPointF pointFromJson(const QJsonValue& value) {
    const QJsonArray array = value.toArray();
    if (array.size() != 2) {
        return {};
    }
    return QPointF(array[0].toDouble(), array[1].toDouble());
}

QJsonArray pointsToJson(const QVector<QPointF>& points) {
    QJsonArray array;
    for (const QPointF& point : points) {
        array.append(pointToJson(point));
    }
    return array;
}

QVector<QPointF> pointsFromJson(const QJsonValue& value) {
    QVector<QPointF> points;
    const QJsonArray array = value.toArray();
    points.reserve(array.size());
    for (const QJsonValue& pointValue : array) {
        points.append(pointFromJson(pointValue));
    }
    return points;
}

QJsonArray rectToJson(const QRectF& rect) {
    return QJsonArray{rect.x(), rect.y(), rect.width(), rect.height()};
}

QRectF rectFromJson(const QJsonValue& value) {
    const QJsonArray array = value.toArray();
    if (array.size() != 4) {
        return {};
    }
    return QRectF(array[0].toDouble(), array[1].toDouble(), array[2].toDouble(), array[3].toDouble());
}

QJsonObject styleToJson(const ShapeStyle& style) {
    QJsonObject object;
    object["stroke"] = style.strokeColor.name(QColor::HexArgb);
    object["fill"] = style.fillColor.name(QColor::HexArgb);
    object["penWidth"] = style.penWidth;
    return object;
}

bool styleFromJson(const QJsonObject& object, ShapeStyle* outStyle) {
    if (!outStyle || !object.contains("stroke") || !object.contains("fill") || !object.contains("penWidth")) {
        return false;
    }

    const QColor stroke(object["stroke"].toString());
    const QColor fill(object["fill"].toString());
    if (!stroke.isValid() || !fill.isValid()) {
        return false;
    }

    outStyle->strokeColor = stroke;
    outStyle->fillColor = fill;
    outStyle->penWidth = std::clamp(object["penWidth"].toInt(2), 1, 20);
    return true;
}

QTransform shapeTransform(const Shape& shape) {
    QTransform transform;
    transform.translate(shape.position.x(), shape.position.y());
    transform.rotate(shape.rotation);
    transform.scale(clampScale(shape.scaleX), clampScale(shape.scaleY));
    return transform;
}

QPainterPath shapePath(const Shape& shape) {
    return shapeTransform(shape).map(shape.localPath());
}

QPainterPath shapeStrokePath(const Shape& shape, qreal extraPadding) {
    QPainterPathStroker stroker;
    stroker.setCapStyle(Qt::RoundCap);
    stroker.setJoinStyle(Qt::RoundJoin);
    stroker.setWidth(std::max<qreal>(shape.style.penWidth + extraPadding, 8.0));
    return stroker.createStroke(shapePath(shape));
}

QRectF shapeBounds(const Shape& shape) {
    return shapePath(shape).boundingRect();
}

bool shapeContains(const Shape& shape, const QPointF& scenePoint) {
    const QPainterPath transformed = shapePath(shape);
    if (shape.supportsFill() && transformed.contains(scenePoint)) {
        return true;
    }
    return shapeStrokePath(shape).contains(scenePoint);
}

QSizeF effectiveShapeSize(const Shape& shape) {
    const QRectF bounds = shape.localGeometryBounds();
    return QSizeF(std::max<qreal>(1.0, bounds.width() * clampScale(shape.scaleX)),
                  std::max<qreal>(1.0, bounds.height() * clampScale(shape.scaleY)));
}

QString createShapeId() {
    return QUuid::createUuid().toString(QUuid::WithoutBraces);
}

QString createLayerId() {
    return QUuid::createUuid().toString(QUuid::WithoutBraces);
}