Quit settles a pending gradient, a pixel move and open dialogs; Dither › Scanlines (CRT) on all cores (13.17)

kernels/DitherPixels.c

@@ -1,9 +1,30 @@
 #include "DitherPixels.h"
 #include <math.h>
 #include <stdlib.h>
+#include <stdatomic.h>
+
+// Linux: GCD's dispatch_apply, run on QtConcurrent by Document/Dither.cpp. Blocks become functions with a context.
+void dither_bands(size_t bands, void (*band)(void *context, size_t index), void *context);
 
 static inline float clamp01(float v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
 
+typedef void (*band_body)(void *context, size_t start, size_t end);
+typedef struct { size_t count, size; band_body body; void *context; } band_job;
+
+static void run_band(void *context, size_t band) {
+    const band_job *job = context;
+    size_t count = job->count, size = job->size;
+    size_t start = band * size, end = start + size < count ? start + size : count;
+    if (start < end) job->body(job->context, start, end);
+}
+
+// Runs `body` over `count` items split into a few runs per core, each a (start, end) range, all at once.
+static void in_bands(size_t count, band_body body, void *context) {
+    size_t bands = count < 64 ? 1 : 32, size = (count + bands - 1) / bands;
+    band_job job = { count, size, body, context };
+    dither_bands(bands, run_band, &job);
+}
+
 // Density darkens (positive) or lightens as a gamma, so black and white stay put; contrast pivots on mid gray.
 static inline float adjust_tone(float v, float gamma, float contrast) {
     v = powf(clamp01(v), gamma);
@@ -114,19 +135,17 @@ static inline void write_pixel(uint8_t *px, float r, float g, float b) {
     px[2] = (uint8_t)lroundf(clamp01(b) * a * 255.0f);
 }
 
-int dither_apply(uint8_t *rgba, size_t width, size_t height, size_t stride, const DitherParams *p) {
-    size_t count = width * height;
-    if (!count) return 1;
-    int planes = p->originalColors ? 3 : 1;
-    float *tone = malloc(count * sizeof(float) * (size_t)planes);
-    uint8_t *alpha = malloc(count);
-    // The image's own colors, unadjusted: halftone dots and glyphs take them in Original mode.
-    float *source = p->originalColors ? malloc(count * sizeof(float) * 3) : NULL;
-    if (!tone || !alpha || (p->originalColors && !source)) { free(tone); free(alpha); free(source); return 0; }
+typedef struct {
+    uint8_t *rgba; size_t stride, width, count; uint8_t *alpha; float *tone, *source; const DitherParams *p;
+    float gamma, contrast;
+} tone_job;
 
-    float gamma = exp2f(p->density * 1.5f);
-    float contrast = p->contrast >= 0 ? 1.0f / (1.0f - 0.95f * p->contrast) : 1.0f + p->contrast;
-    for (size_t y = 0; y < height; ++y) {
+static void tone_band(void *context, size_t first, size_t last) {
+    const tone_job *job = context;
+    uint8_t *rgba = job->rgba; size_t stride = job->stride, width = job->width, count = job->count;
+    uint8_t *alpha = job->alpha; float *tone = job->tone, *source = job->source; const DitherParams *p = job->p;
+    float gamma = job->gamma, contrast = job->contrast;
+    for (size_t y = first; y < last; ++y) {
         const uint8_t *row = rgba + y * stride;
         for (size_t x = 0; x < width; ++x) {
             const uint8_t *px = row + x * 4;
@@ -147,6 +166,90 @@ int dither_apply(uint8_t *rgba, size_t width, size_t height, size_t stride, cons
             }
         }
     }
+}
+
+typedef struct {
+    uint8_t *rgba; size_t stride, width, height, count; int planes; const uint8_t *alpha; const float *tone;
+    const DitherParams *p; size_t spacing; float middle, dots; const float *screen, *phosphor; atomic_int failed;
+} scan_job;
+
+static void scan_band(void *context, size_t firstLine, size_t lastLine) {
+    scan_job *job = context;
+    uint8_t *rgba = job->rgba; size_t stride = job->stride, width = job->width, height = job->height, count = job->count;
+    int planes = job->planes; const uint8_t *alpha = job->alpha; const float *tone = job->tone; const DitherParams *p = job->p;
+    size_t spacing = job->spacing; float middle = job->middle, dots = job->dots;
+    const float *screen = job->screen, *phosphor = job->phosphor;
+    float *scan = malloc(width * sizeof(float) * (size_t)planes);
+    if (!scan) { atomic_store(&job->failed, 1); return; }
+    for (size_t line = firstLine; line < lastLine; ++line) {
+        size_t top = line * spacing;
+        size_t bottom = top + spacing < height ? top + spacing : height;
+        // Wobble: each line is pushed sideways, a slow wave down the screen with a quicker one over it, as a
+        // CRT's picture wavers when its sync drifts.
+        float wave = sinf((float)line * 0.45f) * 0.7f + sinf((float)line * 1.7f + 1.3f) * 0.3f;
+        long shift = lroundf(p->wobble * wave);
+        for (size_t x = 0; x < width; ++x) {
+            float sum[3] = { 0, 0, 0 }; int n = 0;
+            long sx = (long)x - shift;
+            if (sx >= 0 && sx < (long)width)
+                for (size_t y = top; y < bottom; ++y) {
+                    size_t at = y * width + (size_t)sx;
+                    if (!alpha[at]) continue;
+                    for (int c = 0; c < planes; ++c) sum[c] += tone[(size_t)c * count + at];
+                    ++n;
+                }
+            for (int c = 0; c < planes; ++c) scan[(size_t)c * width + x] = n ? sum[c] / (float)n : 0;
+        }
+        for (size_t y = top; y < bottom; ++y) {
+            uint8_t *row = rgba + y * stride;
+            float offset = fabsf((float)(y - top) + 0.5f - middle);
+            for (size_t x = 0; x < width; ++x) {
+                if (!alpha[y * width + x]) continue;
+                // Dots: the line breaks into beads, one every line spacing, each lit in the color at its middle.
+                float along = fmodf((float)x + 0.5f, (float)spacing) - middle;
+                long centered = lroundf((float)x - along * dots);
+                size_t at = centered < 0 ? 0 : (size_t)centered >= width ? width - 1 : (size_t)centered;
+                float r, g, b, t;
+                if (p->originalColors) {
+                    r = scan[at]; g = scan[width + at]; b = scan[2 * width + at];
+                    t = 0.2126f * r + 0.7152f * g + 0.0722f * b;
+                } else {
+                    t = scan[at];
+                    r = screen[0] + (phosphor[0] - screen[0]) * t;
+                    g = screen[1] + (phosphor[1] - screen[1]) * t;
+                    b = screen[2] + (phosphor[2] - screen[2]) * t;
+                }
+                // The beam is driven brighter than the picture, making up for the dark screen between lines.
+                r *= 1.35f; g *= 1.35f; b *= 1.35f;
+                // Half the beam's height: a thin line in the shadows, most of the way across in the highlights,
+                // always leaving dark screen between lines.
+                float beam = middle * (0.2f + 0.5f * sqrtf(clamp01(t)));
+                float across = along * dots, distance = sqrtf(offset * offset + across * across);
+                float cover = clamp01(beam - distance + 0.5f);
+                // Between the lines, the screen: black in Original, else the dark color.
+                float br = p->originalColors ? 0 : screen[0], bg = p->originalColors ? 0 : screen[1];
+                float bb = p->originalColors ? 0 : screen[2];
+                write_pixel(row + x * 4, br + (r - br) * cover, bg + (g - bg) * cover, bb + (b - bb) * cover);
+            }
+        }
+    }
+    free(scan);
+}
+
+int dither_apply(uint8_t *rgba, size_t width, size_t height, size_t stride, const DitherParams *p) {
+    size_t count = width * height;
+    if (!count) return 1;
+    int planes = p->originalColors ? 3 : 1;
+    float *tone = malloc(count * sizeof(float) * (size_t)planes);
+    uint8_t *alpha = malloc(count);
+    // The image's own colors, unadjusted: halftone dots and glyphs take them in Original mode.
+    float *source = p->originalColors ? malloc(count * sizeof(float) * 3) : NULL;
+    if (!tone || !alpha || (p->originalColors && !source)) { free(tone); free(alpha); free(source); return 0; }
+
+    float gamma = exp2f(p->density * 1.5f);
+    float contrast = p->contrast >= 0 ? 1.0f / (1.0f - 0.95f * p->contrast) : 1.0f + p->contrast;
+    tone_job toning = { rgba, stride, width, count, alpha, tone, source, p, gamma, contrast };
+    in_bands(height, tone_band, &toning);
 
     float dark[3] = { p->dark[0] / 255.0f, p->dark[1] / 255.0f, p->dark[2] / 255.0f };
     float light[3] = { p->light[0] / 255.0f, p->light[1] / 255.0f, p->light[2] / 255.0f };
@@ -183,6 +286,18 @@ int dither_apply(uint8_t *rgba, size_t width, size_t height, size_t stride, cons
                 }
             }
         }
+    } else if (style == DITHER_SCANLINES) {
+        // A CRT: each line scans the image, its tone along the line the average of the rows it covers. The beam glows
+        // brighter and blooms thicker where the picture is light, and the screen between lines stays dark.
+        size_t spacing = (size_t)(p->cell < 2 ? 2 : p->cell);
+        float middle = (float)spacing / 2, dots = clamp01(p->dots);
+        // Each line is drawn on its own, so the lines are shared out across the cores.
+        size_t lines = (height + spacing - 1) / spacing;
+        const float *screen = dark, *phosphor = light;
+        scan_job scanning = { rgba, stride, width, height, count, planes, alpha, tone, p, spacing, middle, dots, screen, phosphor, 0 };
+        in_bands(lines, scan_band, &scanning);
+        int failed = atomic_load(&scanning.failed);
+        if (failed) { free(tone); free(alpha); free(source); return 0; }
     } else {
         // Marks (halftone shapes, patterns, glyphs) cover as much of each spot as the tone calls for. On light, they
         // stand for darkness and are drawn in the dark color; light on dark, the reverse.
@@ -277,3 +392,27 @@ void dither_dots(uint8_t *rgba, size_t width, size_t height, size_t stride, int
         }
     }
 }
+
+typedef struct { uint8_t *rgba; const uint8_t *glow; size_t width, stride; float amount; } glow_job;
+
+static void glow_band(void *context, size_t first, size_t last) {
+    const glow_job *job = context;
+    uint8_t *rgba = job->rgba; const uint8_t *glow = job->glow; size_t width = job->width, stride = job->stride;
+    float amount = job->amount;
+    for (size_t y = first; y < last; ++y) {
+        uint8_t *row = rgba + y * stride;
+        const uint8_t *light = glow + y * stride;
+        for (size_t x = 0; x < width * 4; x += 4) {
+            float a = row[x + 3];
+            for (int c = 0; c < 3; ++c) {
+                float v = (float)row[x + c] + (float)light[x + c] * amount * a / 255.0f;
+                row[x + c] = (uint8_t)lroundf(v > a ? a : v);
+            }
+        }
+    }
+}
+
+void dither_glow(uint8_t *rgba, const uint8_t *glow, size_t width, size_t height, size_t stride, float amount) {
+    glow_job glowing = { rgba, glow, width, stride, amount };
+    in_bands(height, glow_band, &glowing);
+}

kernels/DitherPixels.h

@@ -8,7 +8,7 @@ enum {
     DITHER_ATKINSON, DITHER_FLOYD_STEINBERG,
     DITHER_BAYER_2, DITHER_BAYER_4, DITHER_BAYER_8,
     DITHER_DOTS, DITHER_LINES, DITHER_DIAMONDS,
-    DITHER_PATTERNS, DITHER_GLYPHS
+    DITHER_PATTERNS, DITHER_GLYPHS, DITHER_SCANLINES
 };
 
 typedef struct {
@@ -20,7 +20,8 @@ typedef struct {
     // −1…1: darker (more ink) or lighter, and flatter or punchier, before dithering.
     float density;
     float contrast;
-    // Halftone and glyph cells, in pixels, and the halftone screen's angle in radians.
+    // Halftone and glyph cells, in pixels (scanlines: the distance between lines), and the halftone screen's angle in
+    // radians.
     int cell;
     float angle;
     // Halftone dots, patterns and glyphs mark the light tones on the dark color instead of the dark on the light.
@@ -37,6 +38,9 @@ typedef struct {
     const uint8_t *glyphs;
     const float *glyphCoverage;
     int glyphCount;
+    // Scanlines: how far each line breaks into round dots (0–1), and how many pixels its wobble pushes it sideways.
+    float dots;
+    float wobble;
 } DitherParams;
 
 // Dithers premultiplied RGBA pixels (4 bytes per pixel, `stride` bytes per row) in place. Alpha is kept and fully
@@ -45,4 +49,6 @@ int dither_apply(uint8_t *rgba, size_t width, size_t height, size_t stride, cons
 // Turns each `block` × `block` square of premultiplied RGBA pixels into a round dot in its own color on `gap` (straight
 // sRGB), like the lit pixels of a dot-matrix screen. The dot's edge is smoothed and alpha is kept.
 void dither_dots(uint8_t *rgba, size_t width, size_t height, size_t stride, int block, const uint8_t *gap);
+// Adds `glow` (premultiplied RGBA, same layout) over the pixels at `amount`, never past their own alpha.
+void dither_glow(uint8_t *rgba, const uint8_t *glow, size_t width, size_t height, size_t stride, float amount);
 #endif

src/Document/Dither.cpp

@@ -1,17 +1,28 @@
 #include "Document/Dither.h"
 #include "Document/BrushStroke.h"
+#include "Document/PixelAdjust.h"
 #include "IO/ImageExporter.h"
+#include "Rendering/PoolMap.h"
 #include <QFontMetricsF>
 #include <QPainter>
 #include <QPainterPath>
 #include <QTextBoundaryFinder>
 #include <algorithm>
 #include <cmath>
+#include <numeric>
 #include <set>
 extern "C" {
 #include "DitherPixels.h"
 }
 
+// The kernel's bands, where Swift's kernel calls dispatch_apply.
+extern "C" void dither_bands(size_t bands, void (*band)(void *context, size_t index), void *context)
+{
+    std::vector<size_t> indices(bands);
+    std::iota(indices.begin(), indices.end(), size_t(0));
+    PoolMap::blocking(indices, [band, context](size_t index) { band(context, index); });
+}
+
 // Swift's Dither.swift: the settings, the chunky pixels, the glyphs.
 namespace {
 // Swift's Characters: the text's graphemes.
@@ -53,6 +64,7 @@ QString rawValue(DitherStyle style)
     case DitherStyle::diamonds: return QStringLiteral("Halftone Diamonds");
     case DitherStyle::patterns: return QStringLiteral("Mac Patterns");
     case DitherStyle::ascii: return QStringLiteral("ASCII");
+    case DitherStyle::scanlines: return QStringLiteral("Scanlines (CRT)");
     }
     throw std::logic_error("unknown dither style");
 }
@@ -80,7 +92,12 @@ bool isHalftone(DitherStyle style)
 
 bool drawsMarks(DitherStyle style)
 {
-    return !hasTones(style);
+    return !hasTones(style) && style != DitherStyle::scanlines;
+}
+
+bool usesPixelSize(DitherStyle style)
+{
+    return style != DitherStyle::ascii && style != DitherStyle::scanlines;
 }
 
 QString rawValue(DitherPixelShape shape)
@@ -105,6 +122,10 @@ DitherSettings DitherSettings::normalized() const
     result.pixelSize = std::round(clamp(pixelSize, pixelSizeLow, pixelSizeHigh, 2));
     result.cellSize = std::round(clamp(cellSize, cellSizeLow, cellSizeHigh, 8));
     result.textSize = std::round(clamp(textSize, textSizeLow, textSizeHigh, 14));
+    result.lineSpacing = std::round(clamp(lineSpacing, lineSpacingLow, lineSpacingHigh, 4));
+    result.glow = clamp(glow, 0, 100, 35);
+    result.dots = clamp(dots, 0, 100, 0);
+    result.wobble = clamp(wobble, wobbleLow, wobbleHigh, 0);
     result.angle = clamp(angle, -90, 90, 45);
     result.levels = std::round(clamp(levels, levelsLow, levelsHigh, 2));
     result.diffusion = clamp(diffusion, 0, 100, 100);
@@ -125,8 +146,8 @@ DitherSettings DitherSettings::normalized() const
 QImage DitherSettings::apply(const QImage &image) const
 {
     const DitherSettings settings = normalized();
-    // ASCII draws at full resolution: chunks would blur its letters.
-    const int block = settings.style == DitherStyle::ascii ? 1 : int(settings.pixelSize);
+    // ASCII and Scanlines draw full size: chunks would blur them.
+    const int block = usesPixelSize(settings.style) ? int(settings.pixelSize) : 1;
     const QImage source = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
     if (source.isNull())
         throw ExportError(ExportError::Kind::render);
@@ -153,6 +174,8 @@ QImage DitherSettings::apply(const QImage &image) const
         }
     }
     const QImage dithered = settings.dither(working);
+    if (settings.style == DitherStyle::scanlines && settings.glow > 0)
+        return settings.glowing(dithered);
     if (block <= 1)
         return dithered;
     // Blown back up without smoothing.
@@ -171,9 +194,42 @@ QImage DitherSettings::apply(const QImage &image) const
     return full;
 }
 
+// The lines' light blurred wide and added back: phosphor bloom.
+QImage DitherSettings::glowing(const QImage &image) const
+{
+    // Blurred small, scaled back up: same light, less work.
+    const double sigma = lineSpacing * 3 + 3, shrink = std::max(1.0, std::floor(sigma / 4));
+    const int width = image.width(), height = image.height();
+    // Swift clamps first: edges repeat outward before shrinking.
+    const int step = int(shrink), pad = int(std::ceil(sigma * 3 / shrink)) * step;
+    QImage padded = BrushRaster::context(width + 2 * pad, height + 2 * pad, false);
+    for (int y = 0; y < padded.height(); ++y) {
+        const uchar *source = image.constScanLine(std::clamp(y - pad, 0, height - 1));
+        uchar *out = padded.scanLine(y);
+        for (int x = 0; x < padded.width(); ++x)
+            std::copy_n(source + std::clamp(x - pad, 0, width - 1) * 4, 4, out + x * 4);
+    }
+    const int smallWidth = (padded.width() + step - 1) / step, smallHeight = (padded.height() + step - 1) / step;
+    const QImage small = padded.scaled(smallWidth, smallHeight, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+    if (small.isNull())
+        throw ExportError(ExportError::Kind::render);
+    const QImage blurred = PixelAdjust::gaussianBlur(small, sigma / shrink, true)
+                               .scaled(smallWidth * step, smallHeight * step, Qt::IgnoreAspectRatio, Qt::SmoothTransformation)
+                               .convertToFormat(QImage::Format_RGBA8888_Premultiplied);
+    QImage result = image.copy();
+    if (blurred.isNull() || result.isNull())
+        throw ExportError(ExportError::Kind::render);
+    // The scaled light's own rows, cropped to the image.
+    QImage bloom = BrushRaster::context(width, height, false);
+    for (int y = 0; y < height; ++y)
+        std::copy_n(blurred.constScanLine(y + pad) + pad * 4, width * 4, bloom.scanLine(y));
+    dither_glow(result.bits(), bloom.constBits(), size_t(width), size_t(height), size_t(result.bytesPerLine()), float(glow / 100 * 2.5));
+    return result;
+}
+
 QImage DitherSettings::dither(const QImage &image) const
 {
-    const int cell = int(cellSize);
+    const int cell = int(style == DitherStyle::scanlines ? lineSpacing : cellSize);
     const Glyphs glyphs = style == DitherStyle::ascii ? DitherSettings::glyphs(characters.isEmpty() ? defaultCharacters() : characters, int(textSize)) : Glyphs();
     const bool two = colors == DitherColors::twoColors;
     const std::array<uint8_t, 3> darkColor = two ? bytes(dark) : std::array<uint8_t, 3>{0, 0, 0};
@@ -184,7 +240,8 @@ QImage DitherSettings::dither(const QImage &image) const
                             .contrast = float(contrast / 100), .cell = cell, .angle = float(angle * M_PI / 180), .lightOnDark = lightOnDark ? 1 : 0,
                             .originalColors = colors == DitherColors::original ? 1 : 0, .dark = {darkColor[0], darkColor[1], darkColor[2]},
                             .light = {lightColor[0], lightColor[1], lightColor[2]}, .glyphWidth = glyphs.width, .glyphHeight = glyphs.height, .glyphs = glyphs.maps.data(),
-                            .glyphCoverage = glyphs.coverage.data(), .glyphCount = int(glyphs.coverage.size())};
+                            .glyphCoverage = glyphs.coverage.data(), .glyphCount = int(glyphs.coverage.size()), .dots = float(dots / 100),
+                            .wobble = float(wobble)};
         failed = dither_apply(pixels, size_t(width), size_t(height), size_t(stride), &params) == 0;
     });
     if (failed)

