385 lines
17 KiB
C++
385 lines
17 KiB
C++
#include "Document/DocumentLimits.h"
|
||
#include "UI/ColorPickerSheet.h"
|
||
#include "UI/ImageSizeSheet.h"
|
||
#include <QCheckBox>
|
||
#include <QComboBox>
|
||
#include <QLabel>
|
||
#include <QPushButton>
|
||
#include <QApplication>
|
||
#include <QWheelEvent>
|
||
#include <QtTest>
|
||
|
||
// Swift's ImageSizeSheet: pixels resampled or print size alone.
|
||
class ImageSizeSheetTests : public QObject {
|
||
Q_OBJECT
|
||
private slots:
|
||
void theSheetShowsTheCanvas();
|
||
void pixelsFollowUnitsAndTheLock();
|
||
void aNewResolutionKeepsThePrintSize();
|
||
void aDocumentsOwnResolutionIsTheLastUsable();
|
||
void withoutResamplingOnlyTheResolutionMoves();
|
||
void anInvalidSizeRestsResize();
|
||
void returnWithoutTypingKeepsTheNumbers();
|
||
void aWheelOverUnitsCommitsTheTypingFirst();
|
||
void halfwayNumbersRoundToEven();
|
||
};
|
||
|
||
namespace {
|
||
CanvasDocument document(int width, int height, double resolution)
|
||
{
|
||
CanvasDocument made{width, height};
|
||
made.resolution = resolution;
|
||
return made;
|
||
}
|
||
|
||
struct Sheet {
|
||
std::optional<std::optional<ImageSizeOptions>> answer;
|
||
ImageSizeSheet sheet;
|
||
explicit Sheet(int width = 1200, int height = 800, double resolution = 72)
|
||
: sheet(document(width, height, resolution), [this](std::optional<ImageSizeOptions> options) { answer = options; })
|
||
{
|
||
sheet.show();
|
||
}
|
||
template <typename Widget> Widget &find(const char *name)
|
||
{
|
||
Widget *found = sheet.findChild<Widget *>(QString::fromLatin1(name));
|
||
if (!found)
|
||
throw std::runtime_error(std::string("no widget named ") + name);
|
||
return *found;
|
||
}
|
||
void type(const char *name, const QString &text)
|
||
{
|
||
auto &field = find<PickerField>(name);
|
||
field.setFocus();
|
||
field.selectAll();
|
||
QTest::keyClicks(&field, text);
|
||
QTest::keyClick(&field, Qt::Key_Return);
|
||
}
|
||
void unit(const QString &name)
|
||
{
|
||
auto &units = find<QComboBox>("imageUnits");
|
||
const int index = units.findText(name);
|
||
units.setCurrentIndex(index);
|
||
emit units.activated(index);
|
||
}
|
||
QString shown(const char *name) { return find<PickerField>(name).text(); }
|
||
QString result() { return find<QLabel>("imageResult").text(); }
|
||
QStringList units()
|
||
{
|
||
QStringList names;
|
||
auto &units = find<QComboBox>("imageUnits");
|
||
for (int index = 0; index < units.count(); ++index)
|
||
names << units.itemText(index);
|
||
return names;
|
||
}
|
||
};
|
||
}
|
||
|
||
void ImageSizeSheetTests::theSheetShowsTheCanvas()
|
||
{
|
||
Sheet shown;
|
||
QStringList texts;
|
||
for (const QLabel *label : shown.sheet.findChildren<QLabel *>())
|
||
texts << label->text();
|
||
QVERIFY(texts.contains("Image Size"));
|
||
QVERIFY(texts.contains("Current: 1,200 × 800 pixels"));
|
||
QVERIFY(texts.contains("pixels/inch"));
|
||
QCOMPARE(shown.sheet.width(), 430);
|
||
QCOMPARE(shown.units(), (QStringList{"Pixels", "Percent", "Inches", "Centimeters"}));
|
||
QCOMPARE(shown.shown("imageWidth"), QString("1200"));
|
||
QCOMPARE(shown.shown("imageResolution"), QString("72"));
|
||
QVERIFY(shown.find<QCheckBox>("imageLocked").isChecked());
|
||
QVERIFY(shown.find<QCheckBox>("imageResample").isChecked());
|
||
auto &sampling = shown.find<QComboBox>("imageSampling");
|
||
QCOMPARE(sampling.currentText(), QString("High quality"));
|
||
QCOMPARE(sampling.count(), 3);
|
||
QCOMPARE(shown.find<QLabel>("imageExplanation").text(), QString("Resizes layer pixels and applies existing transforms. Undo restores the originals."));
|
||
QCOMPARE(shown.result(), QString("Result: 1,200 × 800 pixels"));
|
||
// Cancel answers with nothing; Resize with the size.
|
||
shown.find<QPushButton>("imageCancel").click();
|
||
QVERIFY(!shown.answer.value().has_value());
|
||
emit sampling.activated(0);
|
||
shown.find<QPushButton>("imageResize").click();
|
||
const ImageSizeOptions options = shown.answer.value().value();
|
||
QVERIFY(options.width == 1200 && options.height == 800 && options.resolution == 72 && options.sampling == LayerSampling::nearest);
|
||
}
|
||
|
||
void ImageSizeSheetTests::pixelsFollowUnitsAndTheLock()
|
||
{
|
||
Sheet shown;
|
||
shown.type("imageWidth", "600");
|
||
QCOMPARE(shown.shown("imageHeight"), QString("400"));
|
||
shown.find<QCheckBox>("imageLocked").click();
|
||
shown.type("imageHeight", "500");
|
||
QCOMPARE(shown.shown("imageWidth"), QString("600"));
|
||
QCOMPARE(shown.result(), QString("Result: 600 × 500 pixels"));
|
||
shown.unit("Percent");
|
||
QCOMPARE(shown.shown("imageWidth"), QString("50"));
|
||
QCOMPARE(shown.shown("imageHeight"), QString("62.5"));
|
||
shown.type("imageWidth", "25");
|
||
QCOMPARE(shown.result(), QString("Result: 300 × 500 pixels"));
|
||
shown.unit("Inches");
|
||
QCOMPARE(shown.shown("imageWidth"), QString("4.167"));
|
||
shown.type("imageWidth", "10");
|
||
QCOMPARE(shown.result(), QString("Result: 720 × 500 pixels"));
|
||
shown.unit("Centimeters");
|
||
shown.type("imageWidth", "2.54");
|
||
QCOMPARE(shown.result(), QString("Result: 72 × 500 pixels"));
|
||
QCOMPARE(shown.shown("imageHeight"), QString("17.639"));
|
||
// Percent counts each side against its own original.
|
||
shown.unit("Percent");
|
||
shown.type("imageHeight", "50");
|
||
QCOMPARE(shown.result(), QString("Result: 72 × 400 pixels"));
|
||
// Locked, a height takes the width along.
|
||
shown.find<QCheckBox>("imageLocked").click();
|
||
shown.unit("Pixels");
|
||
shown.type("imageHeight", "800");
|
||
QCOMPARE(shown.result(), QString("Result: 144 × 800 pixels"));
|
||
shown.find<QCheckBox>("imageLocked").click();
|
||
shown.type("imageWidth", "600.6");
|
||
shown.find<QPushButton>("imageResize").click();
|
||
QCOMPARE(shown.answer.value().value().width, 601);
|
||
// Nothing, no number and zero are refused, as Swift's guard.
|
||
for (const QString &refused : {QString("0"), QString("-3"), QString("wide")}) {
|
||
shown.type("imageWidth", refused);
|
||
QCOMPARE(shown.result(), QString("Result: 601 × 800 pixels"));
|
||
}
|
||
}
|
||
|
||
void ImageSizeSheetTests::aNewResolutionKeepsThePrintSize()
|
||
{
|
||
Sheet shown;
|
||
// In physical units the pixels follow the resolution.
|
||
shown.unit("Inches");
|
||
shown.type("imageResolution", "144");
|
||
QCOMPARE(shown.result(), QString("Result: 2,400 × 1,600 pixels"));
|
||
QCOMPARE(shown.shown("imageWidth"), QString("16.667"));
|
||
// In pixels they stay.
|
||
shown.unit("Pixels");
|
||
shown.type("imageResolution", "300");
|
||
QCOMPARE(shown.result(), QString("Result: 2,400 × 1,600 pixels"));
|
||
shown.find<QPushButton>("imageResize").click();
|
||
QCOMPARE(shown.answer.value().value().resolution, 300.0);
|
||
// Swift's 555417e: zero and below keep 8 by 5.333 inches.
|
||
shown.unit("Inches");
|
||
QCOMPARE(shown.shown("imageWidth"), QString("8"));
|
||
shown.type("imageResolution", "0");
|
||
QCOMPARE(shown.result(), QStringLiteral("Use 1–30,000 pixels per side, up to %1 megapixels, and 1–9,600 pixels/inch.").arg(DocumentLimits::maxSurfaceMegapixels()));
|
||
// A size typed meanwhile is ignored.
|
||
shown.type("imageWidth", "2");
|
||
shown.type("imageResolution", "-5");
|
||
shown.type("imageHeight", "3");
|
||
shown.type("imageResolution", "150");
|
||
QCOMPARE(shown.result(), QString("Result: 1,200 × 800 pixels"));
|
||
QCOMPARE(shown.shown("imageWidth"), QString("8"));
|
||
// Centimetres keep the print size alike.
|
||
shown.unit("Centimeters");
|
||
shown.type("imageResolution", "0");
|
||
shown.type("imageResolution", "300");
|
||
QCOMPARE(shown.result(), QString("Result: 2,400 × 1,600 pixels"));
|
||
}
|
||
|
||
void ImageSizeSheetTests::aDocumentsOwnResolutionIsTheLastUsable()
|
||
{
|
||
for (const QString &unit : {QStringLiteral("Inches"), QStringLiteral("Centimeters")}) {
|
||
Sheet shown(1200, 800, 300);
|
||
shown.unit(unit);
|
||
shown.type("imageResolution", "0");
|
||
shown.type("imageWidth", "1");
|
||
shown.type("imageResolution", "-5");
|
||
shown.type("imageResolution", "150");
|
||
QCOMPARE(shown.result(), QString("Result: 600 × 400 pixels"));
|
||
}
|
||
// Pixels and Percent need no resolution: those edits apply.
|
||
for (const auto &[unit, width] : {std::pair(QStringLiteral("Pixels"), QStringLiteral("600")), std::pair(QStringLiteral("Percent"), QStringLiteral("50"))}) {
|
||
Sheet shown(1200, 800, 300);
|
||
shown.unit(unit);
|
||
shown.type("imageResolution", "0");
|
||
shown.type("imageWidth", width);
|
||
shown.type("imageResolution", "150");
|
||
QCOMPARE(shown.result(), QString("Result: 600 × 400 pixels"));
|
||
}
|
||
// Infinity is no usable resolution either.
|
||
for (const QString &unit : {QStringLiteral("Inches"), QStringLiteral("Centimeters")}) {
|
||
Sheet shown(1200, 800, 300);
|
||
shown.unit(unit);
|
||
shown.type("imageResolution", "inf");
|
||
QVERIFY(!shown.find<QPushButton>("imageResize").isEnabled());
|
||
shown.type("imageWidth", "1");
|
||
shown.type("imageResolution", "150");
|
||
QCOMPARE(shown.result(), QString("Result: 600 × 400 pixels"));
|
||
shown.find<QPushButton>("imageResize").click();
|
||
const ImageSizeOptions options = shown.answer.value().value();
|
||
QVERIFY(options.width == 600 && options.height == 400 && options.resolution == 150);
|
||
}
|
||
// Without resampling, print sizes wait for a usable resolution too.
|
||
for (const QString &unit : {QStringLiteral("Inches"), QStringLiteral("Centimeters")}) {
|
||
for (const QString &invalid : {QStringLiteral("0"), QStringLiteral("-5"), QStringLiteral("inf")}) {
|
||
Sheet held(1200, 800, 300);
|
||
held.unit(unit);
|
||
held.find<QCheckBox>("imageResample").click();
|
||
held.type("imageResolution", invalid);
|
||
const QString shownResolution = held.shown("imageResolution");
|
||
held.type("imageWidth", "1");
|
||
held.type("imageHeight", "2");
|
||
QCOMPARE(held.shown("imageResolution"), shownResolution);
|
||
QVERIFY(!held.find<QPushButton>("imageResize").isEnabled());
|
||
held.type("imageResolution", "150");
|
||
QCOMPARE(held.result(), QString("Result: 1,200 × 800 pixels"));
|
||
held.find<QCheckBox>("imageResample").click();
|
||
held.type("imageResolution", "300");
|
||
QCOMPARE(held.result(), QString("Result: 2,400 × 1,600 pixels"));
|
||
}
|
||
}
|
||
// Any finite positive resolution counts, even past Resize's range.
|
||
for (const QString &unit : {QStringLiteral("Inches"), QStringLiteral("Centimeters")}) {
|
||
Sheet low(12, 8, 300);
|
||
low.type("imageResolution", "0.5");
|
||
low.unit(unit);
|
||
low.type("imageResolution", "150");
|
||
QCOMPARE(low.result(), QString("Result: 3,600 × 2,400 pixels"));
|
||
Sheet high(300, 200, 300);
|
||
high.type("imageResolution", "12000");
|
||
high.unit(unit);
|
||
high.type("imageResolution", "6000");
|
||
QCOMPARE(high.result(), QString("Result: 150 × 100 pixels"));
|
||
}
|
||
// Without resampling the pixels stay, across the toggle.
|
||
Sheet shown(1200, 800, 300);
|
||
shown.type("imageResolution", "0");
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
shown.type("imageResolution", "150");
|
||
QCOMPARE(shown.result(), QString("Result: 1,200 × 800 pixels"));
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
shown.type("imageResolution", "300");
|
||
QCOMPARE(shown.result(), QString("Result: 2,400 × 1,600 pixels"));
|
||
}
|
||
|
||
void ImageSizeSheetTests::withoutResamplingOnlyTheResolutionMoves()
|
||
{
|
||
Sheet shown;
|
||
shown.type("imageWidth", "600");
|
||
shown.find<QCheckBox>("imageLocked").click();
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
// The pixels go back; physical units alone; locked.
|
||
QCOMPARE(shown.units(), (QStringList{"Inches", "Centimeters"}));
|
||
QCOMPARE(shown.find<QComboBox>("imageUnits").currentText(), QString("Inches"));
|
||
QVERIFY(shown.find<QCheckBox>("imageLocked").isChecked());
|
||
QVERIFY(!shown.find<QCheckBox>("imageLocked").isEnabled());
|
||
QVERIFY(!shown.find<QWidget>("imageSamplingRow").isVisible());
|
||
QCOMPARE(shown.find<QLabel>("imageExplanation").text(), QString("Only print dimensions and resolution change. Pixels stay unchanged."));
|
||
QCOMPARE(shown.result(), QString("Result: 1,200 × 800 pixels"));
|
||
shown.type("imageWidth", "10");
|
||
QCOMPARE(shown.shown("imageResolution"), QString("120"));
|
||
QCOMPARE(shown.shown("imageHeight"), QString("6.667"));
|
||
shown.unit("Centimeters");
|
||
shown.type("imageHeight", "25.4");
|
||
QCOMPARE(shown.shown("imageResolution"), QString("80"));
|
||
shown.find<QPushButton>("imageResize").click();
|
||
const ImageSizeOptions options = shown.answer.value().value();
|
||
QVERIFY(options.width == 1200 && options.height == 800 && options.resolution == 80);
|
||
// Without resampling a resolution moves no pixels.
|
||
shown.type("imageResolution", "160");
|
||
QCOMPARE(shown.result(), QString("Result: 1,200 × 800 pixels"));
|
||
// Back on, the units return; the pixels are kept.
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
QCOMPARE(shown.units(), (QStringList{"Pixels", "Percent", "Inches", "Centimeters"}));
|
||
QCOMPARE(shown.find<QComboBox>("imageUnits").currentText(), QString("Centimeters"));
|
||
QVERIFY(shown.find<QCheckBox>("imageLocked").isEnabled());
|
||
// A print-size edit updates the last usable resolution.
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
shown.type("imageHeight", "25.4");
|
||
QCOMPARE(shown.shown("imageResolution"), QString("80"));
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
shown.type("imageResolution", "160");
|
||
QCOMPARE(shown.result(), QString("Result: 2,400 × 1,600 pixels"));
|
||
}
|
||
|
||
void ImageSizeSheetTests::anInvalidSizeRestsResize()
|
||
{
|
||
Sheet shown;
|
||
auto &resize = shown.find<QPushButton>("imageResize");
|
||
QVERIFY(resize.isDefault() && resize.isEnabled());
|
||
shown.find<QCheckBox>("imageLocked").click();
|
||
shown.type("imageWidth", "30001");
|
||
QCOMPARE(shown.result(), QStringLiteral("Use 1–30,000 pixels per side, up to %1 megapixels, and 1–9,600 pixels/inch.").arg(DocumentLimits::maxSurfaceMegapixels()));
|
||
QCOMPARE(shown.find<QLabel>("imageResult").foregroundRole(), QPalette::BrightText);
|
||
QVERIFY(!resize.isEnabled());
|
||
// Past one surface's 200 megapixels while resampling.
|
||
shown.type("imageWidth", "20000");
|
||
shown.type("imageHeight", "10001");
|
||
QVERIFY(!resize.isEnabled());
|
||
shown.type("imageHeight", "10000");
|
||
QVERIFY(resize.isEnabled());
|
||
QCOMPARE(shown.find<QLabel>("imageResult").foregroundRole(), QPalette::PlaceholderText);
|
||
shown.type("imageResolution", "9601");
|
||
QVERIFY(!resize.isEnabled());
|
||
shown.type("imageResolution", "9600");
|
||
QVERIFY(resize.isEnabled());
|
||
shown.type("imageResolution", "0.5");
|
||
QVERIFY(!resize.isEnabled());
|
||
shown.type("imageResolution", "72");
|
||
shown.type("imageWidth", "30000");
|
||
shown.type("imageHeight", "1");
|
||
QVERIFY(resize.isEnabled());
|
||
// Without resampling the pixels are the canvas's, however many.
|
||
Sheet huge(30'000, 30'000);
|
||
QVERIFY(!huge.find<QPushButton>("imageResize").isEnabled());
|
||
huge.find<QCheckBox>("imageResample").click();
|
||
QVERIFY(huge.find<QPushButton>("imageResize").isEnabled());
|
||
}
|
||
|
||
void ImageSizeSheetTests::returnWithoutTypingKeepsTheNumbers()
|
||
{
|
||
Sheet shown;
|
||
shown.find<QCheckBox>("imageResample").click();
|
||
// A size shown to three places would move the resolution.
|
||
auto &width = shown.find<PickerField>("imageWidth");
|
||
width.setFocus();
|
||
QTest::keyClick(&width, Qt::Key_Return);
|
||
QCOMPARE(shown.shown("imageResolution"), QString("72"));
|
||
shown.type("imageWidth", "7");
|
||
auto &resolution = shown.find<PickerField>("imageResolution");
|
||
QCOMPARE(resolution.text(), QString("171.429"));
|
||
resolution.setFocus();
|
||
QTest::keyClick(&resolution, Qt::Key_Return);
|
||
shown.find<QPushButton>("imageResize").click();
|
||
QCOMPARE(shown.answer.value().value().resolution, 1200.0 / 7);
|
||
}
|
||
|
||
// Scrolled, Units take no focus; the typing meant pixels.
|
||
void ImageSizeSheetTests::aWheelOverUnitsCommitsTheTypingFirst()
|
||
{
|
||
Sheet shown;
|
||
// Focus moves only in the active window.
|
||
shown.sheet.activateWindow();
|
||
QVERIFY(QTest::qWaitForWindowActive(&shown.sheet));
|
||
auto &width = shown.find<PickerField>("imageWidth");
|
||
width.setFocus();
|
||
width.selectAll();
|
||
QTest::keyClicks(&width, "600");
|
||
auto &units = shown.find<QComboBox>("imageUnits");
|
||
QWheelEvent wheel(QPointF(5, 5), units.mapToGlobal(QPointF(5, 5)), QPoint(), QPoint(0, -120), Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase, false);
|
||
QApplication::sendEvent(&units, &wheel);
|
||
QCOMPARE(units.currentText(), QString("Percent"));
|
||
QCOMPARE(width.text(), QString("50"));
|
||
QCOMPARE(shown.result(), QString("Result: 600 × 400 pixels"));
|
||
}
|
||
|
||
// Foundation rounds halves to even: 17 pixels, 16 per inch.
|
||
void ImageSizeSheetTests::halfwayNumbersRoundToEven()
|
||
{
|
||
CanvasDocument canvas{17, 19};
|
||
canvas.resolution = 16;
|
||
ImageSizeSheet sheet(canvas, [](std::optional<ImageSizeOptions>) {});
|
||
auto &units = *sheet.findChild<QComboBox *>(QStringLiteral("imageUnits"));
|
||
const int inches = units.findText(QStringLiteral("Inches"));
|
||
units.setCurrentIndex(inches);
|
||
emit units.activated(inches);
|
||
QCOMPARE(sheet.findChild<PickerField *>(QStringLiteral("imageWidth"))->text(), QString("1.062"));
|
||
QCOMPARE(sheet.findChild<PickerField *>(QStringLiteral("imageHeight"))->text(), QString("1.188"));
|
||
}
|
||
|
||
QTEST_MAIN(ImageSizeSheetTests)
|
||
#include "ImageSizeSheetTests.moc"
|