441 lines
21 KiB
C++
441 lines
21 KiB
C++
#include "Document/BrushStroke.h"
|
|
#include "Document/EditorSession.h"
|
|
#include "UI/FilterSheet.h"
|
|
#include "UI/SliderSnap.h"
|
|
#include <QApplication>
|
|
#include <QLabel>
|
|
#include <QMouseEvent>
|
|
#include <QLayout>
|
|
#include <QLineEdit>
|
|
#include <QtTest>
|
|
|
|
// Swift 1.3.2's coloured filter sliders: tracks, resets, aligned titles.
|
|
namespace {
|
|
using Kind = CameraRawSliderTrack::Kind;
|
|
|
|
QImage solid(QColor colour)
|
|
{
|
|
QImage image(4, 4, QImage::Format_RGBA8888_Premultiplied);
|
|
image.fill(colour);
|
|
return image;
|
|
}
|
|
|
|
struct Sheet {
|
|
EditorSession session;
|
|
std::unique_ptr<FilterSheet> sheet;
|
|
explicit Sheet(FilterKind kind)
|
|
{
|
|
session.createDocument(4, 4);
|
|
const QImage image = solid(QColor::fromRgbF(0.8f, 0.3f, 0.2f));
|
|
session.insert(ImportedImage(image, image, QStringLiteral("Color")));
|
|
session.beginFilter(kind);
|
|
sheet = std::make_unique<FilterSheet>(session);
|
|
sheet->show();
|
|
}
|
|
const FilterSettings &settings() const { return session.filterEdit().value().settings; }
|
|
void set(const std::function<void(FilterSettings &)> &change, bool preview = true)
|
|
{
|
|
FilterSettings changed = settings();
|
|
change(changed);
|
|
session.updateFilter(changed, preview);
|
|
}
|
|
// The slider a title names, and that title.
|
|
QSlider &slider(const QString &title) const
|
|
{
|
|
for (QLabel *label : sheet->findChildren<QLabel *>()) {
|
|
if (label->text() == title && label->buddy())
|
|
return *static_cast<QSlider *>(label->buddy());
|
|
}
|
|
throw std::runtime_error("no slider titled " + title.toStdString());
|
|
}
|
|
QLabel &title(const QString &text) const
|
|
{
|
|
for (QLabel *label : sheet->findChildren<QLabel *>()) {
|
|
if (label->text() == text && label->buddy())
|
|
return *label;
|
|
}
|
|
throw std::runtime_error("no title " + text.toStdString());
|
|
}
|
|
CameraRawSlider &coloured(const QString &title) const
|
|
{
|
|
auto *found = qobject_cast<CameraRawSlider *>(&slider(title));
|
|
if (!found)
|
|
throw std::runtime_error("no coloured slider titled " + title.toStdString());
|
|
return *found;
|
|
}
|
|
};
|
|
|
|
// Swift's Color Balance ends, written out.
|
|
const std::array<std::vector<QColor>, 3> swiftEnds{
|
|
std::vector{QColor::fromRgbF(0.10f, 0.72f, 0.80f), QColor::fromRgbF(0.86f, 0.18f, 0.20f)},
|
|
std::vector{QColor::fromRgbF(0.80f, 0.22f, 0.70f), QColor::fromRgbF(0.24f, 0.70f, 0.30f)},
|
|
std::vector{QColor::fromRgbF(0.95f, 0.82f, 0.18f), QColor::fromRgbF(0.22f, 0.40f, 0.92f)}};
|
|
|
|
void send(QWidget &widget, QEvent::Type type, QPointF at, Qt::MouseButton button, Qt::MouseButtons buttons)
|
|
{
|
|
QMouseEvent event(type, at, widget.mapToGlobal(at), button, buttons, Qt::NoModifier);
|
|
QApplication::sendEvent(&widget, &event);
|
|
}
|
|
|
|
// Counts the paints a widget receives.
|
|
class PaintCount : public QObject {
|
|
public:
|
|
explicit PaintCount(QWidget &widget) { widget.installEventFilter(this); }
|
|
int paints = 0;
|
|
|
|
protected:
|
|
bool eventFilter(QObject *, QEvent *event) override
|
|
{
|
|
paints += event->type() == QEvent::Paint;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// A point on the knob, found along the slider's middle.
|
|
QPoint knob(const CameraRawSlider &slider)
|
|
{
|
|
for (int x = 0; x < slider.width(); ++x) {
|
|
const QPoint point(x, slider.height() / 2);
|
|
if (slider.isOnKnob(point))
|
|
return point;
|
|
}
|
|
throw std::runtime_error("no knob");
|
|
}
|
|
|
|
QList<QColor> pixels(const QImage &image)
|
|
{
|
|
QList<QColor> colours;
|
|
for (int y = 0; y < image.height(); ++y)
|
|
for (int x = 0; x < image.width(); ++x)
|
|
colours << image.pixelColor(x, y);
|
|
return colours;
|
|
}
|
|
|
|
// Shown rows' titles: the widest's width, sixty at least.
|
|
void checkAligned(const Sheet &shown, const QStringList &visible, const QStringList &hidden)
|
|
{
|
|
int widest = 60;
|
|
for (const QString &text : visible)
|
|
widest = std::max(widest, shown.title(text).sizeHint().width());
|
|
for (const QString &text : visible + hidden) {
|
|
QCOMPARE(shown.title(text).minimumWidth(), widest);
|
|
QCOMPARE(shown.title(text).maximumWidth(), widest);
|
|
}
|
|
}
|
|
}
|
|
|
|
class ColoredSliderTests : public QObject {
|
|
Q_OBJECT
|
|
private slots:
|
|
void initTestCase() { SliderSnap::install(); }
|
|
void colorBalanceTracksRunFromEachColorToItsOpposite();
|
|
void theSpectrumCentresOnItsHue();
|
|
void resettingAColoredFilterSliderRestoresTheDefault();
|
|
void blackAndWhiteAndColorBalanceSlidersAreColoured();
|
|
void aDoubleClickResetsItsOwnSliderOnly();
|
|
void titlesLineUpToTheWidestShown();
|
|
void rowsLayOutAsSwifts();
|
|
void aResetReplacesTheFieldsTyping();
|
|
void theTrackPaintsEveryStopInPlace();
|
|
void aTitleResetsOnlyForALeftDoubleClickWhileEnabled();
|
|
void aResetThenScrubsFromTheDefault();
|
|
void colorBalanceResetsEachOfItsNineRows();
|
|
void aNewTrackRepaintsTheSlider();
|
|
};
|
|
|
|
void ColoredSliderTests::colorBalanceTracksRunFromEachColorToItsOpposite()
|
|
{
|
|
const std::vector<QColor> cyanRed = FilterSheet::cyanRedTrack().colors().value();
|
|
QVERIFY(cyanRed[0].blueF() > cyanRed[0].redF() && cyanRed[1].redF() > cyanRed[1].blueF());
|
|
const std::vector<QColor> magentaGreen = FilterSheet::magentaGreenTrack().colors().value();
|
|
QVERIFY(magentaGreen[0].redF() > magentaGreen[0].greenF() && magentaGreen[1].greenF() > magentaGreen[1].redF());
|
|
const std::vector<QColor> yellowBlue = FilterSheet::yellowBlueTrack().colors().value();
|
|
QVERIFY(yellowBlue[0].greenF() > yellowBlue[0].blueF() && yellowBlue[1].blueF() > yellowBlue[1].greenF());
|
|
const QColor greens = CameraRawSliderTrack{Kind::luminance, 120}.colors().value().back();
|
|
QVERIFY(greens.greenF() > greens.redF() && greens.greenF() > greens.blueF());
|
|
// Swift's exact ends.
|
|
QVERIFY(cyanRed == swiftEnds[0] && magentaGreen == swiftEnds[1] && yellowBlue == swiftEnds[2]);
|
|
}
|
|
|
|
void ColoredSliderTests::theSpectrumCentresOnItsHue()
|
|
{
|
|
// Thirteen stops every 30 degrees, the hue in the middle.
|
|
const std::vector<QColor> circle = CameraRawSliderTrack{Kind::spectrum, 60}.colors().value();
|
|
QCOMPARE(int(circle.size()), 13);
|
|
for (size_t index = 0; index < circle.size(); ++index) {
|
|
const double hue = std::fmod(60 - 180 + 30.0 * double(index) + 720, 360);
|
|
QVERIFY2(std::abs(circle[index].hsvHueF() * 360 - hue) < 0.5 || std::abs(circle[index].hsvHueF() * 360 - hue) > 359.5, qPrintable(QString::number(index)));
|
|
QVERIFY(std::abs(circle[index].hsvSaturationF() - 0.85) < 0.01 && std::abs(circle[index].valueF() - 0.9) < 0.01);
|
|
}
|
|
// Black to white, as Lightness runs.
|
|
const std::vector<QColor> ends = CameraRawSliderTrack{.kind = Kind::opposing, .from = Qt::black, .to = Qt::white}.colors().value();
|
|
QVERIFY(ends == (std::vector<QColor>{Qt::black, Qt::white}));
|
|
}
|
|
|
|
void ColoredSliderTests::resettingAColoredFilterSliderRestoresTheDefault()
|
|
{
|
|
EditorSession session;
|
|
session.createDocument(4, 4);
|
|
const QImage base = solid(QColor::fromRgbF(0.8f, 0.3f, 0.2f));
|
|
session.insert(ImportedImage(base, base, QStringLiteral("Color")));
|
|
session.beginFilter(FilterKind::blackWhite);
|
|
FilterSettings settings = session.filterEdit().value().settings;
|
|
settings.blackWhite.reds = 250;
|
|
settings.blackWhite.blues = -100;
|
|
session.updateFilter(settings, true);
|
|
settings = FilterSheet::resetting([](FilterSettings &each) -> double & { return each.blackWhite.reds; }, settings);
|
|
QCOMPARE(settings.blackWhite.reds, BlackWhiteSettings().reds);
|
|
// Only the double-clicked slider resets.
|
|
QCOMPARE(settings.blackWhite.blues, -100.0);
|
|
session.updateFilter(FilterSheet::resetting([](FilterSettings &each) -> double & { return each.blackWhite.blues; }, settings), true);
|
|
QVERIFY(session.filterEdit().value().settings.blackWhite == BlackWhiteSettings());
|
|
QVERIFY(session.filterEdit().value().preview);
|
|
bool done = false;
|
|
session.commitFilter([&done] { done = true; });
|
|
QTRY_VERIFY(done);
|
|
QCOMPARE(pixels(session.activeLayer().value().asset.value().image()), pixels(BlackWhiteSettings().apply(base)));
|
|
session.undo();
|
|
|
|
session.beginFilter(FilterKind::colorBalance);
|
|
FilterSettings balance = session.filterEdit().value().settings;
|
|
balance.colorBalance.midCyanRed = -80;
|
|
session.updateFilter(balance, false);
|
|
session.updateFilter(FilterSheet::resetting([](FilterSettings &each) -> double & { return each.colorBalance.midCyanRed; }, balance), false);
|
|
QVERIFY(session.filterEdit().value().settings.colorBalance == ColorBalanceSettings());
|
|
// A reset leaves Preview off.
|
|
QVERIFY(!session.filterEdit().value().preview);
|
|
session.cancelFilter();
|
|
QCOMPARE(pixels(session.activeLayer().value().asset.value().image()), pixels(base));
|
|
}
|
|
|
|
void ColoredSliderTests::blackAndWhiteAndColorBalanceSlidersAreColoured()
|
|
{
|
|
Sheet blackWhite(FilterKind::blackWhite);
|
|
const std::pair<const char *, double> families[] = {{"Reds", 0}, {"Yellows", 60}, {"Greens", 120}, {"Cyans", 180}, {"Blues", 240}, {"Magentas", 300}};
|
|
for (const auto &[title, degrees] : families) {
|
|
const CameraRawSlider &slider = blackWhite.coloured(QString::fromLatin1(title));
|
|
QVERIFY(slider.track().kind == Kind::luminance && slider.track().degrees == degrees);
|
|
QCOMPARE(slider.toolTip(), QString::fromLatin1(title) + QStringLiteral(". Double-click to reset."));
|
|
}
|
|
// Tint's Hue is plain; Saturation follows the tint's hue.
|
|
QCOMPARE(blackWhite.coloured(QStringLiteral("Hue")).track().kind, Kind::plain);
|
|
QVERIFY(blackWhite.coloured(QStringLiteral("Saturation")).track().kind == Kind::saturation
|
|
&& blackWhite.coloured(QStringLiteral("Saturation")).track().degrees == 40);
|
|
blackWhite.set([](FilterSettings &settings) { settings.blackWhite.tintHue = 200; });
|
|
QCOMPARE(blackWhite.coloured(QStringLiteral("Saturation")).track().degrees, 200.0);
|
|
// Its knob sits at 40, between -200 and 300.
|
|
QCOMPARE(blackWhite.coloured(QStringLiteral("Reds")).shown(), 40.0);
|
|
// Dragged, the value lands whole.
|
|
blackWhite.coloured(QStringLiteral("Reds")).setValue(501);
|
|
QCOMPARE(blackWhite.settings().blackWhite.reds, 51.0);
|
|
|
|
Sheet balance(FilterKind::colorBalance);
|
|
const QList<CameraRawSlider *> sliders = balance.sheet->findChildren<CameraRawSlider *>();
|
|
QCOMPARE(sliders.size(), 9);
|
|
for (int index = 0; index < 9; ++index)
|
|
QVERIFY(sliders[index]->track().kind == Kind::opposing && sliders[index]->track().colors().value() == swiftEnds[size_t(index % 3)]);
|
|
// Other filters keep the plain slider.
|
|
Sheet blur(FilterKind::gaussianBlur);
|
|
QVERIFY(!qobject_cast<CameraRawSlider *>(&blur.slider(QStringLiteral("Radius"))));
|
|
}
|
|
|
|
void ColoredSliderTests::aDoubleClickResetsItsOwnSliderOnly()
|
|
{
|
|
Sheet shown(FilterKind::blackWhite);
|
|
QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
|
|
shown.set([](FilterSettings &settings) {
|
|
settings.blackWhite.reds = 250;
|
|
settings.blackWhite.blues = -100;
|
|
settings.blackWhite.tint = true;
|
|
settings.blackWhite.tintHue = 90;
|
|
}, false);
|
|
// On the title: that row alone, Preview left off.
|
|
QTest::mouseDClick(&shown.title(QStringLiteral("Reds")), Qt::LeftButton);
|
|
QVERIFY(shown.settings().blackWhite.reds == 40 && shown.settings().blackWhite.blues == -100);
|
|
QVERIFY(!shown.session.filterEdit().value().preview);
|
|
QCOMPARE(shown.sheet->findChild<QLineEdit *>(QStringLiteral("redsField"))->text(), QString("40"));
|
|
// On the knob.
|
|
CameraRawSlider &blues = shown.coloured(QStringLiteral("Blues"));
|
|
QTest::mouseDClick(&blues, Qt::LeftButton, {}, knob(blues));
|
|
QCOMPARE(shown.settings().blackWhite.blues, 20.0);
|
|
// The plain Hue resets too.
|
|
QTest::mouseDClick(&shown.title(QStringLiteral("Hue")), Qt::LeftButton);
|
|
QCOMPARE(shown.settings().blackWhite.tintHue, 40.0);
|
|
// A plain filter's title keeps its value.
|
|
Sheet blur(FilterKind::gaussianBlur);
|
|
blur.set([](FilterSettings &settings) { settings.radius = 25; });
|
|
QTest::mouseDClick(&blur.title(QStringLiteral("Radius")), Qt::LeftButton);
|
|
QCOMPARE(blur.settings().radius, 25.0);
|
|
}
|
|
|
|
void ColoredSliderTests::titlesLineUpToTheWidestShown()
|
|
{
|
|
const QStringList pairs{"Cyan / Red", "Magenta / Green", "Yellow / Blue"};
|
|
Sheet balance(FilterKind::colorBalance);
|
|
checkAligned(balance, pairs, {});
|
|
QVERIFY(balance.title(QStringLiteral("Magenta / Green")).width() > 60);
|
|
// Tint's rows count only while shown.
|
|
Sheet blackWhite(FilterKind::blackWhite);
|
|
const QStringList families{"Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"};
|
|
checkAligned(blackWhite, families, {"Hue", "Saturation"});
|
|
blackWhite.set([](FilterSettings &settings) { settings.blackWhite.tint = true; });
|
|
checkAligned(blackWhite, families + QStringList{"Hue", "Saturation"}, {});
|
|
// Hidden again, they stop counting.
|
|
blackWhite.set([](FilterSettings &settings) { settings.blackWhite.tint = false; });
|
|
checkAligned(blackWhite, families, {"Hue", "Saturation"});
|
|
// A lone short title keeps sixty.
|
|
Sheet blur(FilterKind::gaussianBlur);
|
|
QCOMPARE(blur.title(QStringLiteral("Radius")).width(), 60);
|
|
}
|
|
|
|
void ColoredSliderTests::rowsLayOutAsSwifts()
|
|
{
|
|
// Title, slider 10 on, field 10 on, unit 2 past.
|
|
for (const auto &[kind, text, field] : {std::tuple(FilterKind::gaussianBlur, "Radius", "radiusField"), std::tuple(FilterKind::blackWhite, "Reds", "redsField")}) {
|
|
Sheet shown(kind);
|
|
QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
|
|
QLabel &title = shown.title(QString::fromLatin1(text));
|
|
QSlider &slider = shown.slider(QString::fromLatin1(text));
|
|
QLineEdit &entry = *shown.sheet->findChild<QLineEdit *>(QString::fromLatin1(field));
|
|
QWidget *box = title.parentWidget();
|
|
QCOMPARE(title.x(), 0);
|
|
QCOMPARE(slider.x() - title.geometry().right() - 1, 10);
|
|
QCOMPARE(entry.x() - slider.geometry().right() - 1, 10);
|
|
QLabel *unit = box->findChildren<QLabel *>().last();
|
|
QCOMPARE(unit->x() - entry.geometry().right() - 1, 2);
|
|
QCOMPARE(unit->geometry().right() + 1, box->width());
|
|
QCOMPARE(box->height(), box->sizeHint().height());
|
|
// The row sits in the sheet's column, among the rest.
|
|
QVERIFY(shown.sheet->layout()->indexOf(box) >= 0);
|
|
}
|
|
}
|
|
|
|
void ColoredSliderTests::aResetReplacesTheFieldsTyping()
|
|
{
|
|
Sheet shown(FilterKind::blackWhite);
|
|
QVERIFY(QTest::qWaitForWindowActive(shown.sheet.get()));
|
|
shown.set([](FilterSettings &settings) { settings.blackWhite.reds = 250; });
|
|
auto &field = *shown.sheet->findChild<QLineEdit *>(QStringLiteral("redsField"));
|
|
field.setFocus();
|
|
field.selectAll();
|
|
QTest::keyClicks(&field, QStringLiteral("7"));
|
|
QVERIFY(field.isModified());
|
|
QTest::mouseDClick(&shown.title(QStringLiteral("Reds")), Qt::LeftButton);
|
|
QVERIFY(!field.isModified());
|
|
QCOMPARE(field.text(), QString("40"));
|
|
// Leaving the field applies nothing more.
|
|
shown.sheet->findChild<QLineEdit *>(QStringLiteral("bluesField"))->setFocus();
|
|
QCOMPARE(shown.settings().blackWhite.reds, 40.0);
|
|
}
|
|
|
|
void ColoredSliderTests::theTrackPaintsEveryStopInPlace()
|
|
{
|
|
// Round red: violet a quarter in, red in the middle.
|
|
CameraRawSlider slider(-100, 100, CameraRawSliderTrack{Kind::spectrum, 0}, QStringLiteral("Probe"), [](double) {}, [] {});
|
|
slider.resize(400, 22);
|
|
slider.display(100);
|
|
const QImage painted = slider.grab().toImage();
|
|
const auto hueAt = [&](double share) { return painted.pixelColor(int(share * painted.width()), painted.height() / 2).hsvHueF() * 360; };
|
|
QVERIFY2(std::abs(hueAt(0.25) - 270) < 25, qPrintable(QString::number(hueAt(0.25))));
|
|
const double middle = hueAt(0.5);
|
|
QVERIFY2(middle < 20 || middle > 340, qPrintable(QString::number(middle)));
|
|
QVERIFY2(std::abs(hueAt(0.75) - 90) < 25, qPrintable(QString::number(hueAt(0.75))));
|
|
}
|
|
|
|
void ColoredSliderTests::aTitleResetsOnlyForALeftDoubleClickWhileEnabled()
|
|
{
|
|
Sheet shown(FilterKind::blackWhite);
|
|
QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
|
|
shown.set([](FilterSettings &settings) { settings.blackWhite.reds = 250; });
|
|
for (const Qt::MouseButton button : {Qt::RightButton, Qt::MiddleButton}) {
|
|
QTest::mouseDClick(&shown.title(QStringLiteral("Reds")), button);
|
|
QCOMPARE(shown.settings().blackWhite.reds, 250.0);
|
|
}
|
|
// A resting sheet resets nothing.
|
|
shown.sheet->setEnabled(false);
|
|
send(shown.title(QStringLiteral("Reds")), QEvent::MouseButtonDblClick, QPointF(2, 2), Qt::LeftButton, Qt::LeftButton);
|
|
QCOMPARE(shown.settings().blackWhite.reds, 250.0);
|
|
shown.sheet->setEnabled(true);
|
|
QTest::mouseDClick(&shown.title(QStringLiteral("Reds")), Qt::LeftButton);
|
|
QCOMPARE(shown.settings().blackWhite.reds, 40.0);
|
|
}
|
|
|
|
void ColoredSliderTests::aResetThenScrubsFromTheDefault()
|
|
{
|
|
// A real double click: the second press goes on scrubbing.
|
|
Sheet shown(FilterKind::blackWhite);
|
|
QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
|
|
shown.set([](FilterSettings &settings) { settings.blackWhite.reds = 250; });
|
|
QLabel &title = shown.title(QStringLiteral("Reds"));
|
|
send(title, QEvent::MouseButtonPress, QPointF(2, 2), Qt::LeftButton, Qt::LeftButton);
|
|
send(title, QEvent::MouseButtonRelease, QPointF(2, 2), Qt::LeftButton, Qt::NoButton);
|
|
send(title, QEvent::MouseButtonDblClick, QPointF(2, 2), Qt::LeftButton, Qt::LeftButton);
|
|
QCOMPARE(shown.settings().blackWhite.reds, 40.0);
|
|
send(title, QEvent::MouseMove, QPointF(14, 2), Qt::NoButton, Qt::LeftButton);
|
|
send(title, QEvent::MouseButtonRelease, QPointF(14, 2), Qt::LeftButton, Qt::NoButton);
|
|
QCOMPARE(shown.settings().blackWhite.reds, 52.0);
|
|
}
|
|
|
|
void ColoredSliderTests::colorBalanceResetsEachOfItsNineRows()
|
|
{
|
|
Sheet shown(FilterKind::colorBalance);
|
|
QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
|
|
const std::array<double ColorBalanceSettings::*, 9> fields{
|
|
&ColorBalanceSettings::shadowCyanRed, &ColorBalanceSettings::shadowMagentaGreen, &ColorBalanceSettings::shadowYellowBlue,
|
|
&ColorBalanceSettings::midCyanRed, &ColorBalanceSettings::midMagentaGreen, &ColorBalanceSettings::midYellowBlue,
|
|
&ColorBalanceSettings::highlightCyanRed, &ColorBalanceSettings::highlightMagentaGreen, &ColorBalanceSettings::highlightYellowBlue};
|
|
const QList<CameraRawSlider *> sliders = shown.sheet->findChildren<CameraRawSlider *>();
|
|
QCOMPARE(sliders.size(), 9);
|
|
for (size_t index = 0; index < fields.size(); ++index) {
|
|
shown.set([&fields](FilterSettings &settings) {
|
|
for (size_t each = 0; each < fields.size(); ++each)
|
|
settings.colorBalance.*fields[each] = double(each + 1) * 10;
|
|
}, false);
|
|
CameraRawSlider &slider = *sliders[qsizetype(index)];
|
|
// Titles on even rows, knobs on odd ones.
|
|
if (index % 2 == 0) {
|
|
QLabel *title = nullptr;
|
|
for (QLabel *label : shown.sheet->findChildren<QLabel *>())
|
|
title = label->buddy() == &slider ? label : title;
|
|
QTest::mouseDClick(title, Qt::LeftButton);
|
|
// The double click's own release ends its scrub.
|
|
send(*title, QEvent::MouseButtonRelease, QPointF(2, 2), Qt::LeftButton, Qt::NoButton);
|
|
} else {
|
|
QTest::mouseDClick(&slider, Qt::LeftButton, {}, knob(slider));
|
|
}
|
|
for (size_t each = 0; each < fields.size(); ++each)
|
|
QCOMPARE(shown.settings().colorBalance.*fields[each], each == index ? 0.0 : double(each + 1) * 10);
|
|
QVERIFY(!shown.session.filterEdit().value().preview);
|
|
}
|
|
}
|
|
|
|
void ColoredSliderTests::aNewTrackRepaintsTheSlider()
|
|
{
|
|
// Swift's needsDisplay: the knob stays, the gradient changes.
|
|
CameraRawSlider slider(-100, 100, CameraRawSliderTrack{Kind::saturation, 0}, QStringLiteral("Probe"), [](double) {}, [] {});
|
|
slider.resize(200, 22);
|
|
slider.display(20);
|
|
slider.show();
|
|
QVERIFY(QTest::qWaitForWindowExposed(&slider));
|
|
QTest::qWait(50);
|
|
PaintCount count(slider);
|
|
slider.reshape(-100, 100, CameraRawSliderTrack{Kind::saturation, 200}, 20);
|
|
QTRY_COMPARE(count.paints, 1);
|
|
// Mid-drag too.
|
|
slider.setSliderDown(true);
|
|
slider.reshape(-100, 100, CameraRawSliderTrack{Kind::spectrum, 90}, 60);
|
|
QTRY_COMPARE(count.paints, 2);
|
|
slider.setSliderDown(false);
|
|
// In a sheet: Tint's saturation follows its hue.
|
|
Sheet shown(FilterKind::blackWhite);
|
|
shown.set([](FilterSettings &settings) { settings.blackWhite.tint = true; });
|
|
QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
|
|
QTest::qWait(50);
|
|
PaintCount saturation(shown.coloured(QStringLiteral("Saturation")));
|
|
shown.set([](FilterSettings &settings) { settings.blackWhite.tintHue = 200; });
|
|
QTRY_VERIFY(saturation.paints >= 1);
|
|
}
|
|
|
|
QTEST_MAIN(ColoredSliderTests)
|
|
#include "ColoredSliderTests.moc"
|