src/Document/Dither.h

@@ -6,10 +6,10 @@
 #include <vector>
 
 // Filter › Dither's looks, in the panel's order and DitherPixels.h's.
-enum class DitherStyle { atkinson, floydSteinberg, bayer2, bayer4, bayer8, dots, lines, diamonds, patterns, ascii };
-inline constexpr std::array allDitherStyles{DitherStyle::atkinson, DitherStyle::floydSteinberg, DitherStyle::bayer2, DitherStyle::bayer4,
-                                            DitherStyle::bayer8,   DitherStyle::dots,           DitherStyle::lines,  DitherStyle::diamonds,
-                                            DitherStyle::patterns, DitherStyle::ascii};
+enum class DitherStyle { atkinson, floydSteinberg, bayer2, bayer4, bayer8, dots, lines, diamonds, patterns, ascii, scanlines };
+inline constexpr std::array allDitherStyles{DitherStyle::atkinson, DitherStyle::floydSteinberg, DitherStyle::bayer2,   DitherStyle::bayer4,
+                                            DitherStyle::bayer8,   DitherStyle::dots,           DitherStyle::lines,    DitherStyle::diamonds,
+                                            DitherStyle::patterns, DitherStyle::ascii,          DitherStyle::scanlines};
 QString rawValue(DitherStyle style);
 // Swift's groups: diffusion, ordered, halftone, marks.
 int ditherGroup(DitherStyle style);
