ZacharyZhang-NY/OmaPhoto
1
1 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity
Files
0616f9b00649e608c2fc9588c1fac3d8caf32c58
OmaPhoto/tests/FloatingPanelTests.cpp
T

311 lines
14 KiB
C++
Raw Blame History

#include "CanvasFixtures.h"
#include "UI/ColorPickerSheet.h"
#include "UI/FilterSheet.h"
#include "UI/FloatingPanel.h"
#include "UI/HueSaturationSheet.h"
#include "UI/LevelsSheet.h"
#include <QApplication>
#include <QLabel>
#include <QVBoxLayout>
#include <QWindow>
#include <QtTest>
// Swift's FloatingPanelTests.
namespace {
QWidget *visiblePanel(const QString &name)
{
for (QWidget *widget : QApplication::topLevelWidgets()) {
if (widget->objectName() == name && widget->isVisible())
return widget;
}
return nullptr;
}
}
class FloatingPanelTests : public QObject {
Q_OBJECT
private slots:
void colorPickerPanelSurvivesALayoutPass();
void levelsPanelSurvivesALayoutPass();
void adjustmentPanelSurvivesALayoutPass();
void adjustmentEditorsUseMovableNonmodalPanels_data();
void adjustmentEditorsUseMovableNonmodalPanels();
void aPanelOpensOverTheCanvasThenWhereItWasLeft();
void itsCloseButtonAndEscapeCancel();
void aPanelRemembersWhereItIsMovedAndCentresWithoutACanvas();
void dockedPlacementLeavesTheSavedFilterPosition();
};
void FloatingPanelTests::colorPickerPanelSurvivesALayoutPass()
{
Shown shown(QSize(40, 20));
QImage image(40, 20, QImage::Format_RGBA8888_Premultiplied);
image.fill(Qt::red);
shown.session.insert(ImportedImage(image, image, QStringLiteral("Red")));
shown.session.openColorPicker(false);
ColorPickerPanelController controller(shown.window);
controller.show(shown.session.colorPicker().value(), shown.session);
QTest::qWait(400);
QWidget *panel = visiblePanel(ColorPickerPanelController::identifier());
QVERIFY(panel);
QVERIFY(panel->findChild<ColorPickerSheet *>());
QVERIFY(!panel->isModal());
QVERIFY(panel->windowFlags().testFlag(Qt::Tool));
controller.close();
shown.session.closeColorPicker(false);
QVERIFY(!panel->isVisible());
}
void FloatingPanelTests::levelsPanelSurvivesALayoutPass()
{
Shown shown(QSize(40, 20));
QImage image(40, 20, QImage::Format_RGBA8888_Premultiplied);
image.fill(Qt::red);
shown.session.insert(ImportedImage(image, image, QStringLiteral("Red")));
shown.session.beginLevels();
FloatingPanel panel(QStringLiteral("testLevelsPanel"), shown.window);
panel.show(QStringLiteral("Levels"), new LevelsSheet(shown.session));
QTest::qWait(400);
QVERIFY(panel.isVisible());
// A preview landing while hosted survives a pass too.
LevelsSettings settings;
settings.setCurrent(LevelRange{0, 2, 255, 0, 255});
shown.session.updateLevels(settings, true);
QTRY_VERIFY(shown.session.levels().value().preparedPreview);
QTest::qWait(400);
panel.close();
shown.session.cancelLevels();
QVERIFY(!panel.isVisible() && !shown.session.levels());
}
void FloatingPanelTests::adjustmentPanelSurvivesALayoutPass()
{
Shown shown(QSize(40, 20));
QImage image(40, 20, QImage::Format_RGBA8888_Premultiplied);
image.fill(Qt::red);
shown.session.insert(ImportedImage(image, image, QStringLiteral("Red")));
shown.session.beginHueSaturation();
FloatingPanel panel(QStringLiteral("testAdjustmentPanel"), shown.window);
panel.show(QStringLiteral("Hue/Saturation"), new HueSaturationSheet(shown.session));
QTest::qWait(400);
QVERIFY(panel.isVisible());
const int height = visiblePanel(QStringLiteral("testAdjustmentPanel"))->height();
// A range's spectrum grows it; a landed preview passes too.
shown.session.updateHueSaturation(HueSaturationSettings(120, 0, 0, false, ColorRange::reds), true);
QTRY_VERIFY(shown.session.hueSaturation().value().previewImage(shown.session.activeLayerID().value()));
QTest::qWait(400);
QVERIFY(visiblePanel(QStringLiteral("testAdjustmentPanel"))->height() > height);
panel.close();
shown.session.cancelHueSaturation();
QVERIFY(!panel.isVisible() && !shown.session.hueSaturation());
}
void FloatingPanelTests::adjustmentEditorsUseMovableNonmodalPanels_data()
{
QTest::addColumn<AdjustmentKind>("kind");
// Invert has no settings, so no editor, as Swift's.
for (const AdjustmentKind kind : allAdjustmentKinds)
if (isEditable(kind))
QTest::newRow(qPrintable(rawValue(kind))) << kind;
}
void FloatingPanelTests::adjustmentEditorsUseMovableNonmodalPanels()
{
QFETCH(AdjustmentKind, kind);
Shown shown(QSize(40, 20));
QImage image(40, 20, QImage::Format_RGBA8888_Premultiplied);
image.fill(Qt::red);
shown.session.insert(ImportedImage(image, image, QStringLiteral("Red")));
shown.session.addAdjustment(kind);
bool opened = false;
shown.session.beginAdjustmentEditing(shown.session.adjustmentEditingID().value(), [&opened] { opened = true; });
QTRY_VERIFY(opened);
FloatingPanel controller(QStringLiteral("testDynamicAdjustmentPanel"), shown.window);
controller.onClose = [&shown] { shown.session.finishAdjustmentEditing(false); };
if (kind == AdjustmentKind::levels)
controller.show(QStringLiteral("Levels"), new LevelsSheet(shown.session));
else if (kind == AdjustmentKind::hsv)
controller.show(QStringLiteral("Hue/Saturation"), new HueSaturationSheet(shown.session));
else
controller.show(rawValue(kind), new FilterSheet(shown.session));
QTest::qWait(400);
QWidget *panel = visiblePanel(QStringLiteral("testDynamicAdjustmentPanel"));
QVERIFY(panel);
// A tool window beside the canvas: movable, never modal.
QVERIFY(panel->windowFlags().testFlag(Qt::Tool) && !panel->isModal() && !shown.session.showsBusy());
const QPoint origin = panel->pos();
panel->move(origin + QPoint(20, 20));
QCOMPARE(panel->pos(), origin + QPoint(20, 20));
panel->close();
QVERIFY(!shown.session.adjustmentEditingID());
QVERIFY(!shown.session.levels() && !shown.session.hueSaturation() && !shown.session.filterEdit());
}
void FloatingPanelTests::aPanelOpensOverTheCanvasThenWhereItWasLeft()
{
Shown shown;
// Wider than the canvas: the canvas's middle, not the window's.
shown.window.resize(600, 400);
FloatingPanel panel(QStringLiteral("testPlacedPanel"), shown.window);
QVERIFY(!panel.isVisible());
panel.close();
// First over the canvas's middle.
panel.show(QStringLiteral("First"), new QLabel(QStringLiteral("One")));
QWidget *window = visiblePanel(QStringLiteral("testPlacedPanel"));
QVERIFY(window);
const QPoint middle = shown.canvas->mapToGlobal(shown.canvas->rect().center());
QVERIFY(std::abs(window->pos().x() + window->width() / 2 - middle.x()) <= 1);
QVERIFY(std::abs(window->pos().y() + window->height() / 2 - middle.y()) <= 1);
// It takes the keys, fixed to its content's size.
QTRY_COMPARE(QApplication::activeWindow(), window);
QCOMPARE(window->size(), window->findChild<QLabel *>()->sizeHint());
QCOMPARE(window->minimumSize(), window->maximumSize());
// Moved, it keeps its place through content and a close.
const QPoint spot(30, 20);
window->move(spot);
// Shown again, it takes the keys back.
shown.window.activateWindow();
QTRY_COMPARE(QApplication::activeWindow(), &shown.window);
auto *old = new QLabel(QStringLiteral("Old"));
panel.show(QStringLiteral("Second"), old);
QTRY_COMPARE(QApplication::activeWindow(), window);
QCOMPARE(window->pos(), spot);
QCOMPARE(window->windowTitle(), QString("Second"));
QTRY_VERIFY(old->isVisible());
QPointer<QLabel> gone(old);
auto *wider = new QLabel(QStringLiteral("Wider content than before"));
panel.show(QStringLiteral("Third"), wider);
QVERIFY(gone && !gone->isVisible());
QCOMPARE(window->size(), wider->sizeHint());
QTRY_VERIFY(!gone);
panel.close();
QVERIFY(!panel.isVisible());
panel.show(QStringLiteral("Fourth"), new QLabel(QStringLiteral("Four")));
QCOMPARE(window->pos(), spot);
// Another panel of that name, later, opens there too.
panel.close();
FloatingPanel again(QStringLiteral("testPlacedPanel"), shown.window);
again.show(QStringLiteral("Again"), new QLabel(QStringLiteral("Five")));
QCOMPARE(visiblePanel(QStringLiteral("testPlacedPanel"))->pos(), spot);
}
void FloatingPanelTests::itsCloseButtonAndEscapeCancel()
{
Shown shown;
// Without a listener, its close button just closes.
FloatingPanel quiet(QStringLiteral("testQuietPanel"), shown.window);
quiet.show(QStringLiteral("Quiet"), new QLabel(QStringLiteral("Content")));
visiblePanel(QStringLiteral("testQuietPanel"))->close();
QVERIFY(!quiet.isVisible());
// A hidden panel is never handed the keys.
shown.window.activateWindow();
QTRY_COMPARE(QApplication::activeWindow(), &shown.window);
FloatingPanel::refocus(QStringLiteral("testQuietPanel"));
QTest::qWait(50);
QCOMPARE(QApplication::activeWindow(), &shown.window);
FloatingPanel panel(QStringLiteral("testClosedPanel"), shown.window);
int closes = 0;
panel.onClose = [&closes] { ++closes; };
panel.show(QStringLiteral("Panel"), new QLabel(QStringLiteral("Content")));
QWidget *window = visiblePanel(QStringLiteral("testClosedPanel"));
QVERIFY(window);
window->close();
QCOMPARE(closes, 1);
QVERIFY(!panel.isVisible());
panel.show(QStringLiteral("Panel"), new QLabel(QStringLiteral("Content")));
QTest::keyClick(window, Qt::Key_Escape);
QCOMPARE(closes, 2);
QVERIFY(!panel.isVisible());
// Hidden by its owner, it reports nothing.
panel.show(QStringLiteral("Panel"), new QLabel(QStringLiteral("Content")));
panel.close();
QCOMPARE(closes, 2);
// A click on the canvas hands it the keys back.
panel.show(QStringLiteral("Panel"), new QLabel(QStringLiteral("Content")));
shown.window.activateWindow();
QTRY_COMPARE(QApplication::activeWindow(), &shown.window);
FloatingPanel::refocus(QStringLiteral("testClosedPanel"));
QTRY_COMPARE(QApplication::activeWindow(), window);
// Only the panel of that name.
quiet.show(QStringLiteral("Quiet"), new QLabel(QStringLiteral("Content")));
QWidget *other = visiblePanel(QStringLiteral("testQuietPanel"));
QTRY_COMPARE(QApplication::activeWindow(), other);
FloatingPanel::refocus(QStringLiteral("testClosedPanel"));
QTRY_COMPARE(QApplication::activeWindow(), window);
// A miss activates no widget; a bare window keeps focus.
QWindow bare;
bare.show();
bare.requestActivate();
QTRY_COMPARE(QGuiApplication::focusWindow(), &bare);
FloatingPanel::refocus(QStringLiteral("testMissingPanel"));
QTest::qWait(50);
QCOMPARE(QGuiApplication::focusWindow(), &bare);
}
void FloatingPanelTests::aPanelRemembersWhereItIsMovedAndCentresWithoutACanvas()
{
Shown shown;
QPointer<QWidget> dropped;
{
FloatingPanel moved(QStringLiteral("testMovedPanel"), shown.window);
moved.show(QStringLiteral("Moved"), new QLabel(QStringLiteral("Content")));
dropped = visiblePanel(QStringLiteral("testMovedPanel"));
dropped->move(QPoint(25, 35));
QTRY_COMPARE(dropped->pos(), QPoint(25, 35));
}
// Its window goes with it.
QVERIFY(!dropped);
// Gone without a close, it reopens where it was moved.
FloatingPanel again(QStringLiteral("testMovedPanel"), shown.window);
again.show(QStringLiteral("Again"), new QLabel(QStringLiteral("Content")));
QCOMPARE(visiblePanel(QStringLiteral("testMovedPanel"))->pos(), QPoint(25, 35));
// Shown, never moved, it keeps that place for the next.
QPoint first;
{
FloatingPanel still(QStringLiteral("testStillPanel"), shown.window);
still.show(QStringLiteral("Still"), new QLabel(QStringLiteral("Content")));
first = visiblePanel(QStringLiteral("testStillPanel"))->pos();
}
const QPoint away = shown.window.pos() + QPoint(40, 30);
shown.window.move(away);
QTRY_COMPARE(shown.window.pos(), away);
FloatingPanel next(QStringLiteral("testStillPanel"), shown.window);
next.show(QStringLiteral("Next"), new QLabel(QStringLiteral("Content")));
QCOMPARE(visiblePanel(QStringLiteral("testStillPanel"))->pos(), first);
// A window without a canvas centres it on itself.
QWidget plain;
plain.setGeometry(100, 80, 500, 300);
plain.show();
QVERIFY(QTest::qWaitForWindowExposed(&plain));
FloatingPanel centred(QStringLiteral("testCentredPanel"), plain);
centred.show(QStringLiteral("Centred"), new QLabel(QStringLiteral("Content")));
QWidget *window = visiblePanel(QStringLiteral("testCentredPanel"));
const QPoint middle = plain.geometry().center();
QVERIFY(std::abs(window->pos().x() + window->width() / 2 - middle.x()) <= 1);
QVERIFY(std::abs(window->pos().y() + window->height() / 2 - middle.y()) <= 1);
}
// Swift's test: a docked frame never sets where panels reopen.
void FloatingPanelTests::dockedPlacementLeavesTheSavedFilterPosition()
{
Shown shown;
auto *slot = new QWidget(&shown.window);
auto *layout = new QVBoxLayout(slot);
slot->setGeometry(250, 0, 150, 300);
FloatingPanel panel(QStringLiteral("testDockedPanel"), shown.window);
panel.show(QStringLiteral("Docked"), new QLabel(QStringLiteral("Docked")), slot);
QVERIFY(!visiblePanel(QStringLiteral("testDockedPanel")) && panel.isVisible());
// The docked panel moves inside its slot; nothing is kept.
layout->setContentsMargins(20, 20, 0, 0);
layout->activate();
panel.close();
QVERIFY(!slot->isVisible() && !panel.isVisible());
panel.show(QStringLiteral("Floating"), new QLabel(QStringLiteral("Floating")));
QWidget *window = visiblePanel(QStringLiteral("testDockedPanel"));
const QPoint middle = shown.canvas->mapToGlobal(shown.canvas->rect().center());
QVERIFY(std::abs(window->pos().x() + window->width() / 2 - middle.x()) <= 1);
}
QTEST_MAIN(FloatingPanelTests)
#include "FloatingPanelTests.moc"
Reference in new issue View Git Blame Copy Permalink