414 lines
19 KiB
C++
414 lines
19 KiB
C++
#include "SelectionCanvasFixtures.h"
|
||
#include <QNativeGestureEvent>
|
||
|
||
// The Crop tool on the canvas: drags, keys, cursors, frame.
|
||
class CropCanvasTests : public QObject {
|
||
Q_OBJECT
|
||
private slots:
|
||
void aDragDrawsMovesAndResizesTheFrame();
|
||
void altAndCtrlShapeTheDragAsTheyChange();
|
||
void snappingReachesEightViewPoints();
|
||
void theKeysAndLostReleasesEndTheDrag();
|
||
void theCursorShowsWhatAPressTakes();
|
||
void theFrameDimsWhatItCutsAway();
|
||
void aFramePastTheCanvasShowsWhatItTakesIn();
|
||
void cropDraggingRedrawsOnlyTheOverlay();
|
||
};
|
||
|
||
namespace {
|
||
struct CropCanvas : Canvas {
|
||
CropCanvas()
|
||
{
|
||
// Zoomed about the middle, the pan keeps a float's dust.
|
||
session.viewport.pan = QSizeF(0, 0);
|
||
session.selectTool(NavigationTool::crop);
|
||
canvas->synchronizeDisplay();
|
||
}
|
||
std::optional<QRectF> frame() const { return session.cropRect(); }
|
||
Qt::CursorShape shape() const { return canvas->cursor().shape(); }
|
||
};
|
||
}
|
||
|
||
void CropCanvasTests::aDragDrawsMovesAndResizesTheFrame()
|
||
{
|
||
CropCanvas shown;
|
||
// On the whole canvas's frame a press draws anew.
|
||
shown.press(QPointF(100, 100));
|
||
QCOMPARE(shown.frame(), std::nullopt);
|
||
shown.move(QPointF(200, 160));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 100, 100, 60)));
|
||
shown.release(QPointF(200, 160));
|
||
// Inside a drawn frame a press moves it.
|
||
shown.drag(QPointF(150, 130), QPointF(160, 145));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(110, 115, 100, 60)));
|
||
// Eight points from the canvas's edge, an edge snaps.
|
||
shown.drag(QPointF(150, 130), QPointF(45, 130));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(0, 115, 100, 60)));
|
||
// Corner grips resize; so do edges far from their middle.
|
||
shown.drag(QPointF(100, 175), QPointF(150, 200));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(0, 115, 150, 85)));
|
||
shown.drag(QPointF(20, 115), QPointF(20, 95));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(0, 95, 150, 105)));
|
||
// A fixed ratio shapes a new frame.
|
||
shown.session.setCropRatioChoice("1:1");
|
||
shown.drag(QPointF(250, 20), QPointF(310, 50));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(250, 20, 60, 60)));
|
||
// Dragged past the bounds, a frame keeps its last shape.
|
||
shown.session.setCropRatioChoice("Free");
|
||
shown.session.zoom(0.01);
|
||
shown.canvas->synchronizeDisplay();
|
||
shown.press(QPointF(1, 1));
|
||
shown.move(QPointF(100, 100));
|
||
const QRectF good = shown.frame().value();
|
||
shown.move(QPointF(399, 299));
|
||
QCOMPARE(shown.frame(), std::optional(good));
|
||
shown.release(QPointF(399, 299));
|
||
}
|
||
|
||
void CropCanvasTests::altAndCtrlShapeTheDragAsTheyChange()
|
||
{
|
||
CropCanvas shown;
|
||
// Alt grows the frame out from the press.
|
||
shown.press(QPointF(300, 50), Qt::AltModifier);
|
||
shown.move(QPointF(320, 60), Qt::AltModifier);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(280, 40, 40, 20)));
|
||
shown.release(QPointF(320, 60), Qt::AltModifier);
|
||
// Ctrl leaves the edges where the pointer puts them.
|
||
shown.drag(QPointF(100, 100), QPointF(395, 200));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 100, 300, 100)));
|
||
shown.session.cancelCrop();
|
||
shown.drag(QPointF(100, 100), QPointF(395, 200), Qt::ControlModifier);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 100, 295, 100)));
|
||
// A key pressed or let go mid-drag reshapes at once.
|
||
shown.session.cancelCrop();
|
||
shown.press(QPointF(200, 150));
|
||
shown.move(QPointF(220, 160));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 150, 20, 10)));
|
||
QTest::keyPress(shown.window.windowHandle(), Qt::Key_Alt, Qt::AltModifier);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(180, 140, 40, 20)));
|
||
QTest::keyRelease(shown.window.windowHandle(), Qt::Key_Alt, Qt::NoModifier);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 150, 20, 10)));
|
||
shown.move(QPointF(395, 160));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 150, 200, 10)));
|
||
QTest::keyPress(shown.window.windowHandle(), Qt::Key_Control, Qt::ControlModifier);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 150, 195, 10)));
|
||
QTest::keyRelease(shown.window.windowHandle(), Qt::Key_Control, Qt::NoModifier);
|
||
shown.release(QPointF(395, 160));
|
||
// Without a drag a key leaves the frame be.
|
||
QTest::keyPress(shown.window.windowHandle(), Qt::Key_Alt, Qt::AltModifier);
|
||
QTest::keyRelease(shown.window.windowHandle(), Qt::Key_Alt, Qt::NoModifier);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 150, 200, 10)));
|
||
}
|
||
|
||
void CropCanvasTests::theKeysAndLostReleasesEndTheDrag()
|
||
{
|
||
CropCanvas shown;
|
||
EditorSession &session = shown.session;
|
||
// The canvas takes the frame's keys: nothing above sees them.
|
||
QKeyEvent escape(QEvent::KeyPress, Qt::Key_Escape, Qt::NoModifier);
|
||
QApplication::sendEvent(shown.canvas, &escape);
|
||
QVERIFY(escape.isAccepted());
|
||
// Escape drops the frame, mid-drag too, ending the drag.
|
||
shown.move(QPointF(150, 150));
|
||
QTest::keyClick(shown.canvas, Qt::Key_Escape);
|
||
QCOMPARE(shown.frame(), std::nullopt);
|
||
shown.move(QPointF(200, 200));
|
||
QCOMPARE(shown.frame(), std::nullopt);
|
||
shown.release(QPointF(200, 200));
|
||
QCOMPARE(session.visibleCropRect(), std::optional(QRectF(0, 0, 400, 300)));
|
||
// Return without a frame crops nothing.
|
||
QTest::keyClick(shown.canvas, Qt::Key_Return);
|
||
QTest::qWait(20);
|
||
QCOMPARE(session.document().value().width, 400);
|
||
// Losing the keys, or the left button, ends a drag.
|
||
shown.press(QPointF(100, 100));
|
||
shown.move(QPointF(150, 150));
|
||
QFocusEvent out(QEvent::FocusOut, Qt::ActiveWindowFocusReason);
|
||
QApplication::sendEvent(shown.canvas, &out);
|
||
shown.move(QPointF(200, 200));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 100, 50, 50)));
|
||
shown.canvas->setFocus();
|
||
shown.press(QPointF(10, 250));
|
||
shown.move(QPointF(20, 260));
|
||
shown.hover(QPointF(30, 270));
|
||
shown.move(QPointF(40, 280));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(10, 250, 10, 10)));
|
||
shown.release(QPointF(40, 280));
|
||
// Mid-drag, wheels and pinches neither pan nor zoom.
|
||
const CanvasViewport before = session.viewport;
|
||
shown.press(QPointF(200, 50));
|
||
wheel(*shown.canvas, QPointF(200, 50), QPoint(0, 40), QPoint(0, 120), Qt::NoModifier);
|
||
QNativeGestureEvent pinch(Qt::ZoomNativeGesture, QPointingDevice::primaryPointingDevice(), 2, QPointF(200, 50), QPointF(200, 50),
|
||
shown.canvas->mapToGlobal(QPoint(200, 50)), 0.5, QPointF());
|
||
QApplication::sendEvent(shown.canvas, &pinch);
|
||
QVERIFY(session.viewport == before);
|
||
// Busy, or another tool, and a drag changes nothing.
|
||
shown.move(QPointF(250, 80));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 50, 50, 30)));
|
||
session.setIsProjectBusy(true);
|
||
shown.move(QPointF(260, 90));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(200, 50, 50, 30)));
|
||
session.setIsProjectBusy(false);
|
||
session.selectTool(NavigationTool::brush);
|
||
shown.move(QPointF(270, 100));
|
||
// The Brush's circle follows the pointer meanwhile.
|
||
QCOMPARE(shown.canvas->brushCursor().circle().value().center(), QPointF(270, 100));
|
||
QTest::keyPress(shown.window.windowHandle(), Qt::Key_Alt, Qt::AltModifier);
|
||
QTest::keyRelease(shown.window.windowHandle(), Qt::Key_Alt, Qt::NoModifier);
|
||
QCOMPARE(shown.frame(), std::nullopt);
|
||
shown.release(QPointF(270, 100));
|
||
// Return crops to the frame, Enter alike; one step each.
|
||
session.selectTool(NavigationTool::crop);
|
||
session.setCropRect(QRectF(10, 20, 200, 100));
|
||
QTest::keyClick(shown.canvas, Qt::Key_Return);
|
||
QTRY_COMPARE(session.document().value().width, 200);
|
||
QCOMPARE(session.document().value().height, 100);
|
||
QCOMPARE(session.history.undoName(), QString("Crop"));
|
||
session.setCropRect(QRectF(0, 0, 50, 40));
|
||
QTest::keyClick(shown.canvas, Qt::Key_Enter, Qt::KeypadModifier);
|
||
QTRY_COMPARE(session.document().value().width, 50);
|
||
// Off the Crop tool, Return goes to a transform.
|
||
session.selectTool(NavigationTool::move);
|
||
session.insert(filled(10, 10, qRgba(0, 0, 255, 255), "Blue"));
|
||
session.beginTransform();
|
||
QVERIFY(session.transformEdit());
|
||
QTest::keyClick(shown.canvas, Qt::Key_Return);
|
||
QVERIFY(!session.transformEdit());
|
||
QCOMPARE(session.document().value().width, 50);
|
||
// A document gone mid-drag leaves the drag nothing to do.
|
||
session.selectTool(NavigationTool::crop);
|
||
shown.press(QPointF(10, 10));
|
||
session.clearProject();
|
||
shown.move(QPointF(30, 30));
|
||
QTest::keyPress(shown.window.windowHandle(), Qt::Key_Alt, Qt::AltModifier);
|
||
QTest::keyRelease(shown.window.windowHandle(), Qt::Key_Alt, Qt::NoModifier);
|
||
QCOMPARE(shown.frame(), std::nullopt);
|
||
shown.release(QPointF(30, 30));
|
||
}
|
||
|
||
void CropCanvasTests::snappingReachesEightViewPoints()
|
||
{
|
||
CropCanvas shown;
|
||
// At 100% eight points are eight pixels: nine stay out.
|
||
shown.drag(QPointF(100, 100), QPointF(391, 200));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 100, 291, 100)));
|
||
// At 50% the same eight points reach sixteen pixels.
|
||
shown.session.zoom(0.5);
|
||
shown.canvas->synchronizeDisplay();
|
||
const QSizeF size = shown.documentSize();
|
||
const QPointF from = shown.session.viewport.viewPoint(QPointF(100, 50), size), to = shown.session.viewport.viewPoint(QPointF(390, 170), size);
|
||
shown.drag(from, to);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 50, 300, 120)));
|
||
// Snap off: the edges stay where the pointer puts them.
|
||
shown.session.setSnappingEnabled(false);
|
||
shown.session.setCropRect(std::nullopt);
|
||
shown.drag(from, to);
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(100, 50, 290, 120)));
|
||
}
|
||
|
||
void CropCanvasTests::theCursorShowsWhatAPressTakes()
|
||
{
|
||
CropCanvas shown;
|
||
// Before any hover, the crosshair.
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
// A narrow frame's corners overlap: the first corner wins.
|
||
shown.session.setCropRect(QRectF(100, 100, 10, 100));
|
||
shown.canvas->synchronizeDisplay();
|
||
shown.hover(QPointF(105, 100));
|
||
QCOMPARE(shown.shape(), Qt::SizeFDiagCursor);
|
||
shown.session.setCropRect(QRectF(100, 100, 200, 100));
|
||
shown.canvas->synchronizeDisplay();
|
||
shown.hover(QPointF(200, 150));
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
shown.hover(QPointF(50, 50));
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
const std::pair<QPointF, Qt::CursorShape> grips[] = {
|
||
{{100, 100}, Qt::SizeFDiagCursor}, {{200, 100}, Qt::SizeVerCursor}, {{300, 100}, Qt::SizeBDiagCursor}, {{300, 150}, Qt::SizeHorCursor},
|
||
{{300, 200}, Qt::SizeFDiagCursor}, {{200, 200}, Qt::SizeVerCursor}, {{100, 200}, Qt::SizeBDiagCursor}, {{100, 150}, Qt::SizeHorCursor},
|
||
{{115, 91}, Qt::SizeVerCursor}, {{109, 185}, Qt::SizeHorCursor}, {{109.5, 109.5}, Qt::SizeFDiagCursor}, {{110, 110}, Qt::CrossCursor},
|
||
{{90, 95}, Qt::SizeFDiagCursor}, {{95, 90}, Qt::SizeFDiagCursor}};
|
||
for (const auto &[at, cursor] : grips) {
|
||
shown.hover(at);
|
||
QCOMPARE(shown.shape(), cursor);
|
||
}
|
||
// Space pans.
|
||
QTest::keyPress(shown.canvas, Qt::Key_Space);
|
||
shown.hover(QPointF(300, 200));
|
||
QCOMPARE(shown.shape(), Qt::OpenHandCursor);
|
||
QTest::keyRelease(shown.canvas, Qt::Key_Space);
|
||
QCOMPARE(shown.shape(), Qt::SizeFDiagCursor);
|
||
// A new frame keeps its press's cursor: the old frame's.
|
||
shown.hover(QPointF(5, 150));
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
shown.press(QPointF(5, 150));
|
||
QCOMPARE(shown.frame(), std::nullopt);
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
shown.move(QPointF(30, 170));
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
shown.release(QPointF(30, 170));
|
||
shown.session.setCropRect(QRectF(100, 100, 200, 100));
|
||
shown.canvas->synchronizeDisplay();
|
||
// A drag keeps its press's cursor until the release.
|
||
shown.session.cancelCrop();
|
||
shown.press(QPointF(50, 50));
|
||
shown.move(QPointF(150, 150));
|
||
QCOMPARE(shown.frame(), std::optional(QRectF(50, 50, 100, 100)));
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
shown.release(QPointF(150, 150));
|
||
QCOMPARE(shown.shape(), Qt::SizeFDiagCursor);
|
||
shown.press(QPointF(150, 100));
|
||
QCOMPARE(shown.shape(), Qt::SizeHorCursor);
|
||
shown.move(QPointF(120, 60));
|
||
QCOMPARE(shown.shape(), Qt::SizeHorCursor);
|
||
QTest::keyClick(shown.canvas, Qt::Key_Escape);
|
||
shown.canvas->synchronizeDisplay();
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
shown.release(QPointF(120, 60));
|
||
// Escape without a crop drag leaves another drag's cursor be.
|
||
shown.session.selectTool(NavigationTool::move);
|
||
shown.session.insert(filled(100, 100, qRgba(0, 0, 255, 255), "Blue"));
|
||
shown.press(QPointF(200, 150));
|
||
const QImage dragging = image(shown.canvas->cursor());
|
||
QVERIFY(!dragging.isNull());
|
||
QTest::keyClick(shown.canvas, Qt::Key_C);
|
||
QTest::keyClick(shown.canvas, Qt::Key_Escape);
|
||
QCOMPARE(image(shown.canvas->cursor()), dragging);
|
||
shown.release(QPointF(200, 150));
|
||
// Return frees the drag cursor at once, before the crop.
|
||
shown.press(QPointF(50, 50));
|
||
shown.move(QPointF(150, 150));
|
||
QCOMPARE(shown.shape(), Qt::CrossCursor);
|
||
QTest::keyClick(shown.canvas, Qt::Key_Return);
|
||
QCOMPARE(shown.shape(), Qt::SizeFDiagCursor);
|
||
shown.release(QPointF(150, 150));
|
||
QTRY_COMPARE(shown.session.document().value().width, 100);
|
||
}
|
||
|
||
void CropCanvasTests::theFrameDimsWhatItCutsAway()
|
||
{
|
||
CropCanvas shown;
|
||
EditorSession &session = shown.session;
|
||
session.setCropRect(QRectF(100, 100, 200, 100));
|
||
QImage image(400, 300, QImage::Format_RGB32);
|
||
image.fill(QColor(200, 200, 200));
|
||
{
|
||
QPainter painter(&image);
|
||
TransformOverlay(session).draw(painter, shown.canvas->palette());
|
||
}
|
||
// Outside, 60% black; inside, clear but for lines and grips.
|
||
QCOMPARE(qRed(image.pixel(50, 50)), 80);
|
||
QCOMPARE(qRed(image.pixel(150, 150)), 200);
|
||
QCOMPARE(qRed(image.pixel(150, 120)), 200);
|
||
// The frame straddles the edge: half white, half beneath.
|
||
QVERIFY(std::abs(qRed(image.pixel(150, 100)) - 228) <= 1);
|
||
QVERIFY(std::abs(qRed(image.pixel(150, 99)) - 168) <= 1);
|
||
// A third's line: 40% white over its pixels, antialiased.
|
||
QVERIFY(qRed(image.pixel(166, 120)) > 210 && qRed(image.pixel(166, 120)) < 221);
|
||
QCOMPARE(qRed(image.pixel(165, 120)), 200);
|
||
QVERIFY(qRed(image.pixel(150, 133)) > 205);
|
||
// Both thirds each way, end to end, flat-capped.
|
||
for (const QPoint third : {QPoint(233, 120), QPoint(150, 166), QPoint(166, 101), QPoint(166, 198), QPoint(298, 133)})
|
||
QVERIFY2(qRed(image.pixel(third)) > 205, qPrintable(QString("%1 %2").arg(third.x()).arg(third.y())));
|
||
QVERIFY(std::abs(qRed(image.pixel(166, 99)) - 168) <= 2);
|
||
// White grips with black rims, corners and middles alike.
|
||
for (const QPoint grip : {QPoint(102, 102), QPoint(202, 102), QPoint(298, 198), QPoint(102, 152)})
|
||
QCOMPARE(image.pixel(grip), qRgb(255, 255, 255));
|
||
QVERIFY(qRed(image.pixel(96, 101)) < 200);
|
||
// At twice the scale a grip's corner is mitred.
|
||
QImage twice(800, 600, QImage::Format_RGB32);
|
||
twice.fill(QColor(200, 200, 200));
|
||
{
|
||
QPainter painter(&twice);
|
||
painter.scale(2, 2);
|
||
TransformOverlay(session).draw(painter, shown.canvas->palette());
|
||
}
|
||
QCOMPARE(qRed(twice.pixel(191, 191)), 0);
|
||
QCOMPARE(qRed(twice.pixel(204, 204)), 255);
|
||
// It repaints the frames, the grips' five points around.
|
||
QCOMPARE(TransformOverlay(session).drawnRect(QRect(0, 0, 400, 300)), QRect(95, 95, 210, 110));
|
||
session.zoom(2);
|
||
QCOMPARE(TransformOverlay(session).cropViewRect().value().size(), QSizeF(400, 200));
|
||
QCOMPARE(TransformOverlay(session).cropViewRect().value().topLeft(), session.viewport.viewPoint(QPointF(100, 100), QSizeF(400, 300)));
|
||
session.zoom(1);
|
||
session.selectTool(NavigationTool::hand);
|
||
QVERIFY(TransformOverlay(session).drawnRect(QRect(0, 0, 400, 300)).isEmpty());
|
||
QVERIFY(TransformOverlay(session).cropResizeRegions().empty());
|
||
}
|
||
|
||
void CropCanvasTests::aFramePastTheCanvasShowsWhatItTakesIn()
|
||
{
|
||
Shown shown;
|
||
shown.settle();
|
||
shown.session.zoom(1);
|
||
shown.canvas->synchronizeDisplay();
|
||
// The document sits at 150–250 × 100–200 in view points.
|
||
QCOMPARE(shown.session.viewport.viewPoint(QPointF(0, 0), shown.documentSize()), QPointF(150, 100));
|
||
const QColor surround = shown.canvas->palette().color(QPalette::Base);
|
||
QCOMPARE(shown.canvas->grab().toImage().pixelColor(120, 150), surround);
|
||
shown.session.selectTool(NavigationTool::crop);
|
||
shown.session.setCropRect(QRectF(-50, 0, 100, 100));
|
||
shown.canvas->synchronizeDisplay();
|
||
const QImage shot = shown.canvas->grab().toImage();
|
||
// The checkerboard's squares: the frame takes this in.
|
||
QCOMPARE(qGray(shot.pixel(120, 150)), 77);
|
||
QCOMPARE(qGray(shot.pixel(106, 106)), 89);
|
||
// The canvas still shows beside it, dimmed.
|
||
QVERIFY(std::abs(qGray(shot.pixel(230, 150)) - 36) <= 1);
|
||
// Beyond the frame the surround shows, dimmed.
|
||
QVERIFY(std::abs(qRed(shot.pixel(20, 20)) - qRound(surround.red() * 0.4)) <= 1);
|
||
shown.session.selectTool(NavigationTool::hand);
|
||
shown.canvas->synchronizeDisplay();
|
||
QCOMPARE(shown.canvas->grab().toImage().pixelColor(120, 150), surround);
|
||
// Coming and going, the dimming repaints the canvas.
|
||
shown.session.viewport.pan = QSizeF(0, 0);
|
||
shown.canvas->synchronizeDisplay();
|
||
QApplication::processEvents();
|
||
PaintSpy spy(*shown.canvas);
|
||
const auto shows = [&](const std::function<void()> &change) {
|
||
spy.painted = QRect();
|
||
change();
|
||
shown.canvas->synchronizeDisplay();
|
||
QApplication::processEvents();
|
||
return spy.painted;
|
||
};
|
||
QCOMPARE(shows([&] { shown.session.selectTool(NavigationTool::crop); }), shown.canvas->rect());
|
||
// A changed frame repaints the old and the new alone.
|
||
QCOMPARE(shows([&] { shown.session.setCropRect(QRectF(10, 0, 20, 20)); }), QRect(145, 95, 110, 110));
|
||
QCOMPARE(shows([&] { shown.session.setCropRect(QRectF(20, 0, 20, 20)); }), QRect(155, 95, 40, 30));
|
||
QCOMPARE(shows([&] { shown.session.selectTool(NavigationTool::hand); }), shown.canvas->rect());
|
||
}
|
||
|
||
// Swift's test: inside the canvas a drag repaints frames alone.
|
||
void CropCanvasTests::cropDraggingRedrawsOnlyTheOverlay()
|
||
{
|
||
Shown shown(QSize(800, 600), QSize(600, 450));
|
||
shown.settle();
|
||
EditorSession &session = shown.session;
|
||
session.insert(filled(400, 300, qRgba(255, 0, 0, 255), "Red"));
|
||
session.selectTool(NavigationTool::crop);
|
||
shown.canvas->synchronizeDisplay();
|
||
QApplication::processEvents();
|
||
PaintSpy spy(*shown.canvas);
|
||
QTest::mousePress(shown.canvas, Qt::LeftButton, Qt::NoModifier, QPoint(150, 120));
|
||
QApplication::processEvents();
|
||
const auto viewRect = [&] { return TransformOverlay(session).cropViewRect().value(); };
|
||
QRectF shown_ = viewRect();
|
||
for (int step = 0; step < 10; ++step) {
|
||
spy.painted = QRect();
|
||
drag(*shown.canvas, QPointF(170 + step * 10, 140 + step * 8));
|
||
QApplication::processEvents();
|
||
const QRectF next = viewRect();
|
||
// Old and new frames together, grips and all.
|
||
QVERIFY((shown_ | next).adjusted(-5, -5, 5, 5).toAlignedRect().contains(spy.painted));
|
||
QVERIFY(spy.painted.contains(next.toAlignedRect()));
|
||
QVERIFY(step == 0 || spy.painted.width() < 150);
|
||
QVERIFY(!shown.canvas->synchronizeDisplay());
|
||
shown_ = next;
|
||
}
|
||
QTest::mouseRelease(shown.canvas, Qt::LeftButton, Qt::NoModifier, QPoint(260, 212));
|
||
QVERIFY(session.cropRect().has_value());
|
||
}
|
||
|
||
QTEST_MAIN(CropCanvasTests)
|
||
#include "CropCanvasTests.moc"
|