@@ -19,6 +19,8 @@ bool diffuses(DitherStyle style);
 bool hasTones(DitherStyle style);
 bool isHalftone(DitherStyle style);
 bool drawsMarks(DitherStyle style);
+// ASCII and Scanlines draw at full resolution, not chunky.
+bool usesPixelSize(DitherStyle style);
 
 // A chunky pixel: a square, or a dot on dark.
 enum class DitherPixelShape { square, dot };
@@ -35,6 +37,8 @@ struct DitherSettings {
     static constexpr double cellSizeLow = 4, cellSizeHigh = 64;
     static constexpr double textSizeLow = 6, textSizeHigh = 64;
     static constexpr double levelsLow = 2, levelsHigh = 8;
+    static constexpr double lineSpacingLow = 2, lineSpacingHigh = 32;
+    static constexpr double wobbleLow = 0, wobbleHigh = 64;
     static QString defaultCharacters() { return QStringLiteral(" .:-=+*#%@"); }
     DitherStyle style = DitherStyle::atkinson;
     // Each dithered pixel covers this many layer pixels a side.
@@ -44,6 +48,12 @@ struct DitherSettings {
     double cellSize = 8;
     // ASCII's line height in layer pixels; letters about 0.6 wide.
     double textSize = 14;
+    // Scanlines: the lines' distance apart, in layer pixels.
+    double lineSpacing = 4;
+    // Glow and dots 0–100%; wobble sideways in pixels.
+    double glow = 35;
+    double dots = 0;
+    double wobble = 0;
     // The halftone screen's angle, in degrees.
     double angle = 45;
     // Tones per channel; 2 is 1-bit.
@@ -76,4 +86,5 @@ struct DitherSettings {
 
 private:
     QImage dither(const QImage &image) const;
+    QImage glowing(const QImage &image) const;
 };

src/Document/ProjectWorkspace.cpp

@@ -220,14 +220,40 @@ bool ProjectWorkspace::finishTextEditing()
     return true;
 }
 
+void ProjectWorkspace::settlePendingEdits(std::function<void()> done)
+{
+    // Canvas edits are applied; dialogs cancelled, as their Cancel.
+    const std::shared_ptr<ProjectTab> settled = tab(current().id);
+    settled->session.commitGradient([self = QPointer<ProjectWorkspace>(this), settled, done] {
+        settled->session.finishPixelMove([self, settled, done] {
+            EditorSession &session = settled->session;
+            session.cancelFilter();
+            session.cancelHueSaturation();
+            session.cancelLevels();
+            session.cancelColorRange();
+            session.setSelectionAmountOperation(std::nullopt);
+            session.closeColorPicker(false);
+            if (self)
+                done();
+        });
+    });
+}
+
 void ProjectWorkspace::confirmQuit(std::function<void(bool)> done)
 {
-    if (!finishTextEditing() || !canSwitch()) {
+    if (m_isManaging || !finishTextEditing()) {
         finish(done, false);
         return;
     }
-    setManaging(true);
-    askNext(quitOrder(), 0, std::move(done));
+    settlePendingEdits([this, done] {
+        if (!canSwitch()) {
+            qCWarning(lcApp) << "Quit refused: the project is still busy";
+            finish(done, false);
+            return;
+        }
+        setManaging(true);
+        askNext(quitOrder(), 0, done);
+    });
 }
 
 void ProjectWorkspace::askNext(std::vector<std::shared_ptr<ProjectTab>> order, size_t index, std::function<void(bool)> done)

src/Document/ProjectWorkspace.h

@@ -42,6 +42,8 @@ public:
     void close(QUuid id, std::function<void()> done = {});
     void removeTab(QUuid id);
     std::vector<std::shared_ptr<ProjectTab>> quitOrder() const;
+    // Applies canvas edits and cancels dialogs before a quit.
+    void settlePendingEdits(std::function<void()> done);
     void confirmQuit(std::function<void(bool)> done);
     void closeWindow(QWidget *closing);
     void receive(const QList<QUrl> &urls, std::optional<QUuid> destination = std::nullopt,

src/UI/FilterSheet+Dither.cpp

@@ -48,10 +48,25 @@ void FilterSheet::dither()
     });
     control(QStringLiteral("Pixel Size"), key(&DitherSettings::pixelSize), DitherSettings::pixelSizeLow, DitherSettings::pixelSizeHigh, QStringLiteral("px"), 0, false);
     box()->setToolTip(QStringLiteral("Make each dithered pixel this many pixels across, for a chunky old-screen look"));
-    m_shownWhen.emplace_back(box(), [](const FilterSettings &settings) { return settings.dither.style != DitherStyle::ascii; });
+    m_shownWhen.emplace_back(box(), [](const FilterSettings &settings) { return usesPixelSize(settings.dither.style); });
     control(QStringLiteral("Text Size"), key(&DitherSettings::textSize), DitherSettings::textSizeLow, DitherSettings::textSizeHigh, QStringLiteral("px"), 0, false);
     box()->setToolTip(QStringLiteral("The height of each line of characters"));
     m_shownWhen.emplace_back(box(), [](const FilterSettings &settings) { return settings.dither.style == DitherStyle::ascii; });
+    // Scanlines' four rows.
+    const auto scanlines = [](const FilterSettings &settings) { return settings.dither.style == DitherStyle::scanlines; };
+    control(QStringLiteral("Line Spacing"), key(&DitherSettings::lineSpacing), DitherSettings::lineSpacingLow, DitherSettings::lineSpacingHigh, QStringLiteral("px"), 0,
+            false);
+    box()->setToolTip(QStringLiteral("How far apart the screen's lines are"));
+    m_shownWhen.emplace_back(box(), scanlines);
+    control(QStringLiteral("Glow"), key(&DitherSettings::glow), 0, 100, QStringLiteral("%"), 0, false);
+    box()->setToolTip(QStringLiteral("Light blooming around the lines, like a CRT's phosphors"));
+    m_shownWhen.emplace_back(box(), scanlines);
+    control(QStringLiteral("Dots"), key(&DitherSettings::dots), 0, 100, QStringLiteral("%"), 0, false);
+    box()->setToolTip(QStringLiteral("Break the lines into glowing beads"));
+    m_shownWhen.emplace_back(box(), scanlines);
+    control(QStringLiteral("Wobble"), key(&DitherSettings::wobble), DitherSettings::wobbleLow, DitherSettings::wobbleHigh, QStringLiteral("px"), 0, false);
+    box()->setToolTip(QStringLiteral("Make the lines waver sideways down the screen, like a CRT losing sync"));
+    m_shownWhen.emplace_back(box(), scanlines);
     control(QStringLiteral("Cell Size"), key(&DitherSettings::cellSize), DitherSettings::cellSizeLow, DitherSettings::cellSizeHigh, QStringLiteral("px"), 0, false);
     m_shownWhen.emplace_back(box(), [](const FilterSettings &settings) { return isHalftone(settings.dither.style); });
     control(QStringLiteral("Angle"), key(&DitherSettings::angle), -90, 90, QStringLiteral("°"), 0, false);
@@ -133,7 +148,7 @@ void FilterSheet::dither()
         const QSignalBlocker quiet(shape);
         shape->setCurrentIndex(int(settings.dither.pixelShape));
     });
