403 lines
17 KiB
C++
403 lines
17 KiB
C++
#include "Document/DocumentLimits.h"
|
||
#include "BrushFixtures.h"
|
||
#include "Document/EditorSession.h"
|
||
#include "IO/ImageExporter.h"
|
||
#include <QSignalSpy>
|
||
#include <cmath>
|
||
#include <numbers>
|
||
|
||
// Swift's ShapeToolTests, and the draft's own rules.
|
||
namespace {
|
||
std::unique_ptr<EditorSession> makeSession()
|
||
{
|
||
auto session = std::make_unique<EditorSession>();
|
||
session->createDocument(100, 80, true);
|
||
session->selectTool(NavigationTool::shape);
|
||
session->setForegroundColor(PaletteColor{1, 0, 0});
|
||
return session;
|
||
}
|
||
|
||
void drag(EditorSession &session, QPointF start, QPointF end, bool square = false, bool fromCenter = false)
|
||
{
|
||
session.beginShape(start);
|
||
session.dragShape(end, square, fromCenter);
|
||
session.finishShape();
|
||
}
|
||
|
||
// One exported pixel's red and alpha, as Swift's reader.
|
||
std::pair<int, int> redAlpha(const EditorSession &session, int x, int y)
|
||
{
|
||
const std::vector<int> at = pixel(ImageExporter::render(session.projectSnapshot().value()).image, x, y);
|
||
return {at[0], at[3]};
|
||
}
|
||
|
||
QStringList names(const EditorSession &session)
|
||
{
|
||
QStringList list;
|
||
for (const ImageLayer &layer : session.document().value().layers)
|
||
list << layer.name;
|
||
return list;
|
||
}
|
||
|
||
const std::pair<int, int> solid{255, 255};
|
||
}
|
||
|
||
class ShapeToolTests : public QObject {
|
||
Q_OBJECT
|
||
private slots:
|
||
void rectangleFillsANewLayerWithTheForegroundColorAsOneUndoStep();
|
||
void ellipseLeavesItsCornersClearWithShiftCircleAndOptionFromCenter();
|
||
void aClickEscapeOrToolSwitchMakesNoLayer();
|
||
void roundedRectanglesFollowTheRadiusAndClampToAPill();
|
||
void aLineKeepsItsEndsThicknessAndRoundCaps();
|
||
void shiftSnapsALineToEighthsOfATurn();
|
||
void aShapeTooLargeIsRefused();
|
||
void namesSkipThoseInUse();
|
||
void theDraftWaitsForEditableLayers();
|
||
void tabAndTheKindsCancelTheDraft();
|
||
void everyChangeIsAnnounced();
|
||
void pathsFollowSwift();
|
||
void flatDragsMakeNothing();
|
||
void edgesAreSmoothAndLinesAPixelWide();
|
||
};
|
||
|
||
void ShapeToolTests::rectangleFillsANewLayerWithTheForegroundColorAsOneUndoStep()
|
||
{
|
||
const auto session = makeSession();
|
||
session->selectAll();
|
||
const int count = session->history.undoCount();
|
||
drag(*session, QPointF(10, 10), QPointF(40, 30));
|
||
QCOMPARE(names(*session), (QStringList{"Layer 1", "Rectangle 1"}));
|
||
QCOMPARE(session->activeLayer().value().name, QString("Rectangle 1"));
|
||
QCOMPARE(session->history.undoCount(), count + 1);
|
||
QCOMPARE(session->history.undoName(), QString("Rectangle"));
|
||
QCOMPARE(session->activeLayer().value().transform.origin, QPointF(10, 10));
|
||
QCOMPARE(session->activeLayer().value().transform.size, QSizeF(30, 20));
|
||
// Unlike Paste, drawing a shape keeps the selection.
|
||
QVERIFY(session->selection());
|
||
QCOMPARE(redAlpha(*session, 25, 20), solid);
|
||
QCOMPARE(redAlpha(*session, 10, 10), solid);
|
||
QCOMPARE(redAlpha(*session, 39, 29), solid);
|
||
QCOMPARE(redAlpha(*session, 9, 20).second, 0);
|
||
QCOMPARE(redAlpha(*session, 40, 20).second, 0);
|
||
QCOMPARE(redAlpha(*session, 25, 30).second, 0);
|
||
drag(*session, QPointF(60, 10), QPointF(70, 20));
|
||
QCOMPARE(session->activeLayer().value().name, QString("Rectangle 2"));
|
||
session->undo();
|
||
session->undo();
|
||
QCOMPARE(names(*session), (QStringList{"Layer 1"}));
|
||
}
|
||
|
||
void ShapeToolTests::ellipseLeavesItsCornersClearWithShiftCircleAndOptionFromCenter()
|
||
{
|
||
const auto session = makeSession();
|
||
session->toggleShapeKind();
|
||
QCOMPARE(session->shapeKind(), ShapeKind::ellipse);
|
||
drag(*session, QPointF(50, 40), QPointF(60, 45), true, true);
|
||
QCOMPARE(session->activeLayer().value().name, QString("Ellipse 1"));
|
||
QCOMPARE(session->activeLayer().value().transform.origin, QPointF(40, 30));
|
||
QCOMPARE(session->activeLayer().value().transform.size, QSizeF(20, 20));
|
||
QCOMPARE(redAlpha(*session, 50, 40), solid);
|
||
QVERIFY(redAlpha(*session, 41, 40).second > 0 && redAlpha(*session, 50, 31).second > 0);
|
||
// Outside the circle, inside its box.
|
||
QCOMPARE(redAlpha(*session, 40, 30).second, 0);
|
||
QCOMPARE(redAlpha(*session, 59, 49).second, 0);
|
||
}
|
||
|
||
void ShapeToolTests::aClickEscapeOrToolSwitchMakesNoLayer()
|
||
{
|
||
const auto session = makeSession();
|
||
const int count = session->history.undoCount();
|
||
session->beginShape(QPointF(20, 20));
|
||
session->finishShape();
|
||
session->beginShape(QPointF(20, 20));
|
||
session->dragShape(QPointF(50, 50), false, false);
|
||
QCOMPARE(session->shapeDraft().value().rect, QRectF(20, 20, 30, 30));
|
||
session->cancelShape();
|
||
session->beginShape(QPointF(20, 20));
|
||
session->dragShape(QPointF(50, 50), false, false);
|
||
session->selectTool(NavigationTool::brush);
|
||
QVERIFY(!session->shapeDraft());
|
||
QCOMPARE(session->history.undoCount(), count);
|
||
QCOMPARE(session->document().value().layers.size(), size_t(1));
|
||
}
|
||
|
||
void ShapeToolTests::roundedRectanglesFollowTheRadiusAndClampToAPill()
|
||
{
|
||
const auto session = makeSession();
|
||
session->setShapeCornerRadius(8);
|
||
drag(*session, QPointF(10, 10), QPointF(50, 40));
|
||
session->setShapeCornerRadius(500);
|
||
// 40 × 20: a radius of 10.
|
||
drag(*session, QPointF(55, 50), QPointF(95, 70));
|
||
QCOMPARE(redAlpha(*session, 10, 10).second, 0);
|
||
QCOMPARE(redAlpha(*session, 11, 11).second, 0);
|
||
QCOMPARE(redAlpha(*session, 13, 13).second, 255);
|
||
QCOMPARE(redAlpha(*session, 30, 10).second, 255);
|
||
QCOMPARE(redAlpha(*session, 30, 25), solid);
|
||
QCOMPARE(redAlpha(*session, 55, 50).second, 0);
|
||
QCOMPARE(redAlpha(*session, 75, 60), solid);
|
||
QCOMPARE(session->document().value().layers.size(), size_t(3));
|
||
QCOMPARE(session->activeLayer().value().shape.value().style.cornerRadius, 500.0);
|
||
session->toggleShapeKind();
|
||
session->beginShape(QPointF(5, 5));
|
||
QCOMPARE(session->shapeDraft().value().cornerRadius, 0.0);
|
||
session->cancelShape();
|
||
}
|
||
|
||
void ShapeToolTests::aLineKeepsItsEndsThicknessAndRoundCaps()
|
||
{
|
||
const auto session = makeSession();
|
||
session->setForegroundColor(PaletteColor{1, 0.5, 0.25});
|
||
session->setShapeKind(ShapeKind::line);
|
||
session->beginShape(QPointF(10, 10));
|
||
// Undragged, a line has no end yet.
|
||
QVERIFY(!session->shapeLineEnds());
|
||
session->dragShape(QPointF(50, 30), false, false);
|
||
QCOMPARE(session->shapeLineEnds().value(), std::pair(QPointF(10, 10), QPointF(50, 30)));
|
||
session->finishShape();
|
||
// The ends' box, grown by half the default 4.
|
||
const ImageLayer line = session->activeLayer().value();
|
||
QCOMPARE(line.name, QString("Line 1"));
|
||
QCOMPARE(line.transform.origin, QPointF(8, 8));
|
||
QCOMPARE(line.transform.size, QSizeF(44, 24));
|
||
const LayerShapeStyle style = line.liveShape().value().style;
|
||
QCOMPARE(style.kind, ShapeKind::line);
|
||
QCOMPARE(style.color(), (PaletteColor{1, 0.5, 0.25}));
|
||
QCOMPARE(style.lineWidth.value(), 4.0);
|
||
QCOMPARE(style.start.value(), QPointF(2.0 / 44, 2.0 / 24));
|
||
QCOMPARE(style.end.value(), QPointF(42.0 / 44, 22.0 / 24));
|
||
QCOMPARE(redAlpha(*session, 30, 20), solid);
|
||
QCOMPARE(redAlpha(*session, 20, 25).second, 0);
|
||
// Past its start, inside the round cap alone.
|
||
QVERIFY(redAlpha(*session, 8, 9).second > 100);
|
||
QCOMPARE(redAlpha(*session, 50, 30), solid);
|
||
// Dragged back the other way: the same box, ends swapped.
|
||
session->setShapeLineWidth(6);
|
||
session->beginShape(QPointF(50, 30));
|
||
session->dragShape(QPointF(10, 10), false, false);
|
||
QCOMPARE(session->shapeLineEnds().value().first, QPointF(50, 30));
|
||
session->finishShape();
|
||
const ImageLayer back = session->activeLayer().value();
|
||
QCOMPARE(back.transform.origin, QPointF(7, 7));
|
||
QCOMPARE(back.transform.size, QSizeF(46, 26));
|
||
QCOMPARE(back.shape.value().style.start.value(), QPointF(43.0 / 46, 23.0 / 26));
|
||
QCOMPARE(back.shape.value().style.lineWidth.value(), 6.0);
|
||
// A click leaves a dot: the box grows by thickness.
|
||
session->beginShape(QPointF(70, 60));
|
||
session->finishShape();
|
||
const ImageLayer dot = session->activeLayer().value();
|
||
QCOMPARE(dot.name, QString("Line 3"));
|
||
QCOMPARE(dot.transform.origin, QPointF(67, 57));
|
||
QCOMPARE(dot.transform.size, QSizeF(6, 6));
|
||
QCOMPARE(dot.shape.value().style.start.value(), QPointF(0.5, 0.5));
|
||
QCOMPARE(redAlpha(*session, 70, 60), solid);
|
||
// A disc: its box's corners barely touched, its edges full.
|
||
QVERIFY(redAlpha(*session, 67, 57).second < 20 && redAlpha(*session, 67, 60).second > 150);
|
||
// A box that ends between pixels keeps its whole pixels.
|
||
session->beginShape(QPointF(10, 40));
|
||
session->dragShape(QPointF(50.5, 60), false, false);
|
||
session->finishShape();
|
||
QCOMPARE(session->activeLayer().value().asset.value().size(), QSize(46, 26));
|
||
QCOMPARE(session->activeLayer().value().transform.origin, QPointF(7, 37));
|
||
}
|
||
|
||
void ShapeToolTests::shiftSnapsALineToEighthsOfATurn()
|
||
{
|
||
const auto session = makeSession();
|
||
session->setShapeKind(ShapeKind::line);
|
||
session->beginShape(QPointF(10.6, 9.4));
|
||
QCOMPARE(session->shapeDraft().value().anchor, QPointF(11, 9));
|
||
session->beginShape(QPointF(10.4, 9.6));
|
||
QCOMPARE(session->shapeDraft().value().anchor, QPointF(10, 10));
|
||
session->dragShape(QPointF(50, 33), true, false);
|
||
const double length = std::hypot(40.0, 23.0), leg = length * std::cos(std::numbers::pi / 4);
|
||
const QPointF end = session->shapeLineEnds().value().second;
|
||
QVERIFY(std::abs(end.x() - (10 + leg)) < 1e-9 && std::abs(end.y() - (10 + leg)) < 1e-9);
|
||
QCOMPARE(session->shapeDraft().value().rect, DragBox::rect(QPointF(10, 10), end, false, false));
|
||
// Flat stays flat; Alt grows the box both ways.
|
||
session->dragShape(QPointF(50, 14), true, true);
|
||
QVERIFY(std::abs(session->shapeLineEnds().value().second.y() - 10) < 1e-9);
|
||
QCOMPARE(session->shapeDraft().value().rect, DragBox::rect(QPointF(10, 10), session->shapeLineEnds().value().second, false, true));
|
||
// Without Shift a line ends where the pointer is.
|
||
session->dragShape(QPointF(33.3, 21.7), false, false);
|
||
QCOMPARE(session->shapeLineEnds().value().second, QPointF(33.3, 21.7));
|
||
QCOMPARE(session->shapeDraft().value().rect, QRectF(10, 10, 23, 12));
|
||
}
|
||
|
||
void ShapeToolTests::aShapeTooLargeIsRefused()
|
||
{
|
||
EditorSession session;
|
||
session.createDocument(30'000, 12'000, true);
|
||
session.selectTool(NavigationTool::shape);
|
||
// Each side truncated first: 20,001 × 10,000 is over.
|
||
session.beginShape(QPointF(0, 0));
|
||
session.dragShape(QPointF(20'001, 10'000), false, false);
|
||
session.finishShape();
|
||
QCOMPARE(session.brushError().value(), QStringLiteral("That shape is too large. A shape can cover up to %1 megapixels.").arg(DocumentLimits::maxSurfaceMegapixels()));
|
||
QCOMPARE(session.document().value().layers.size(), size_t(1));
|
||
QVERIFY(!session.shapeDraft());
|
||
}
|
||
|
||
void ShapeToolTests::namesSkipThoseInUse()
|
||
{
|
||
EditorSession empty;
|
||
QCOMPARE(empty.nextShapeName(ShapeKind::ellipse), QString("Ellipse 1"));
|
||
const auto session = makeSession();
|
||
session->renameLayer(session->activeLayerID().value(), QStringLiteral("Rectangle 1"));
|
||
QCOMPARE(session->nextShapeName(ShapeKind::rectangle), QString("Rectangle 2"));
|
||
QCOMPARE(session->nextShapeName(ShapeKind::line), QString("Line 1"));
|
||
drag(*session, QPointF(1, 1), QPointF(5, 5));
|
||
QCOMPARE(session->activeLayer().value().name, QString("Rectangle 2"));
|
||
}
|
||
|
||
void ShapeToolTests::theDraftWaitsForEditableLayers()
|
||
{
|
||
const auto session = makeSession();
|
||
// Only the Shape tool, a finite point, editable layers begin.
|
||
session->selectTool(NavigationTool::brush);
|
||
session->beginShape(QPointF(5, 5));
|
||
QVERIFY(!session->shapeDraft());
|
||
session->selectTool(NavigationTool::shape);
|
||
session->beginShape(QPointF(NAN, 5));
|
||
session->beginShape(QPointF(5, INFINITY));
|
||
QVERIFY(!session->shapeDraft());
|
||
session->setIsProjectBusy(true);
|
||
session->beginShape(QPointF(5, 5));
|
||
QVERIFY(!session->shapeDraft());
|
||
session->setIsProjectBusy(false);
|
||
session->beginShape(QPointF(5, 5));
|
||
session->dragShape(QPointF(NAN, 20), false, false);
|
||
session->dragShape(QPointF(20, -INFINITY), false, false);
|
||
QCOMPARE(session->shapeDraft().value().rect, QRectF(5, 5, 0, 0));
|
||
// A draft finished while busy makes nothing.
|
||
session->dragShape(QPointF(20, 20), false, false);
|
||
session->setIsProjectBusy(true);
|
||
session->finishShape();
|
||
QVERIFY(!session->shapeDraft());
|
||
QCOMPARE(session->document().value().layers.size(), size_t(1));
|
||
session->setIsProjectBusy(false);
|
||
// Without a draft, a drag or finish changes nothing.
|
||
session->dragShape(QPointF(30, 30), false, false);
|
||
session->finishShape();
|
||
QVERIFY(!session->shapeDraft());
|
||
QCOMPARE(session->document().value().layers.size(), size_t(1));
|
||
}
|
||
|
||
void ShapeToolTests::tabAndTheKindsCancelTheDraft()
|
||
{
|
||
const auto session = makeSession();
|
||
session->beginShape(QPointF(5, 5));
|
||
session->toggleShapeKind();
|
||
QVERIFY(!session->shapeDraft());
|
||
QCOMPARE(session->shapeKind(), ShapeKind::ellipse);
|
||
session->toggleShapeKind();
|
||
QCOMPARE(session->shapeKind(), ShapeKind::line);
|
||
session->toggleShapeKind();
|
||
QCOMPARE(session->shapeKind(), ShapeKind::rectangle);
|
||
session->beginShape(QPointF(5, 5));
|
||
session->cycleToolMode();
|
||
QVERIFY(!session->shapeDraft());
|
||
QCOMPARE(session->shapeKind(), ShapeKind::ellipse);
|
||
// Choosing the tool it has keeps the draft.
|
||
session->beginShape(QPointF(5, 5));
|
||
session->selectTool(NavigationTool::shape);
|
||
QVERIFY(session->shapeDraft());
|
||
QCOMPARE(session->shapeDraft().value().kind, ShapeKind::ellipse);
|
||
}
|
||
|
||
void ShapeToolTests::everyChangeIsAnnounced()
|
||
{
|
||
const auto session = makeSession();
|
||
QSignalSpy spy(session.get(), &EditorSession::changed);
|
||
session->setShapeKind(ShapeKind::line);
|
||
session->setShapeLineWidth(9);
|
||
session->setShapeCornerRadius(3);
|
||
QCOMPARE(spy.count(), 3);
|
||
QCOMPARE(session->shapeLineWidth(), 9.0);
|
||
QCOMPARE(session->shapeCornerRadius(), 3.0);
|
||
session->beginShape(QPointF(1, 1));
|
||
session->dragShape(QPointF(9, 9), false, false);
|
||
session->cancelShape();
|
||
QCOMPARE(spy.count(), 6);
|
||
session->cancelShape();
|
||
QCOMPARE(spy.count(), 6);
|
||
// A rectangle's click clears the draft, one signal.
|
||
session->setShapeKind(ShapeKind::rectangle);
|
||
session->beginShape(QPointF(1, 1));
|
||
spy.clear();
|
||
session->finishShape();
|
||
QCOMPARE(spy.count(), 1);
|
||
QVERIFY(!session->shapeDraft());
|
||
}
|
||
|
||
void ShapeToolTests::pathsFollowSwift()
|
||
{
|
||
const QRectF tall(0, 0, 20, 40);
|
||
QPainterPath expected;
|
||
expected.addRoundedRect(tall, 10, 10);
|
||
// The radius stops at half the shorter side, either way.
|
||
QCOMPARE(path(ShapeKind::rectangle, tall, 500), expected);
|
||
QCOMPARE(path(ShapeKind::rectangle, tall.transposed(), 500), [] {
|
||
QPainterPath wide;
|
||
wide.addRoundedRect(QRectF(0, 0, 40, 20), 10, 10);
|
||
return wide;
|
||
}());
|
||
QPainterPath square;
|
||
square.addRect(tall);
|
||
QCOMPARE(path(ShapeKind::rectangle, tall, -5), square);
|
||
QCOMPARE(path(ShapeKind::rectangle, tall), square);
|
||
QPainterPath ellipse;
|
||
ellipse.addEllipse(tall);
|
||
QCOMPARE(path(ShapeKind::ellipse, tall, 8), ellipse);
|
||
QCOMPARE(rawValue(ShapeKind::rectangle) + rawValue(ShapeKind::ellipse) + rawValue(ShapeKind::line), QString("RectangleEllipseLine"));
|
||
QCOMPARE(shapeKind(QStringLiteral("Line")), std::optional(ShapeKind::line));
|
||
QCOMPARE(shapeKind(QStringLiteral("Ellipse")), std::optional(ShapeKind::ellipse));
|
||
QVERIFY(!shapeKind(QStringLiteral("line")));
|
||
}
|
||
|
||
void ShapeToolTests::flatDragsMakeNothing()
|
||
{
|
||
const auto session = makeSession();
|
||
drag(*session, QPointF(20, 20), QPointF(50, 20));
|
||
drag(*session, QPointF(20, 20), QPointF(20, 50));
|
||
QCOMPARE(session->document().value().layers.size(), size_t(1));
|
||
QVERIFY(!session->brushError());
|
||
}
|
||
|
||
void ShapeToolTests::edgesAreSmoothAndLinesAPixelWide()
|
||
{
|
||
const auto session = makeSession();
|
||
session->setShapeKind(ShapeKind::ellipse);
|
||
drag(*session, QPointF(40, 30), QPointF(60, 50));
|
||
// The circle's rim crosses this pixel: part covered.
|
||
const int rim = redAlpha(*session, 40, 38).second;
|
||
QVERIFY2(rim > 40 && rim < 250, qPrintable(QString::number(rim)));
|
||
// Thinner than a pixel, a line still draws one wide.
|
||
session->setShapeKind(ShapeKind::line);
|
||
session->setShapeLineWidth(0.4);
|
||
drag(*session, QPointF(10, 10), QPointF(50, 30));
|
||
const QImage line = session->activeLayer().value().asset.value().image();
|
||
int strongest = 0;
|
||
for (int y = 0; y < line.height(); ++y)
|
||
strongest = std::max(strongest, alpha(line, 20, y));
|
||
QVERIFY2(strongest > 150, qPrintable(QString::number(strongest)));
|
||
// Pixel-wide is still an outline: 1 and 1.001 agree.
|
||
session->setShapeLineWidth(1);
|
||
drag(*session, QPointF(10, 40), QPointF(50, 60));
|
||
const QImage one = session->activeLayer().value().asset.value().image();
|
||
session->setShapeLineWidth(1.001);
|
||
drag(*session, QPointF(10, 40), QPointF(50, 60));
|
||
const QImage wider = session->activeLayer().value().asset.value().image();
|
||
QCOMPARE(one.size(), wider.size());
|
||
int apart = 0;
|
||
for (int y = 0; y < one.height(); ++y) {
|
||
for (int x = 0; x < one.width(); ++x)
|
||
apart = std::max(apart, std::abs(alpha(one, x, y) - alpha(wider, x, y)));
|
||
}
|
||
QVERIFY2(apart <= 3, qPrintable(QString::number(apart)));
|
||
}
|
||
|
||
QTEST_GUILESS_MAIN(ShapeToolTests)
|
||
#include "ShapeToolTests.moc"
|