-    m_shownWhen.emplace_back(shape->parentWidget(), [](const FilterSettings &settings) { return settings.dither.pixelSize > 1 && settings.dither.style != DitherStyle::ascii; });
+    m_shownWhen.emplace_back(shape->parentWidget(), [](const FilterSettings &settings) { return settings.dither.pixelSize > 1 && usesPixelSize(settings.dither.style); });
     flag(QStringLiteral("Light on Dark"), QStringLiteral("Draw the marks for the light tones on the dark color, like a glowing screen"),
          [](FilterSettings &settings) -> bool & { return settings.dither.lightOnDark; });
     m_shownWhen.emplace_back(m_flags.back().first, [](const FilterSettings &settings) { return drawsMarks(settings.dither.style); });

tests/DitherSheetTests.cpp

@@ -179,13 +179,13 @@ void DitherSheetTests::theControlsFollowTheStyle()
         dither.colors = DitherColors::twoColors;
     });
     QCOMPARE(shown.shown(), sorted(QStringList{"Style", "Pixel Size", "Density", "Contrast", "Colors", "Light on Dark", "Swatches"}));
-    // Style's menu: ten looks in four groups.
+    // Style's menu: eleven looks in four groups.
     QComboBox &style = shown.child<QComboBox>("ditherStyle");
     QStringList items;
     for (int index = 0; index < style.count(); ++index)
         items << (style.itemText(index).isEmpty() ? QStringLiteral("—") : style.itemText(index));
     QCOMPARE(items, (QStringList{"Atkinson (Classic Mac)", "Floyd–Steinberg", "—", "Bayer 2 × 2", "Bayer 4 × 4", "Bayer 8 × 8", "—", "Halftone Dots",
-                                 "Halftone Lines", "Halftone Diamonds", "—", "Mac Patterns", "ASCII"}));
+                                 "Halftone Lines", "Halftone Diamonds", "—", "Mac Patterns", "ASCII", "Scanlines (CRT)"}));
     QCOMPARE(style.currentText(), QString("Mac Patterns"));
     // Its quick preview never shows the busy line.
     QVERIFY(!shown.child<QProgressBar>("filterSpinner").isVisibleTo(shown.sheet.get()));

tests/DitherTests.cpp

@@ -67,11 +67,11 @@ void DitherTests::stylesKeepSwiftsNamesOrderAndGroups()
     for (const DitherStyle each : allDitherStyles)
         names << rawValue(each);
     QCOMPARE(names, (QStringList{"Atkinson (Classic Mac)", "Floyd–Steinberg", "Bayer 2 × 2", "Bayer 4 × 4", "Bayer 8 × 8", "Halftone Dots",
-                                 "Halftone Lines", "Halftone Diamonds", "Mac Patterns", "ASCII"}));
+                                 "Halftone Lines", "Halftone Diamonds", "Mac Patterns", "ASCII", "Scanlines (CRT)"}));
     QString groups;
     for (const DitherStyle each : allDitherStyles)
         groups += QString::number(ditherGroup(each));
-    QCOMPARE(groups, QString("0011122233"));
+    QCOMPARE(groups, QString("00111222333"));
     QVERIFY(diffuses(DitherStyle::floydSteinberg) && !diffuses(DitherStyle::bayer2));
     QVERIFY(hasTones(DitherStyle::bayer8) && !hasTones(DitherStyle::dots));
     QVERIFY(isHalftone(DitherStyle::diamonds) && !isHalftone(DitherStyle::patterns));

tests/QuitPendingEditsTests.cpp

@@ -0,0 +1,246 @@
+#include "DialogDesk.h"
+#include "Document/ProjectWorkspace.h"
+#include "SelectionFixtures.h"
+#include "UI/ProjectWorkspaceView.h"
+#include <QtTest>
+
+// Swift 1.4.4: quit applies canvas edits and cancels dialogs.
+namespace {
+ImportedImage filled(const QColor &colour)
+{
+    QImage pixels(100, 20, QImage::Format_RGBA8888_Premultiplied);
+    pixels.fill(colour);
+    return ImportedImage(pixels, pixels, QStringLiteral("Fixture"));
+}
+
+// Swift's await: true once the call's callback has run.
+bool awaited(const std::function<void(std::function<void()>)> &call)
+{
+    bool done = false;
+    call([&done] { done = true; });
+    return QTest::qWaitFor([&done] { return done; }, 10'000);
+}
+
+std::optional<bool> answer(ProjectWorkspace &workspace)
+{
+    std::optional<bool> result;
+    workspace.confirmQuit([&](bool value) { result = value; });
+    return QTest::qWaitFor([&] { return result.has_value(); }, 10'000) ? result : std::nullopt;
+}
+
+// Swift's test: a gradient waiting for Apply.
+void pendGradient(EditorSession &session)
+{
+    session.createDocument(100, 20);
+    session.addBlankLayer();
+    session.selectTool(NavigationTool::gradient);
+    session.beginGradient(QPointF(0, 10));
+    session.moveGradient(std::nullopt, QPointF(100, 10));
+    session.endGradientDrag();
+}
+
+ImageIdentity identity(const EditorSession &session)
+{
+    return session.activeLayer().value().asset.value().identity();
+}
+}
+
+class QuitPendingEditsTests : public QObject {
+    Q_OBJECT
+private slots:
+    void quittingAppliesAPendingGradient();
+    void quittingAppliesAPixelMove();
+    void quittingCancelsAnOpenDialog();
+    void quittingCancelsTheOtherDialogs();
+    void quittingCancelsAnAdjustmentsEditor();
+    void aWorkspaceGoneMidSettleCallsNothing();
+    void closingTheWindowAppliesTheGradientThenAsks();
+    void aBusyProjectHoldsTheQuit();
+    void aQuitWhileManagingIsRefusedAtOnce();
+};
+
+void QuitPendingEditsTests::quittingAppliesAPendingGradient()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    pendGradient(session);
+    QVERIFY(!workspace.canSwitch());
+    const int count = session.history.undoCount();
+    QVERIFY(awaited([&](std::function<void()> done) { workspace.settlePendingEdits(std::move(done)); }));
+    QVERIFY(!session.gradientEdit());
+    QCOMPARE(session.history.undoCount(), count + 1);
+    QCOMPARE(session.history.undoName(), QString("Gradient"));
+    QVERIFY(workspace.canSwitch());
+}
+
+void QuitPendingEditsTests::quittingAppliesAPixelMove()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    session.createDocument(100, 20);
+    session.insert(filled(QColor(200, 100, 50)));
+    session.applySelection(rectPath(QRectF(10, 5, 10, 10)), SelectionMode::replace, "Select");
+    QVERIFY(session.beginPixelMove());
+    session.movePixels(QSizeF(30, 0));
+    QVERIFY(!workspace.canSwitch());
+    const int count = session.history.undoCount();
+    QVERIFY(awaited([&](std::function<void()> done) { workspace.settlePendingEdits(std::move(done)); }));
+    QVERIFY(!session.pixelMove());
+    QCOMPARE(session.history.undoCount(), count + 1);
+    QCOMPARE(session.history.undoName(), QString("Move Pixels"));
+    QCOMPARE(session.selection().value().path.boundingRect(), QRectF(40, 5, 10, 10));
+    QVERIFY(workspace.canSwitch());
+}
+
+void QuitPendingEditsTests::quittingCancelsAnOpenDialog()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    session.createDocument(100, 20);
+    session.insert(filled(QColor(200, 100, 50)));
+    const ImageIdentity original = identity(session);
+    const int count = session.history.undoCount();
+    const std::vector<std::function<void()>> opens{[&] { session.beginFilter(FilterKind::gaussianBlur); },
+                                                   [&] { session.beginHueSaturation(); }, [&] { session.beginLevels(); }};
+    for (const std::function<void()> &open : opens) {
+        open();
+        QVERIFY(!workspace.canSwitch());
+        QVERIFY(awaited([&](std::function<void()> done) { workspace.settlePendingEdits(std::move(done)); }));
+        QVERIFY(workspace.canSwitch());
+        QVERIFY(identity(session) == original);
+    }
+    QVERIFY(!session.filterEdit() && !session.hueSaturation() && !session.levels());
+    QCOMPARE(session.history.undoCount(), count);
+}
+
+void QuitPendingEditsTests::quittingCancelsTheOtherDialogs()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    session.createDocument(100, 20);
+    session.insert(filled(QColor(200, 100, 50)));
+    const QPainterPath before = rectPath(QRectF(10, 5, 10, 10));
+    session.applySelection(before, SelectionMode::replace, "Select");
+    const PaletteColor foreground = session.foregroundColor();
+    const auto settle = [&] { return awaited([&](std::function<void()> done) { workspace.settlePendingEdits(std::move(done)); }); };
+    // Color Range: the selection goes back as it was.
+    session.beginColorRange();
+    QVERIFY(session.colorRange() && !workspace.canSwitch());
+    QVERIFY(settle());
+    QVERIFY(!session.colorRange());
+    QCOMPARE(session.selection().value().path.boundingRect(), before.boundingRect());
+    // Expand, Contract or Feather: its panel goes.
+    session.setSelectionAmountOperation(SelectionAmountOperation::feather);
+    QVERIFY(!workspace.canSwitch());
+    QVERIFY(settle());
+    QVERIFY(!session.selectionAmountOperation());
+    // The colour picker: closed, its colour not taken.
+    session.openColorPicker(false);
+    session.setColorPickerHSB(PickerHSB(120, 1, 1));
+    QVERIFY(!workspace.canSwitch());
+    QVERIFY(settle());
+    QVERIFY(!session.colorPicker());
+    QVERIFY(session.foregroundColor() == foreground);
+    QVERIFY(workspace.canSwitch());
+}
+
+void QuitPendingEditsTests::quittingCancelsAnAdjustmentsEditor()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    session.createDocument(100, 20);
+    session.insert(filled(Qt::white));
+    session.addAdjustment(AdjustmentKind::exposure);
+    const QUuid id = session.adjustmentEditingID().value();
+    const LayerAdjustment made = session.activeLayer().value().adjustment.value();
+    QVERIFY(awaited([&](std::function<void()> done) { session.beginAdjustmentEditing(id, std::move(done)); }));
+    FilterSettings settings = session.filterEdit().value().settings;
+    settings.exposure.exposure = 2;
+    session.updateFilter(settings, true);
+    QVERIFY(!(session.activeLayer().value().adjustment.value() == made));
+    QVERIFY(!workspace.canSwitch());
+    QVERIFY(awaited([&](std::function<void()> done) { workspace.settlePendingEdits(std::move(done)); }));
+    QVERIFY(!session.adjustmentEditingID() && !session.adjustmentOriginal() && !session.filterEdit());
+    QVERIFY(session.activeLayer().value().adjustment.value() == made);
+    QVERIFY(workspace.canSwitch());
+}
+
+void QuitPendingEditsTests::aWorkspaceGoneMidSettleCallsNothing()
+{
+    auto workspace = std::make_unique<ProjectWorkspace>();
+    const std::shared_ptr<ProjectTab> tab = workspace->tabs().front();
+    pendGradient(tab->session);
+    bool called = false;
+    workspace->settlePendingEdits([&called] { called = true; });
+    workspace.reset();
+    // The tab lives on and its gradient lands; no answer.
+    QTRY_VERIFY(!tab->session.gradientEdit());
+    QTest::qWait(100);
+    QVERIFY(!called);
+    QCOMPARE(tab->session.history.undoName(), QString("Gradient"));
+}
+
+void QuitPendingEditsTests::closingTheWindowAppliesTheGradientThenAsks()
+{
+    ProjectWorkspace workspace;
+    ProjectWorkspaceView view(workspace);
+    view.show();
+    EditorSession &session = workspace.current().session;
+    pendGradient(session);
+    session.history.markSaved();
+    DialogDesk desk;
+    desk.replies = {"Cancel"};
+    // The gradient is a step by the time it asks.
+    desk.note = [&] { return QStringLiteral("pending=%1 step=%2").arg(session.gradientEdit().has_value()).arg(session.history.undoName()); };
+    view.close();
+    QTRY_COMPARE(desk.seen.size(), 1);
+    QVERIFY2(desk.seen[0].startsWith("alert|2|Save changes to Untitled?") && desk.seen[0].endsWith("|pending=0 step=Gradient"),
+             qPrintable(desk.seen[0]));
+    QTRY_VERIFY(!workspace.isManaging());
+    QVERIFY(view.isVisible());
+}
+
+void QuitPendingEditsTests::aBusyProjectHoldsTheQuit()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    pendGradient(session);
+    session.setIsProjectBusy(true);
+    DialogDesk desk;
+    QTest::ignoreMessage(QtWarningMsg, "Quit refused: the project is still busy");
+    QCOMPARE(answer(workspace), std::optional(false));
+    // Nothing asked, nothing applied: the gradient waits.
+    QVERIFY(desk.seen.isEmpty());
+    QVERIFY(session.gradientEdit());
+    QVERIFY(!workspace.isManaging());
+    session.setIsProjectBusy(false);
+}
+
+void QuitPendingEditsTests::aQuitWhileManagingIsRefusedAtOnce()
+{
+    ProjectWorkspace workspace;
+    EditorSession &session = workspace.current().session;
+    session.createDocument(100, 20);
+    DialogDesk desk;
+    desk.replies = {"Cancel"};
+    std::optional<bool> second;
+    bool settled = false;
+    bool answered = false;
+    // While the first quit asks, a second is refused unasked.
+    desk.note = [&] {
+        session.setSelectionAmountOperation(SelectionAmountOperation::feather);
+        workspace.confirmQuit([&](bool value) { second = value; });
+        answered = QTest::qWaitFor([&] { return second.has_value(); }, 5000);
+        settled = !session.selectionAmountOperation();
+        session.setSelectionAmountOperation(std::nullopt);
+        return QString();
+    };
+    QCOMPARE(answer(workspace), std::optional(false));
+    QCOMPARE(desk.seen.size(), 1);
+    QVERIFY(answered);
+    QCOMPARE(second, std::optional(false));
+    QVERIFY(!settled);
+}
+
+QTEST_MAIN(QuitPendingEditsTests)
+#include "QuitPendingEditsTests.moc"

tests/ScanlinesTests.cpp

@@ -0,0 +1,377 @@
+#include "Document/BrushStroke.h"
+#include "Document/Dither.h"
+#include "Document/EditorSession.h"
+#include "Document/PixelAdjust.h"
+#include "UI/FilterSheet.h"
+#include <QCheckBox>
+#include <QLabel>
+#include <QLayout>
+#include <QLineEdit>
+#include <QPainter>
+#include <QSlider>
+#include <QtTest>
+#include <numeric>
+
+// Swift 1.4.4's Dither › Scanlines (CRT), on every core.
+namespace {
+QImage filled(int width, int height, QColor colour)
+{
+    QImage image = BrushRaster::context(width, height, false);
+    image.fill(colour);
+    return image;
+}
+
+DitherSettings scanlines(double spacing, double glow = 0)
+{
+    DitherSettings settings;
+    settings.style = DitherStyle::scanlines;
+    settings.lineSpacing = spacing;
+    settings.glow = glow;
+    return settings;
+}
+
+// One channel of one column, top to bottom.
+std::vector<int> column(const QImage &image, int x, int channel = 0)
+{
+    std::vector<int> values;
+    for (int y = 0; y < image.height(); ++y)
+        values.push_back(image.constScanLine(y)[x * 4 + channel]);
+    return values;
+}
+
+std::vector<int> row(const QImage &image, int y, int channel = 0)
+{
+    std::vector<int> values;
+    for (int x = 0; x < image.width(); ++x)
+        values.push_back(image.constScanLine(y)[x * 4 + channel]);
+    return values;
+}
+
+// Swift's test: one column of a flat gray's render.
+std::vector<int> gray(int level, double spacing, double glow = 0)
+{
+    return column(scanlines(spacing, glow).apply(filled(16, 32, QColor(level, level, level))), 5);
+}
+
+std::vector<int> repeated(const std::vector<int> &band, int times)
+{
+    std::vector<int> all;
+    for (int each = 0; each < times; ++each)
+        all.insert(all.end(), band.begin(), band.end());
+    return all;
+}
+
+struct Shown {
+    EditorSession session;
+    std::unique_ptr<FilterSheet> sheet;
+    Shown()
+    {
+        session.createDocument(40, 30);
+        const QImage image = filled(40, 30, QColor(200, 120, 40));
+        session.insert(ImportedImage(image, image, QStringLiteral("Colour")));
+        session.beginFilter(FilterKind::dither);
+        FilterSettings settings = session.filterEdit().value().settings;
+        settings.dither.style = DitherStyle::scanlines;
+        session.updateFilter(settings, true);
+        sheet = std::make_unique<FilterSheet>(session);
+        sheet->show();
+    }
+    const DitherSettings &dither() const { return session.filterEdit().value().settings.dither; }
+    // The shown rows in the column's order, with their help.
+    QStringList rows() const
+    {
+        QStringList titles;
+        QLayout *column = sheet->layout();
+        for (int index = 0; index < column->count(); ++index) {
+            QWidget *each = column->itemAt(index)->widget();
+            if (!each || each->isHidden())
+                continue;
+            if (auto *box = qobject_cast<QCheckBox *>(each); box && box->text() != QLatin1String("Preview"))
+                titles << box->text();
+            for (QLabel *label : each->findChildren<QLabel *>(QString(), Qt::FindDirectChildrenOnly)) {
+                if (label->buddy())
+                    titles << label->text() + u'|' + each->toolTip();
+            }
+        }
+        return titles;
+    }
+};
+}
+
+class ScanlinesTests : public QObject {
+    Q_OBJECT
+private slots:
+    void scanlinesAreLinesOfLightThatBloomWithBrightness();
+    void glowLightsBetweenTheLines();
+    void dotsBreakTheLinesIntoBeads();
+    void wobbleMovesLinesSideways();
+    void theStyleDrawsAtFullResolutionWithoutMarks();
+    void normalizingClampsTheFourSettings();
+    void eachLineIsTheAverageOfItsRows();
+    void theScreenIsTheDarkColourOrBlack();
+    void clearPixelsStayClear();
+    void everyBandOfATallImageIsDrawn();
+    void theGlowIsTheBlurredLightAtItsAmount();
+    void theGlowNeverPassesAlpha();
+    void theSheetShowsScanlinesRows();
+    void theRowsWriteTheirSettings();
+};
+
+void ScanlinesTests::scanlinesAreLinesOfLightThatBloomWithBrightness()
+{
+    const std::vector<int> white = gray(255, 8), dim = gray(89, 8), black = gray(0, 8);
+    for (int band = 0; band < 4; ++band) {
+        const std::vector<int> rows(white.begin() + band * 8, white.begin() + band * 8 + 8);
+        QVERIFY(rows[3] == 255 && rows[4] == 255);
+        QVERIFY(std::any_of(rows.begin(), rows.end(), [](int value) { return value < 40; }));
+    }
+    QVERIFY(std::accumulate(dim.begin(), dim.end(), 0) * 2 < std::accumulate(white.begin(), white.end(), 0));
+    QVERIFY(std::all_of(black.begin(), black.end(), [](int value) { return value == 0; }));
+    // The beam's half height, 2.8 white, about 1.98 at 0.35.
+    QCOMPARE(white, repeated({0, 255, 255, 255, 255, 255, 255, 0}, 4));
+    QCOMPARE(dim, repeated({0, 0, 118, 120, 120, 118, 0, 0}, 4));
+}
+
+void ScanlinesTests::glowLightsBetweenTheLines()
+{
+    const std::vector<int> plain = gray(255, 8), glowing = gray(255, 8, 100);
+    QVERIFY2(glowing[0] > plain[0] + 40, qPrintable(QString::number(glowing[0])));
+}
+
+void ScanlinesTests::dotsBreakTheLinesIntoBeads()
+{
+    const QImage white = filled(64, 16, Qt::white);
+    DitherSettings settings = scanlines(8);
+    QCOMPARE(row(settings.apply(white), 4), std::vector<int>(64, 255));
+    settings.dots = 100;
+    // Each bead lit at its middle, dark at its ends.
+    const std::vector<int> lit = row(settings.apply(white), 4);
+    QCOMPARE(std::vector<int>(lit.begin(), lit.begin() + 8), (std::vector<int>{0, 255, 255, 255, 255, 255, 255, 0}));
+    QCOMPARE(std::vector<int>(lit.begin() + 8, lit.begin() + 16), (std::vector<int>{0, 255, 255, 255, 255, 255, 255, 0}));
+    // Half dots: the bead ends dim off the middle.
+    settings.dots = 50;
+    QCOMPARE(row(settings.apply(white), 1)[0], 85);
+}
+
+void ScanlinesTests::wobbleMovesLinesSideways()
+{
+    QImage edge = filled(64, 64, Qt::black);
+    QPainter(&edge).fillRect(QRect(32, 0, 32, 64), Qt::white);
+    const auto edges = [&edge](double wobble) {
+        DitherSettings settings = scanlines(8);
+        settings.wobble = wobble;
+        const QImage result = settings.apply(edge);
+        std::vector<int> found;
+        for (int line = 0; line < 8; ++line) {
+            const std::vector<int> middle = row(result, line * 8 + 4);
+            found.push_back(int(std::find_if(middle.begin(), middle.end(), [](int value) { return value > 128; }) - middle.begin()));
+        }
+        return found;
+    };
+    QCOMPARE(edges(0), std::vector<int>(8, 32));
+    // Each line's shift: 12 times the two waves, rounded.
+    QCOMPARE(edges(12), (std::vector<int>{35, 36, 35, 41, 44, 37, 32, 34}));
+}
+
+void ScanlinesTests::theStyleDrawsAtFullResolutionWithoutMarks()
+{
+    QVERIFY(!usesPixelSize(DitherStyle::scanlines) && !usesPixelSize(DitherStyle::ascii) && usesPixelSize(DitherStyle::patterns));
+    QVERIFY(!drawsMarks(DitherStyle::scanlines) && drawsMarks(DitherStyle::ascii));
+    QVERIFY(!hasTones(DitherStyle::scanlines) && !isHalftone(DitherStyle::scanlines) && ditherGroup(DitherStyle::scanlines) == 3);
+    // A pixel size changes nothing: no chunks, no dots.
+    const QImage image = filled(20, 24, QColor(180, 90, 30));
+    DitherSettings settings = scanlines(4);
+    const QImage plain = settings.apply(image);
+    settings.pixelSize = 5;
+    settings.pixelShape = DitherPixelShape::dot;
+    QCOMPARE(settings.apply(image), plain);
+    // The cell is the line spacing, not the cell size.
+    settings.cellSize = 32;
+    QCOMPARE(settings.apply(image), plain);
+}
+
+void ScanlinesTests::normalizingClampsTheFourSettings()
+{
+    DitherSettings settings;
+    QCOMPARE(settings.lineSpacing, 4.0);
+    QCOMPARE(settings.glow, 35.0);
+    QCOMPARE(settings.dots, 0.0);
+    QCOMPARE(settings.wobble, 0.0);
+    settings.lineSpacing = 1.4;
+    settings.glow = 150;
+    settings.dots = -5;
+    settings.wobble = 3.5;
+    DitherSettings result = settings.normalized();
+    QCOMPARE(result.lineSpacing, 2.0);
+    QCOMPARE(result.glow, 100.0);
+    QCOMPARE(result.dots, 0.0);
+    QCOMPARE(result.wobble, 3.5);
+    settings.lineSpacing = 40;
+    settings.glow = -1;
+    settings.dots = 120;
+    settings.wobble = 70;
+    result = settings.normalized();
+    QCOMPARE(result.lineSpacing, 32.0);
+    QCOMPARE(result.glow, 0.0);
+    QCOMPARE(result.dots, 100.0);
+    QCOMPARE(result.wobble, 64.0);
+    // Rounded within; not a number takes the default.
+    settings.lineSpacing = 5.5;
+    settings.glow = std::nan("");
+    settings.dots = std::nan("");
+    settings.wobble = std::nan("");
+    result = settings.normalized();
+    QCOMPARE(result.lineSpacing, 6.0);
+    QCOMPARE(result.glow, 35.0);
+    QCOMPARE(result.dots, 0.0);
+    QCOMPARE(result.wobble, 0.0);
+    settings.lineSpacing = std::nan("");
+    QCOMPARE(settings.normalized().lineSpacing, 4.0);
+    // Glow and dots keep their fractions.
+    settings.glow = 12.5;
+    settings.dots = 33.3;
+    QCOMPARE(settings.normalized().glow, 12.5);
+    QCOMPARE(settings.normalized().dots, 33.3);
+}
+
+void ScanlinesTests::eachLineIsTheAverageOfItsRows()
+{
+    // Rows of white and black: each line lights at half.
+    QImage stripes = filled(8, 16, Qt::black);
+    for (int y = 0; y < 16; y += 2)
+        QPainter(&stripes).fillRect(QRect(0, y, 8, 1), Qt::white);
+    QCOMPARE(column(scanlines(8).apply(stripes), 3), repeated({0, 37, 172, 172, 172, 172, 37, 0}, 2));
+}
+
+void ScanlinesTests::theScreenIsTheDarkColourOrBlack()
+{
+    const QImage image = filled(8, 8, QColor(255, 128, 0));
+    DitherSettings settings = scanlines(8);
+    settings.colors = DitherColors::twoColors;
+    settings.dark = AdjustmentColor(0, 0, 1);
+    settings.light = AdjustmentColor(1, 1, 0);
+    const QImage two = settings.apply(image);
+    // Off the line the dark colour; on it, the mix.
+    QCOMPARE(two.pixelColor(2, 0), QColor(0, 0, 255));
+    QCOMPARE(two.pixelColor(2, 4), QColor(197, 197, 147));
+    settings.colors = DitherColors::original;
+    const QImage original = settings.apply(image);
+    QCOMPARE(original.pixelColor(2, 0), QColor(0, 0, 0));
+    QCOMPARE(original.pixelColor(2, 4), QColor(255, 173, 0));
+}
+
+void ScanlinesTests::clearPixelsStayClear()
+{
+    QImage image = filled(8, 16, Qt::white);
+    QPainter painter(&image);
+    painter.setCompositionMode(QPainter::CompositionMode_Source);
+    painter.fillRect(QRect(0, 0, 8, 8), Qt::transparent);
+    painter.end();
+    const QImage result = scanlines(8, 100).apply(image);
+    QCOMPARE(column(result, 2, 3), (std::vector<int>{0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255}));
+    QCOMPARE(column(result, 2, 0)[4], 0);
+}
+
+void ScanlinesTests::everyBandOfATallImageIsDrawn()
+{
+    // 150 two-row lines: 32 bands of 5, two empty.
+    const QImage image = filled(3, 300, Qt::white);
+    QCOMPARE(column(scanlines(2).apply(image), 1), repeated({241, 241}, 150));
+    // 70 lines of 8: bands of 3, the last one.
+    const std::vector<int> tall = column(scanlines(8).apply(filled(3, 560, Qt::white)), 1);
+    QCOMPARE(tall, repeated({0, 255, 255, 255, 255, 255, 255, 0}, 70));
+}
+
+void ScanlinesTests::theGlowIsTheBlurredLightAtItsAmount()
+{
+    QImage image = filled(64, 160, Qt::black);
+    QPainter(&image).fillRect(QRect(0, 0, 32, 40), Qt::white);
+    const QImage lines = scanlines(8).apply(image);
+    // Swift's first glow: the lines blurred whole, sigma 27.
+    const QImage blurred = PixelAdjust::gaussianBlur(lines, 8 * 3 + 3, true);
+    for (const double glow : {20.0, 100.0}) {
+        const QImage result = scanlines(8, glow).apply(image);
+        const float amount = float(glow / 100 * 2.5);
+        int worst = 0;
+        for (int y = 0; y < 160; ++y) {
+            for (int x = 0; x < 64; ++x) {
+                const int plain = lines.constScanLine(y)[x * 4], light = blurred.constScanLine(y)[x * 4];
+                const int expected = int(std::lround(std::min(255.0f, float(plain) + float(light) * amount)));
+                worst = std::max(worst, std::abs(result.constScanLine(y)[x * 4] - expected));
+            }
+        }
+        // Three levels of the shrink's blur, times 2.5.
+        QVERIFY2(worst <= 8, qPrintable(QString::number(worst)));
+    }
+    // Below the light, at amount 0.5, it fades.
+    const std::vector<int> fading = column(scanlines(8, 20).apply(image), 16);
+    QVERIFY(fading[48] > 20 && fading[48] < fading[40] && fading[120] < 3);
+}
+
+void ScanlinesTests::theGlowNeverPassesAlpha()
+{
+    QImage image = BrushRaster::context(16, 32, false);
+    image.fill(QColor(255, 255, 255, 128));
+    const QImage result = scanlines(4, 100).apply(image);
+    for (int y = 0; y < 32; ++y) {
+        for (int x = 0; x < 16; ++x) {
+            const uchar *at = result.constScanLine(y) + x * 4;
+            QCOMPARE(int(at[3]), 128);
+            QVERIFY(at[0] <= 128 && at[1] <= 128 && at[2] <= 128);
+        }
+    }
+    QCOMPARE(int(result.constScanLine(0)[0]), 128);
+}
+
+void ScanlinesTests::theSheetShowsScanlinesRows()
+{
+    Shown shown;
+    QCOMPARE(shown.rows(), (QStringList{"Style|", "Line Spacing|How far apart the screen's lines are",
+                                        "Glow|Light blooming around the lines, like a CRT's phosphors", "Dots|Break the lines into glowing beads",
+                                        "Wobble|Make the lines waver sideways down the screen, like a CRT losing sync",
+                                        "Density|More ink (darker) or less before dithering", "Contrast|", "Colors|"}));
+    // Each slider's travel reaches its range's ends.
+    const std::tuple<const char *, double DitherSettings::*, double, double> sliders[] = {
+        {"lineSpacingSlider", &DitherSettings::lineSpacing, 2, 32}, {"glowSlider", &DitherSettings::glow, 0, 100},
+        {"dotsSlider", &DitherSettings::dots, 0, 100},               {"wobbleSlider", &DitherSettings::wobble, 0, 64}};
+    for (const auto &[name, setting, low, high] : sliders) {
+        QSlider *slider = shown.sheet->findChild<QSlider *>(QString::fromLatin1(name));
+        QVERIFY2(slider, name);
+        slider->setValue(slider->maximum());
+        QCOMPARE(shown.dither().*setting, high);
+        slider->setValue(slider->minimum());
+        QCOMPARE(shown.dither().*setting, low);
+    }
+    // Pixel Size and Pixel Shape stay away under Scanlines.
+    FilterSettings settings = shown.session.filterEdit().value().settings;
+    settings.dither.pixelSize = 4;
+    shown.session.updateFilter(settings, true);
+    QVERIFY(!shown.rows().join(',').contains("Pixel"));
+    settings.dither.style = DitherStyle::bayer4;
+    shown.session.updateFilter(settings, true);
+    QVERIFY(shown.rows().contains("Pixel Shape|Draw each chunky pixel as a solid square, or as a round dot like a dot-matrix screen"));
+    QVERIFY(!shown.rows().join(',').contains("Glow"));
+}
+
+void ScanlinesTests::theRowsWriteTheirSettings()
+{
+    Shown shown;
+    const std::tuple<const char *, double DitherSettings::*, const char *, double> rows[] = {
+        {"lineSpacingField", &DitherSettings::lineSpacing, "12", 12}, {"glowField", &DitherSettings::glow, "60", 60},
+        {"dotsField", &DitherSettings::dots, "25", 25},               {"wobbleField", &DitherSettings::wobble, "9", 9}};
+    for (const auto &[name, setting, typed, expected] : rows) {
+        const DitherSettings before = shown.dither();
+        QLineEdit *field = shown.sheet->findChild<QLineEdit *>(QString::fromLatin1(name));
+        QVERIFY2(field, name);
+        field->setFocus();
+        field->selectAll();
+        QTest::keyClicks(field, QString::fromLatin1(typed));
+        QTest::keyClick(field, Qt::Key_Return);
+        DitherSettings wanted = before;
+        wanted.*setting = expected;
+        QVERIFY2(shown.dither() == wanted, name);
+    }
+}
+
+QTEST_MAIN(ScanlinesTests)
+#include "ScanlinesTests.moc"

tests/Tests.cmake

@@ -166,6 +166,8 @@ compositor_test(ProjectReceiveTests)
 compositor_test(ProjectReplaceTests)
 compositor_test(ProjectWorkspaceFlowTests)
 compositor_test(QuitWhileEditingTextTests)
+compositor_test(QuitPendingEditsTests)
+compositor_test(ScanlinesTests)
 compositor_test(OpenRecentTests)
 compositor_test(ColoredSliderTests)
 compositor_test(SheetTeardownTests)