#include "overlay.hpp"
#include "app_messages.hpp"
#include "color_picker_math.hpp"
#include "gif_options_window.hpp"
#include "gif_recorder.hpp"
#include "image_io.hpp"
#include "settings.hpp"
#include "theme.hpp"
#include "uploader.hpp"

#include <objidl.h>
#include <gdiplus.h>
#include <windowsx.h>
#include <shellscalingapi.h>
#include <algorithm>
#include <array>
#include <cstdint>
#include <cmath>
#include <climits>
#include <cstdlib>
#include <cwctype>
#include <iomanip>
#include <memory>
#include <initializer_list>
#include <sstream>
#include <string>
#include <utility>
#include <unordered_set>
#include <vector>

using namespace Gdiplus;

namespace {
constexpr wchar_t kOverlayClass[] = L"NightShotOverlayWindow";

enum class Tool { Drag, Pen, Line, Arrow, Rectangle, Marker, Text };
enum class Action { Drag, Pen, Line, Arrow, Rectangle, Marker, Text, Color, Undo,
                    Upload, Share, Search, Gif, Print, Copy, Save, Close };
enum class ColorField { None, Hex, Red, Green, Blue, Alpha, Hue, Saturation, Value };

constexpr std::size_t kStrokeChunkSegments = 32;

struct Annotation {
    Tool tool = Tool::Pen;
    std::vector<PointF> points;
    // Pen/marker segments are grouped spatially so repainting a tiny dirty
    // rectangle does not scan a complete multi-thousand-point stroke.
    std::vector<RECT> strokeChunkBounds;
    RECT strokeBounds{};
    bool hasStrokeBounds = false;
    Color color = Color(255, 59, 130, 246);
    float width = 3.0f;
    float textSize = 22.0f; // physical pixels; captured when text editing begins
    std::wstring text;
};

RECT unionRawRects(RECT a, RECT b) {
    if (a.right <= a.left || a.bottom <= a.top) return b;
    if (b.right <= b.left || b.bottom <= b.top) return a;
    return RECT{std::min(a.left, b.left), std::min(a.top, b.top),
                std::max(a.right, b.right), std::max(a.bottom, b.bottom)};
}

void appendStrokeChunkBounds(Annotation& annotation, PointF first, PointF second) {
    if (annotation.tool != Tool::Pen && annotation.tool != Tool::Marker) return;
    if (annotation.points.size() < 2) return;
    const int padding = static_cast<int>(std::ceil(annotation.width * 0.5f)) + 3;
    RECT segment{
        static_cast<LONG>(std::floor(std::min(first.X, second.X))) - padding,
        static_cast<LONG>(std::floor(std::min(first.Y, second.Y))) - padding,
        static_cast<LONG>(std::ceil(std::max(first.X, second.X))) + padding + 1,
        static_cast<LONG>(std::ceil(std::max(first.Y, second.Y))) + padding + 1};
    const std::size_t segmentIndex = annotation.points.size() - 2;
    const std::size_t chunkIndex = segmentIndex / kStrokeChunkSegments;
    if (annotation.strokeChunkBounds.size() <= chunkIndex) {
        annotation.strokeChunkBounds.push_back(segment);
    } else {
        annotation.strokeChunkBounds[chunkIndex] = unionRawRects(annotation.strokeChunkBounds[chunkIndex], segment);
    }
    annotation.strokeBounds = annotation.hasStrokeBounds ? unionRawRects(annotation.strokeBounds, segment) : segment;
    annotation.hasStrokeBounds = true;
}

struct Button {
    RECT rect{};
    Action action = Action::Pen;
    bool enabled = true;
};

RECT normalizeRect(POINT a, POINT b) {
    return RECT{std::min(a.x, b.x), std::min(a.y, b.y), std::max(a.x, b.x), std::max(a.y, b.y)};
}

bool pointInRect(const RECT& r, POINT p) {
    return p.x >= r.left && p.x < r.right && p.y >= r.top && p.y < r.bottom;
}

int rectWidth(const RECT& r) { return r.right - r.left; }
int rectHeight(const RECT& r) { return r.bottom - r.top; }

Color toGdiColor(COLORREF c, BYTE alpha = 255) {
    return Color(alpha, GetRValue(c), GetGValue(c), GetBValue(c));
}

std::wstring actionName(Action action) {
    switch (action) {
        case Action::Drag: return L"Move selection (D)";
        case Action::Pen: return L"Pencil (P)";
        case Action::Line: return L"Line (L)";
        case Action::Arrow: return L"Arrow (A)";
        case Action::Rectangle: return L"Rectangle (R)";
        case Action::Marker: return L"Marker (M)";
        case Action::Text: return L"Text (T)";
        case Action::Color: return L"Color picker (C)";
        case Action::Undo: return L"Undo (Ctrl+Z)";
        case Action::Upload: return L"Upload";
        case Action::Share: return L"Share";
        case Action::Search: return L"Find similar";
        case Action::Gif: return L"Record GIF (Ctrl+PrintScreen)";
        case Action::Print: return L"Print";
        case Action::Copy: return L"Copy (Ctrl+C)";
        case Action::Save: return L"Save (Ctrl+S)";
        case Action::Close: return L"Close (Esc)";
    }
    return L"";
}

bool isToolAction(Action action) {
    return action >= Action::Drag && action <= Action::Text;
}

Tool toolFromAction(Action action) {
    switch (action) {
        case Action::Drag: return Tool::Drag;
        case Action::Line: return Tool::Line;
        case Action::Arrow: return Tool::Arrow;
        case Action::Rectangle: return Tool::Rectangle;
        case Action::Marker: return Tool::Marker;
        case Action::Text: return Tool::Text;
        default: return Tool::Pen;
    }
}

void drawArrow(Graphics& g, const Pen& pen, const Color& color, PointF start, PointF end) {
    const float dx = end.X - start.X;
    const float dy = end.Y - start.Y;
    const float length = std::sqrt(dx * dx + dy * dy);
    if (length < 1.0f) return;

    const float ux = dx / length;
    const float uy = dy / length;
    const float nx = -uy;
    const float ny = ux;
    const float stroke = std::max(1.0f, pen.GetWidth());
    const float headLength = std::clamp(stroke * 4.6f + 7.0f, 11.0f, 27.0f);
    const float halfHeadWidth = std::clamp(headLength * 0.48f, 5.0f, 14.0f);

    // Lightshot-style arrow: one clean rounded shaft with a filled triangular
    // head. The shaft runs under the head slightly so antialiasing never leaves
    // a visible seam between the two shapes.
    const float shaftInset = std::min(headLength * 0.58f, length * 0.45f);
    PointF shaftEnd(end.X - ux * shaftInset, end.Y - uy * shaftInset);
    g.DrawLine(&pen, start, shaftEnd);

    PointF baseCenter(end.X - ux * headLength, end.Y - uy * headLength);
    PointF triangle[3]{
        end,
        PointF(baseCenter.X + nx * halfHeadWidth, baseCenter.Y + ny * halfHeadWidth),
        PointF(baseCenter.X - nx * halfHeadWidth, baseCenter.Y - ny * halfHeadWidth)};
    SolidBrush headBrush(color);
    g.FillPolygon(&headBrush, triangle, 3);
}

void drawAnnotation(Graphics& g, const Annotation& a, float offsetX, float offsetY) {
    if (a.points.empty()) return;
    Pen pen(a.color, a.width);
    pen.SetLineJoin(LineJoinRound);
    pen.SetStartCap(LineCapRound);
    pen.SetEndCap(LineCapRound);

    auto shifted = [&](PointF p) { return PointF(p.X + offsetX, p.Y + offsetY); };
    switch (a.tool) {
        case Tool::Drag:
            break;
        case Tool::Pen:
        case Tool::Marker: {
            if (a.points.size() == 1) {
                PointF p = shifted(a.points.front());
                g.DrawEllipse(&pen, p.X, p.Y, 1.0f, 1.0f);
                break;
            }
            std::vector<PointF> pts;
            pts.reserve(a.points.size());
            for (auto p : a.points) pts.push_back(shifted(p));
            g.DrawLines(&pen, pts.data(), static_cast<INT>(pts.size()));
            break;
        }
        case Tool::Line:
            if (a.points.size() >= 2) g.DrawLine(&pen, shifted(a.points[0]), shifted(a.points[1]));
            break;
        case Tool::Arrow:
            if (a.points.size() >= 2) drawArrow(g, pen, a.color, shifted(a.points[0]), shifted(a.points[1]));
            break;
        case Tool::Rectangle:
            if (a.points.size() >= 2) {
                const PointF p1 = shifted(a.points[0]);
                const PointF p2 = shifted(a.points[1]);
                const REAL x = std::min(p1.X, p2.X), y = std::min(p1.Y, p2.Y);
                g.DrawRectangle(&pen, x, y, std::abs(p2.X - p1.X), std::abs(p2.Y - p1.Y));
            }
            break;
        case Tool::Text: {
            if (a.text.empty()) break;
            const GraphicsState state = g.Save();
            g.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
            g.SetTextContrast(0);
            g.SetPixelOffsetMode(PixelOffsetModeDefault);
            FontFamily family(L"Segoe UI");
            const REAL size = std::max<REAL>(14.0f, std::round(a.textSize));
            Font font(&family, size, FontStyleRegular, UnitPixel);
            SolidBrush brush(a.color);
            PointF p = shifted(a.points[0]);
            p.X = std::round(p.X);
            p.Y = std::round(p.Y);
            StringFormat format;
            format.SetFormatFlags(StringFormatFlagsNoWrap | StringFormatFlagsMeasureTrailingSpaces);
            g.DrawString(a.text.c_str(), -1, &font, p, &format, &brush);
            g.Restore(state);
            break;
        }
    }
}

void drawAnnotationClipped(Graphics& g, const Annotation& annotation, const RECT& clip,
                           float offsetX = 0.0f, float offsetY = 0.0f) {
    if (annotation.points.empty()) return;
    if (annotation.tool != Tool::Pen && annotation.tool != Tool::Marker) {
        float minX = annotation.points.front().X + offsetX;
        float minY = annotation.points.front().Y + offsetY;
        float maxX = minX;
        float maxY = minY;
        for (const PointF& point : annotation.points) {
            minX = std::min(minX, point.X + offsetX);
            minY = std::min(minY, point.Y + offsetY);
            maxX = std::max(maxX, point.X + offsetX);
            maxY = std::max(maxY, point.Y + offsetY);
        }
        float padding = annotation.width * 0.5f + 5.0f;
        if (annotation.tool == Tool::Arrow) padding += 30.0f;
        if (annotation.tool == Tool::Text) {
            const float size = std::max(14.0f, annotation.textSize);
            maxX += std::max(size * 2.0f, static_cast<float>(annotation.text.size()) * size * 0.72f);
            maxY += size * 1.45f;
        }
        if (minX - padding >= clip.right || maxX + padding <= clip.left ||
            minY - padding >= clip.bottom || maxY + padding <= clip.top) return;
        drawAnnotation(g, annotation, offsetX, offsetY);
        return;
    }

    Pen pen(annotation.color, annotation.width);
    pen.SetLineJoin(LineJoinRound);
    pen.SetStartCap(LineCapRound);
    pen.SetEndCap(LineCapRound);

    const float padding = annotation.width * 0.5f + 2.0f;
    auto shifted = [&](PointF point) { return PointF(point.X + offsetX, point.Y + offsetY); };
    if (annotation.points.size() == 1) {
        const PointF point = shifted(annotation.points.front());
        if (point.X + padding >= clip.left && point.X - padding <= clip.right &&
            point.Y + padding >= clip.top && point.Y - padding <= clip.bottom) {
            g.DrawEllipse(&pen, point.X, point.Y, 1.0f, 1.0f);
        }
        return;
    }

    auto drawSegmentRange = [&](std::size_t firstPointIndex, std::size_t endPointIndex) {
        endPointIndex = std::min(endPointIndex, annotation.points.size());
        for (std::size_t i = firstPointIndex; i < endPointIndex; ++i) {
            const PointF first = shifted(annotation.points[i - 1]);
            const PointF second = shifted(annotation.points[i]);
            const float left = std::min(first.X, second.X) - padding;
            const float top = std::min(first.Y, second.Y) - padding;
            const float right = std::max(first.X, second.X) + padding;
            const float bottom = std::max(first.Y, second.Y) + padding;
            if (left < clip.right && right > clip.left && top < clip.bottom && bottom > clip.top) {
                g.DrawLine(&pen, first, second);
            }
        }
    };

    if (annotation.hasStrokeBounds && offsetX == 0.0f && offsetY == 0.0f &&
        (annotation.strokeBounds.left >= clip.right || annotation.strokeBounds.right <= clip.left ||
         annotation.strokeBounds.top >= clip.bottom || annotation.strokeBounds.bottom <= clip.top)) return;

    if (!annotation.strokeChunkBounds.empty() && offsetX == 0.0f && offsetY == 0.0f) {
        for (std::size_t chunk = 0; chunk < annotation.strokeChunkBounds.size(); ++chunk) {
            const RECT& bounds = annotation.strokeChunkBounds[chunk];
            if (bounds.left >= clip.right || bounds.right <= clip.left ||
                bounds.top >= clip.bottom || bounds.bottom <= clip.top) continue;
            const std::size_t firstPointIndex = chunk * kStrokeChunkSegments + 1;
            drawSegmentRange(firstPointIndex, firstPointIndex + kStrokeChunkSegments);
        }
    } else {
        drawSegmentRange(1, annotation.points.size());
    }
}

void addRoundedRect(GraphicsPath& path, const RectF& rect, float radius) {
    const float d = radius * 2.0f;
    path.AddArc(rect.X, rect.Y, d, d, 180, 90);
    path.AddArc(rect.GetRight() - d, rect.Y, d, d, 270, 90);
    path.AddArc(rect.GetRight() - d, rect.GetBottom() - d, d, d, 0, 90);
    path.AddArc(rect.X, rect.GetBottom() - d, d, d, 90, 90);
    path.CloseFigure();
}

void fillRoundedRect(Graphics& g, const RectF& rect, float radius, const Brush& brush) {
    GraphicsPath path;
    addRoundedRect(path, rect, radius);
    g.FillPath(&brush, &path);
}

void strokeRoundedRect(Graphics& g, const RectF& rect, float radius, const Pen& pen) {
    GraphicsPath path;
    addRoundedRect(path, rect, radius);
    g.DrawPath(&pen, &path);
}

void fillRoundedGradient(Graphics& g, const RectF& rect, float radius,
                         const Color& start, const Color& end,
                         LinearGradientMode mode = LinearGradientModeVertical) {
    GraphicsPath path;
    addRoundedRect(path, rect, radius);
    LinearGradientBrush brush(rect, start, end, mode);
    g.FillPath(&brush, &path);
}


enum class UiIcon {
    Move, PenTool, Line, ArrowUpRight, Square, Marker, Type, Colors, Undo,
    Upload, Share, Search, Film, Printer, Copy, Save, Close
};

class IconCanvas {
public:
    IconCanvas(Graphics& graphics, const RectF& bounds, const Color& color)
        : g_(graphics), scale_(std::min(bounds.Width, bounds.Height) / 24.0f),
          ox_(std::floor(bounds.X + (bounds.Width - 24.0f * scale_) * 0.5f) + 0.5f),
          oy_(std::floor(bounds.Y + (bounds.Height - 24.0f * scale_) * 0.5f) + 0.5f),
          pen_(color, std::max(1.30f, 1.78f * scale_)), brush_(color) {
        pen_.SetStartCap(LineCapRound);
        pen_.SetEndCap(LineCapRound);
        pen_.SetLineJoin(LineJoinRound);
    }

    PointF point(float x, float y) const { return PointF(ox_ + x * scale_, oy_ + y * scale_); }
    RectF rect(float x, float y, float w, float h) const {
        return RectF(ox_ + x * scale_, oy_ + y * scale_, w * scale_, h * scale_);
    }

    void line(float x1, float y1, float x2, float y2) { g_.DrawLine(&pen_, point(x1, y1), point(x2, y2)); }

    void polyline(std::initializer_list<std::pair<float, float>> points, bool closed = false) {
        std::vector<PointF> mapped;
        mapped.reserve(points.size());
        for (const auto& [x, y] : points) mapped.push_back(point(x, y));
        if (mapped.size() < 2) return;
        GraphicsPath path;
        path.AddLines(mapped.data(), static_cast<INT>(mapped.size()));
        if (closed) path.CloseFigure();
        g_.DrawPath(&pen_, &path);
    }

    void ellipse(float x, float y, float w, float h) {
        const RectF bounds = rect(x, y, w, h);
        g_.DrawEllipse(&pen_, bounds);
    }
    void fillEllipse(float x, float y, float w, float h) {
        const RectF bounds = rect(x, y, w, h);
        g_.FillEllipse(&brush_, bounds);
    }
    void roundedRect(float x, float y, float w, float h, float radius) {
        const RectF bounds = rect(x, y, w, h);
        strokeRoundedRect(g_, bounds, radius * scale_, pen_);
    }
    void arc(float x, float y, float w, float h, float start, float sweep) {
        const RectF bounds = rect(x, y, w, h);
        g_.DrawArc(&pen_, bounds, start, sweep);
    }

    Graphics& graphics() { return g_; }
    Pen& pen() { return pen_; }

private:
    Graphics& g_;
    float scale_;
    float ox_;
    float oy_;
    Pen pen_;
    SolidBrush brush_;
};

void drawUiIcon(Graphics& g, UiIcon icon, const RectF& bounds, const Color& color, COLORREF selectedColor) {
    (void)selectedColor;
    const GraphicsState state = g.Save();
    g.SetSmoothingMode(SmoothingModeAntiAlias);
    g.SetPixelOffsetMode(PixelOffsetModeHalf);
    g.SetCompositingQuality(CompositingQualityHighQuality);
    IconCanvas c(g, bounds, color);
    switch (icon) {
        case UiIcon::Move:
            c.line(12.0f, 3.0f, 12.0f, 21.0f);
            c.line(3.0f, 12.0f, 21.0f, 12.0f);
            c.polyline({{8.0f, 7.0f}, {12.0f, 3.0f}, {16.0f, 7.0f}});
            c.polyline({{8.0f, 17.0f}, {12.0f, 21.0f}, {16.0f, 17.0f}});
            c.polyline({{7.0f, 8.0f}, {3.0f, 12.0f}, {7.0f, 16.0f}});
            c.polyline({{17.0f, 8.0f}, {21.0f, 12.0f}, {17.0f, 16.0f}});
            break;
        case UiIcon::PenTool:
            c.polyline({{3.5f, 20.5f}, {5.0f, 15.5f}, {15.8f, 4.7f}, {19.3f, 8.2f}, {8.5f, 19.0f}, {3.5f, 20.5f}}, true);
            c.line(5.0f, 15.5f, 8.5f, 19.0f);
            c.line(14.4f, 6.1f, 17.9f, 9.6f);
            break;
        case UiIcon::Line:
            c.line(5.0f, 19.0f, 19.0f, 5.0f);
            break;
        case UiIcon::ArrowUpRight:
            c.line(5.0f, 19.0f, 19.0f, 5.0f);
            c.line(10.5f, 5.0f, 19.0f, 5.0f);
            c.line(19.0f, 5.0f, 19.0f, 13.5f);
            break;
        case UiIcon::Square:
            c.roundedRect(4.0f, 4.0f, 16.0f, 16.0f, 2.2f);
            break;
        case UiIcon::Marker:
            c.polyline({{5.0f, 16.0f}, {14.2f, 6.8f}, {17.2f, 9.8f}, {8.0f, 19.0f}, {5.0f, 19.0f}, {5.0f, 16.0f}}, true);
            c.line(14.2f, 6.8f, 16.4f, 4.6f);
            c.line(16.4f, 4.6f, 19.4f, 7.6f);
            c.line(19.4f, 7.6f, 17.2f, 9.8f);
            c.line(4.0f, 21.0f, 12.0f, 21.0f);
            break;
        case UiIcon::Type:
            c.line(4.0f, 6.0f, 4.0f, 4.0f);
            c.line(4.0f, 4.0f, 20.0f, 4.0f);
            c.line(20.0f, 4.0f, 20.0f, 6.0f);
            c.line(12.0f, 4.0f, 12.0f, 20.0f);
            c.line(8.5f, 20.0f, 15.5f, 20.0f);
            break;
        case UiIcon::Colors: {
            // Compact eyedropper + sampled-color well, matching the picker itself.
            c.polyline({{14.2f, 4.0f}, {20.0f, 9.8f}, {17.2f, 12.6f}, {11.4f, 6.8f}, {14.2f, 4.0f}}, true);
            c.line(13.0f, 8.4f, 6.2f, 15.2f);
            c.line(6.2f, 15.2f, 5.0f, 19.0f);
            c.line(5.0f, 19.0f, 8.8f, 17.8f);
            c.line(8.8f, 17.8f, 15.6f, 11.0f);
            c.ellipse(3.5f, 16.0f, 5.0f, 5.0f);
            break;
        }
        case UiIcon::Undo:
            c.arc(4.0f, 5.0f, 16.0f, 14.0f, 205.0f, 285.0f);
            c.line(5.3f, 9.0f, 5.3f, 4.8f);
            c.line(5.3f, 9.0f, 9.5f, 9.0f);
            break;
        case UiIcon::Upload:
            c.line(12.0f, 15.0f, 12.0f, 4.0f);
            c.line(7.8f, 8.2f, 12.0f, 4.0f);
            c.line(16.2f, 8.2f, 12.0f, 4.0f);
            c.polyline({{5.0f, 14.0f}, {5.0f, 18.0f}, {6.0f, 19.0f}, {18.0f, 19.0f}, {19.0f, 18.0f}, {19.0f, 14.0f}});
            break;
        case UiIcon::Share:
            c.ellipse(3.5f, 9.5f, 4.0f, 4.0f);
            c.ellipse(16.5f, 3.5f, 4.0f, 4.0f);
            c.ellipse(16.5f, 16.5f, 4.0f, 4.0f);
            c.line(7.1f, 10.7f, 16.8f, 6.3f);
            c.line(7.1f, 12.3f, 16.8f, 17.7f);
            break;
        case UiIcon::Search:
            c.ellipse(4.0f, 4.0f, 13.0f, 13.0f);
            c.line(15.0f, 15.0f, 21.0f, 21.0f);
            break;
        case UiIcon::Film:
            c.roundedRect(3.0f, 5.0f, 18.0f, 14.0f, 2.0f);
            c.line(7.0f, 5.0f, 7.0f, 19.0f);
            c.line(17.0f, 5.0f, 17.0f, 19.0f);
            c.line(3.0f, 9.0f, 7.0f, 9.0f);
            c.line(3.0f, 15.0f, 7.0f, 15.0f);
            c.line(17.0f, 9.0f, 21.0f, 9.0f);
            c.line(17.0f, 15.0f, 21.0f, 15.0f);
            c.polyline({{10.0f, 9.0f}, {15.0f, 12.0f}, {10.0f, 15.0f}}, true);
            break;
        case UiIcon::Printer:
            c.roundedRect(3.0f, 8.0f, 18.0f, 10.0f, 2.0f);
            c.polyline({{7.0f, 8.0f}, {7.0f, 3.0f}, {17.0f, 3.0f}, {17.0f, 8.0f}});
            c.roundedRect(7.0f, 14.0f, 10.0f, 7.0f, 1.2f);
            c.fillEllipse(17.2f, 10.7f, 1.8f, 1.8f);
            break;
        case UiIcon::Copy:
            c.roundedRect(7.0f, 7.0f, 13.0f, 13.0f, 2.0f);
            c.polyline({{16.0f, 7.0f}, {16.0f, 5.0f}, {15.0f, 4.0f}, {5.0f, 4.0f}, {4.0f, 5.0f}, {4.0f, 15.0f}, {5.0f, 16.0f}, {7.0f, 16.0f}});
            break;
        case UiIcon::Save:
            c.polyline({{4.0f, 3.0f}, {17.0f, 3.0f}, {21.0f, 7.0f}, {21.0f, 21.0f}, {3.0f, 21.0f}, {3.0f, 4.0f}, {4.0f, 3.0f}}, true);
            c.roundedRect(7.0f, 13.0f, 10.0f, 8.0f, 1.2f);
            c.polyline({{7.0f, 3.0f}, {7.0f, 8.0f}, {16.0f, 8.0f}, {16.0f, 3.0f}});
            break;
        case UiIcon::Close:
            c.line(5.0f, 5.0f, 19.0f, 19.0f);
            c.line(19.0f, 5.0f, 5.0f, 19.0f);
            break;
    }
    g.Restore(state);
}

UiIcon iconForAction(Action action) {
    switch (action) {
        case Action::Drag: return UiIcon::Move;
        case Action::Pen: return UiIcon::PenTool;
        case Action::Line: return UiIcon::Line;
        case Action::Arrow: return UiIcon::ArrowUpRight;
        case Action::Rectangle: return UiIcon::Square;
        case Action::Marker: return UiIcon::Marker;
        case Action::Text: return UiIcon::Type;
        case Action::Color: return UiIcon::Colors;
        case Action::Undo: return UiIcon::Undo;
        case Action::Upload: return UiIcon::Upload;
        case Action::Share: return UiIcon::Share;
        case Action::Search: return UiIcon::Search;
        case Action::Gif: return UiIcon::Film;
        case Action::Print: return UiIcon::Printer;
        case Action::Copy: return UiIcon::Copy;
        case Action::Save: return UiIcon::Save;
        case Action::Close: return UiIcon::Close;
    }
    return UiIcon::Close;
}

} // namespace

struct OverlayWindow::Impl {
    struct MonitorArea {
        HMONITOR handle = nullptr;
        RECT bounds{};
        RECT workBounds{};
        UINT dpi = 96;
    };

    struct UiMetrics {
        // Roughly 20% tighter than v0.11. The glyph itself is slightly larger,
        // so the panel loses empty air without making the icon harder to read.
        int button = 28;
        int gap = 1;
        int radius = 6;
        int panelPadding = 2;
        int icon = 19;
        int handle = 7;
        int margin = 6;
        int paletteCell = 25;
        int paletteSwatch = 18;
        int pickerPadding = 9;
        int pickerFieldHeight = 27;
        int tooltipDelayMs = 420;
    };

    static constexpr UINT_PTR kHoverTimer = 1;
    static constexpr int kPaintTileWidth = 1024;
    static constexpr int kPaintTileHeight = 512;

    Impl(ScreenCapture&& screen, HWND target, OverlayMode initialMode)
        : notificationTarget(target), capture(std::move(screen)), mode(initialMode) {
        enumerateMonitors();
        const settings::AppSettings stored = settings::load();
        penWidth = static_cast<float>(stored.penWidth);
        lineWidth = static_cast<float>(stored.lineWidth);
        arrowWidth = static_cast<float>(stored.arrowWidth);
        rectangleWidth = static_cast<float>(stored.rectangleWidth);
        markerWidth = static_cast<float>(stored.markerWidth);
        savedPalette = stored.paletteArgb;
        savedPaletteOccupied = stored.paletteOccupied;
        color = color_picker_math::colorFromArgb(stored.selectedColorArgb);
        colorAlpha = color_picker_math::alphaFromArgb(stored.selectedColorArgb);
        pickerHsv = color_picker_math::rgbToHsv(GetRValue(color), GetGValue(color), GetBValue(color));

        POINT cursor{};
        if (GetCursorPos(&cursor)) {
            cursor.x -= capture.x;
            cursor.y -= capture.y;
            hintMonitorIndex = monitorIndexForPoint(cursor);
            cursorPoint = cursor;
        }
    }

    ~Impl() {
        releaseScratchBuffer();
    }

    HWND hwnd = nullptr;
    HWND notificationTarget = nullptr;
    ScreenCapture capture;
    OverlayMode mode = OverlayMode::Screenshot;
    // selection is the visible part inside the virtual desktop.
    // logicalSelection keeps the full rectangle while it is temporarily clipped
    // by a desktop edge, so dragging it back restores the original dimensions.
    RECT selection{};
    RECT logicalSelection{};
    RECT originalSelection{};
    RECT originalLogicalSelection{};
    POINT dragStart{};
    POINT lastPoint{};
    bool hasSelection = false;
    bool selecting = false;
    bool drawing = false;
    bool draggingSelection = false;
    int resizeHandle = -1;
    Tool tool = Tool::Drag;
    COLORREF color = theme::kAccent;
    std::vector<Annotation> annotations;
    std::vector<Button> verticalButtons;
    std::vector<Button> horizontalButtons;
    std::array<RECT, 8> handleRects{};
    std::vector<MonitorArea> monitors;
    UiMetrics ui{};
    int uiMonitorIndex = 0;
    int hintMonitorIndex = 0;
    RECT verticalPanelBounds{};
    RECT horizontalPanelBounds{};
    RECT palettePanelBounds{};
    RECT dimensionBadgeRect{};
    int hoveredButton = -1; // combined index: vertical then horizontal
    int tooltipButton = -1;
    bool trackingMouseLeave = false;
    bool paletteOpen = false;

    BYTE colorAlpha = 255;
    color_picker_math::Hsv pickerHsv{};
    bool eyedropperActive = false;
    bool pickerDraggingSv = false;
    bool pickerDraggingHue = false;
    bool pickerDraggingAlpha = false;
    ColorField activeColorField = ColorField::None;
    std::wstring colorFieldBuffer;
    bool colorFieldReplaceOnType = false;
    RECT pickerPreviewRect{};
    RECT pickerEyedropperRect{};
    RECT pickerSvRect{};
    RECT pickerHueRect{};
    RECT pickerAlphaRect{};
    std::array<RECT, 8> pickerFieldRects{};
    int pickerPaletteCell = 25;
    int pickerPaletteSwatch = 18;
    std::array<std::uint32_t, settings::kSavedColorCount> savedPalette{};
    std::array<bool, settings::kSavedColorCount> savedPaletteOccupied{};
    std::array<RECT, settings::kSavedColorCount> paletteRects{};

    float penWidth = 3.0f;
    float lineWidth = 3.0f;
    float arrowWidth = 3.0f;
    float rectangleWidth = 3.0f;
    float markerWidth = 15.0f;
    POINT cursorPoint{};
    RECT brushPreviewRect{};

    bool textEditing = false;
    POINT textAnchor{};
    RECT textEditorRect{};
    float textEditSize = 22.0f;
    std::wstring textEditBuffer;

    HDC scratchDc = nullptr;
    HBITMAP scratchBitmap = nullptr;
    HGDIOBJ oldScratchBitmap = nullptr;
    std::uint8_t* scratchPixels = nullptr;
    int scratchWidth = 0;
    int scratchHeight = 0;
    int scratchStride = 0;

    static BOOL CALLBACK enumMonitorProc(HMONITOR monitor, HDC, LPRECT, LPARAM value) {
        auto* self = reinterpret_cast<Impl*>(value);
        MONITORINFO info{};
        info.cbSize = sizeof(info);
        if (!GetMonitorInfoW(monitor, &info)) return TRUE;

        UINT dpiX = 96;
        UINT dpiY = 96;
        if (GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY) == S_OK) {
            dpiX = (dpiX + dpiY) / 2;
        } else {
            dpiX = 96;
        }
        RECT local{
            info.rcMonitor.left - self->capture.x,
            info.rcMonitor.top - self->capture.y,
            info.rcMonitor.right - self->capture.x,
            info.rcMonitor.bottom - self->capture.y};
        RECT localWork{
            info.rcWork.left - self->capture.x,
            info.rcWork.top - self->capture.y,
            info.rcWork.right - self->capture.x,
            info.rcWork.bottom - self->capture.y};
        self->monitors.push_back(MonitorArea{monitor, local, localWork, dpiX});
        return TRUE;
    }

    void enumerateMonitors() {
        monitors.clear();
        EnumDisplayMonitors(nullptr, nullptr, &Impl::enumMonitorProc, reinterpret_cast<LPARAM>(this));
        if (monitors.empty()) {
            const RECT fallback{0, 0, capture.width, capture.height};
            monitors.push_back(MonitorArea{nullptr, fallback, fallback, 96});
        }
    }

    static long long distanceSquaredToRect(const RECT& r, POINT p) {
        const long long dx = p.x < r.left ? static_cast<long long>(r.left) - p.x
                           : p.x >= r.right ? static_cast<long long>(p.x) - (r.right - 1) : 0;
        const long long dy = p.y < r.top ? static_cast<long long>(r.top) - p.y
                           : p.y >= r.bottom ? static_cast<long long>(p.y) - (r.bottom - 1) : 0;
        return dx * dx + dy * dy;
    }

    int monitorIndexForPoint(POINT p) const {
        for (size_t i = 0; i < monitors.size(); ++i) {
            if (pointInRect(monitors[i].bounds, p)) return static_cast<int>(i);
        }
        int best = 0;
        long long bestDistance = distanceSquaredToRect(monitors[0].bounds, p);
        for (size_t i = 1; i < monitors.size(); ++i) {
            const long long distance = distanceSquaredToRect(monitors[i].bounds, p);
            if (distance < bestDistance) {
                best = static_cast<int>(i);
                bestDistance = distance;
            }
        }
        return best;
    }

    static RECT intersectRects(RECT a, RECT b) {
        RECT result{std::max(a.left, b.left), std::max(a.top, b.top),
                    std::min(a.right, b.right), std::min(a.bottom, b.bottom)};
        if (result.right <= result.left || result.bottom <= result.top) return RECT{0, 0, 0, 0};
        return result;
    }

    static bool rectsIntersect(RECT a, RECT b) {
        return a.left < b.right && a.right > b.left && a.top < b.bottom && a.bottom > b.top;
    }

    UiMetrics metricsForMonitor(int index) const {
        const float scale = std::clamp(static_cast<float>(monitors[index].dpi) / 96.0f, 0.85f, 2.25f);
        auto px = [scale](float value) { return std::max(1, static_cast<int>(std::lround(value * scale))); };
        UiMetrics result;
        result.button = px(28.0f);
        result.gap = px(1.0f);
        result.radius = px(6.0f);
        result.panelPadding = px(2.0f);
        result.icon = px(19.0f);
        result.handle = std::max(7, px(7.0f));
        result.margin = px(6.0f);
        result.paletteCell = px(25.0f);
        result.paletteSwatch = px(18.0f);
        result.pickerPadding = px(9.0f);
        result.pickerFieldHeight = px(27.0f);
        result.tooltipDelayMs = 420;
        return result;
    }

    RECT safeMonitorBounds(int index) const {
        RECT result = monitors[index].workBounds;
        InflateRect(&result, -ui.margin, -ui.margin);
        return result;
    }

    static long long intersectionArea(RECT first, RECT second) {
        const LONG width = std::max(0L, std::min(first.right, second.right) - std::max(first.left, second.left));
        const LONG height = std::max(0L, std::min(first.bottom, second.bottom) - std::max(first.top, second.top));
        return static_cast<long long>(width) * static_cast<long long>(height);
    }

    static bool isDrawingTool(Tool value) {
        return value == Tool::Pen || value == Tool::Line || value == Tool::Arrow ||
               value == Tool::Rectangle || value == Tool::Marker;
    }

    float currentStrokeWidth() const {
        switch (tool) {
            case Tool::Pen: return penWidth;
            case Tool::Line: return lineWidth;
            case Tool::Arrow: return arrowWidth;
            case Tool::Rectangle: return rectangleWidth;
            case Tool::Marker: return markerWidth;
            default: return 0.0f;
        }
    }

    float* currentStrokeWidthPointer() {
        switch (tool) {
            case Tool::Pen: return &penWidth;
            case Tool::Line: return &lineWidth;
            case Tool::Arrow: return &arrowWidth;
            case Tool::Rectangle: return &rectangleWidth;
            case Tool::Marker: return &markerWidth;
            default: return nullptr;
        }
    }

    void persistEditorPreferences() const {
        settings::AppSettings value = settings::load();
        value.penWidth = static_cast<int>(std::lround(penWidth));
        value.lineWidth = static_cast<int>(std::lround(lineWidth));
        value.arrowWidth = static_cast<int>(std::lround(arrowWidth));
        value.rectangleWidth = static_cast<int>(std::lround(rectangleWidth));
        value.markerWidth = static_cast<int>(std::lround(markerWidth));
        value.selectedColorArgb = currentArgb();
        value.paletteArgb = savedPalette;
        value.paletteOccupied = savedPaletteOccupied;
        const bool saved = settings::save(value);
        (void)saved;
    }

    RECT calculateDimensionBadgeBounds() const {
        if ((!hasSelection && !selecting) || rectWidth(selection) <= 0 || rectHeight(selection) <= 0)
            return RECT{0, 0, 0, 0};
        const POINT anchor{selection.left, selection.top};
        const int monitorIndex = monitorIndexForPoint(anchor);
        const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
        const UiMetrics metrics = metricsForMonitor(monitorIndex);
        RECT safe = monitors[monitorIndex].workBounds;
        InflateRect(&safe, -metrics.margin, -metrics.margin);
        const std::wstring dimensions = std::to_wstring(std::max(0, rectWidth(selection))) + L" × " +
                                        std::to_wstring(std::max(0, rectHeight(selection)));
        const LONG width = static_cast<LONG>(std::ceil(dimensions.size() * 7.15f * scale)) +
                           static_cast<LONG>(std::max(13, metrics.icon - 3));
        const LONG height = static_cast<LONG>(std::max(22, static_cast<int>(std::lround(24.0f * scale))));
        const LONG gap = static_cast<LONG>(std::max(4, metrics.gap + 3));
        LONG x = std::clamp(selection.left, safe.left, std::max(safe.left, safe.right - width));
        LONG y = selection.top - height - gap;
        if (y < safe.top) y = selection.top + gap;
        y = std::clamp(y, safe.top, std::max(safe.top, safe.bottom - height));
        return RECT{x, y, x + width, y + height};
    }

    void updateDimensionBadgeBounds() {
        dimensionBadgeRect = calculateDimensionBadgeBounds();
    }

    void syncPickerFromRgb() {
        pickerHsv = color_picker_math::rgbToHsv(GetRValue(color), GetGValue(color), GetBValue(color));
    }

    void setCurrentColor(COLORREF nextColor, BYTE nextAlpha, bool syncHsv = true) {
        color = nextColor;
        colorAlpha = nextAlpha;
        if (syncHsv) syncPickerFromRgb();
        persistEditorPreferences();
    }

    std::uint32_t currentArgb() const {
        return color_picker_math::toArgb(color, colorAlpha);
    }

    static ColorField fieldForIndex(int index) {
        constexpr std::array<ColorField, 8> fields{
            ColorField::Hex, ColorField::Red, ColorField::Green, ColorField::Blue,
            ColorField::Alpha, ColorField::Hue, ColorField::Saturation, ColorField::Value};
        return index >= 0 && index < static_cast<int>(fields.size()) ? fields[index] : ColorField::None;
    }

    static const wchar_t* colorFieldLabel(ColorField field) {
        switch (field) {
            case ColorField::Hex: return L"HEX";
            case ColorField::Red: return L"R";
            case ColorField::Green: return L"G";
            case ColorField::Blue: return L"B";
            case ColorField::Alpha: return L"A";
            case ColorField::Hue: return L"H";
            case ColorField::Saturation: return L"S";
            case ColorField::Value: return L"V";
            default: return L"";
        }
    }

    std::wstring colorFieldValue(ColorField field) const {
        switch (field) {
            case ColorField::Hex: return color_picker_math::hexRgba(color, colorAlpha);
            case ColorField::Red: return std::to_wstring(GetRValue(color));
            case ColorField::Green: return std::to_wstring(GetGValue(color));
            case ColorField::Blue: return std::to_wstring(GetBValue(color));
            case ColorField::Alpha: return std::to_wstring(colorAlpha);
            case ColorField::Hue: return std::to_wstring(static_cast<int>(std::lround(pickerHsv.h)) % 360);
            case ColorField::Saturation: return std::to_wstring(static_cast<int>(std::lround(pickerHsv.s * 100.0f)));
            case ColorField::Value: return std::to_wstring(static_cast<int>(std::lround(pickerHsv.v * 100.0f)));
            default: return L"";
        }
    }

    static bool parseStrictInt(const std::wstring& text, int& result) {
        if (text.empty()) return false;
        wchar_t* end = nullptr;
        const long value = std::wcstol(text.c_str(), &end, 10);
        if (!end || *end != L'\0') return false;
        result = static_cast<int>(value);
        return true;
    }

    void startColorFieldEdit(ColorField field) {
        activeColorField = field;
        colorFieldBuffer = colorFieldValue(field);
        colorFieldReplaceOnType = true;
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void cancelColorFieldEdit() {
        if (activeColorField == ColorField::None) return;
        activeColorField = ColorField::None;
        colorFieldBuffer.clear();
        colorFieldReplaceOnType = false;
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void commitColorFieldEdit() {
        if (activeColorField == ColorField::None) return;
        bool changed = false;
        if (activeColorField == ColorField::Hex) {
            COLORREF parsedColor = color;
            BYTE parsedAlpha = colorAlpha;
            if (color_picker_math::parseHexRgba(colorFieldBuffer, parsedColor, parsedAlpha)) {
                setCurrentColor(parsedColor, parsedAlpha);
                changed = true;
            }
        } else {
            int value = 0;
            if (parseStrictInt(colorFieldBuffer, value)) {
                switch (activeColorField) {
                    case ColorField::Red:
                        setCurrentColor(RGB(std::clamp(value, 0, 255), GetGValue(color), GetBValue(color)), colorAlpha);
                        changed = true;
                        break;
                    case ColorField::Green:
                        setCurrentColor(RGB(GetRValue(color), std::clamp(value, 0, 255), GetBValue(color)), colorAlpha);
                        changed = true;
                        break;
                    case ColorField::Blue:
                        setCurrentColor(RGB(GetRValue(color), GetGValue(color), std::clamp(value, 0, 255)), colorAlpha);
                        changed = true;
                        break;
                    case ColorField::Alpha:
                        setCurrentColor(color, static_cast<BYTE>(std::clamp(value, 0, 255)), false);
                        changed = true;
                        break;
                    case ColorField::Hue:
                        pickerHsv.h = static_cast<float>((value % 360 + 360) % 360);
                        setCurrentColor(color_picker_math::hsvToRgb(pickerHsv.h, pickerHsv.s, pickerHsv.v), colorAlpha, false);
                        changed = true;
                        break;
                    case ColorField::Saturation:
                        pickerHsv.s = static_cast<float>(std::clamp(value, 0, 100)) / 100.0f;
                        setCurrentColor(color_picker_math::hsvToRgb(pickerHsv.h, pickerHsv.s, pickerHsv.v), colorAlpha, false);
                        changed = true;
                        break;
                    case ColorField::Value:
                        pickerHsv.v = static_cast<float>(std::clamp(value, 0, 100)) / 100.0f;
                        setCurrentColor(color_picker_math::hsvToRgb(pickerHsv.h, pickerHsv.s, pickerHsv.v), colorAlpha, false);
                        changed = true;
                        break;
                    default: break;
                }
            }
        }
        activeColorField = ColorField::None;
        colorFieldBuffer.clear();
        colorFieldReplaceOnType = false;
        if (changed) invalidateButton(7);
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void appendColorFieldCharacter(wchar_t character) {
        if (activeColorField == ColorField::None) return;
        if (character == L'\b') {
            if (colorFieldReplaceOnType) colorFieldBuffer.clear();
            else if (!colorFieldBuffer.empty()) colorFieldBuffer.pop_back();
            colorFieldReplaceOnType = false;
        } else if (activeColorField == ColorField::Hex) {
            if (colorFieldReplaceOnType) { colorFieldBuffer.clear(); colorFieldReplaceOnType = false; }
            if (character == L'#' && colorFieldBuffer.empty()) colorFieldBuffer.push_back(character);
            else if (std::iswxdigit(static_cast<wint_t>(character)) && colorFieldBuffer.size() < 9)
                colorFieldBuffer.push_back(static_cast<wchar_t>(std::towupper(character)));
            else return;
        } else {
            if (colorFieldReplaceOnType) { colorFieldBuffer.clear(); colorFieldReplaceOnType = false; }
            if (std::iswdigit(static_cast<wint_t>(character)) && colorFieldBuffer.size() < 3)
                colorFieldBuffer.push_back(character);
            else return;
        }
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void pasteColorFieldFromClipboard() {
        if (activeColorField == ColorField::None || !OpenClipboard(hwnd)) return;
        HANDLE data = GetClipboardData(CF_UNICODETEXT);
        if (data) {
            const auto* text = static_cast<const wchar_t*>(GlobalLock(data));
            if (text) {
                colorFieldBuffer.clear();
                colorFieldReplaceOnType = false;
                for (const wchar_t* cursor = text; *cursor; ++cursor) {
                    const wchar_t character = *cursor;
                    if (activeColorField == ColorField::Hex) {
                        if (character == L'#' && colorFieldBuffer.empty()) colorFieldBuffer.push_back(character);
                        else if (std::iswxdigit(static_cast<wint_t>(character)) && colorFieldBuffer.size() < 9)
                            colorFieldBuffer.push_back(static_cast<wchar_t>(std::towupper(character)));
                    } else if (std::iswdigit(static_cast<wint_t>(character)) && colorFieldBuffer.size() < 3) {
                        colorFieldBuffer.push_back(character);
                    }
                }
                GlobalUnlock(data);
                invalidateRectPadded(palettePanelBounds, 3);
            }
        }
        CloseClipboard();
    }

    void saveCurrentColorToSlot(std::size_t index) {
        if (index >= settings::kSavedColorCount) return;
        savedPalette[index] = currentArgb();
        savedPaletteOccupied[index] = true;
        persistEditorPreferences();
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void clearSavedColorSlot(std::size_t index) {
        if (index < 8 || index >= settings::kSavedColorCount) return;
        savedPaletteOccupied[index] = false;
        savedPalette[index] = 0;
        persistEditorPreferences();
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void updatePickerFromSvPoint(POINT point) {
        if (rectWidth(pickerSvRect) <= 1 || rectHeight(pickerSvRect) <= 1) return;
        pickerHsv.s = std::clamp(static_cast<float>(point.x - pickerSvRect.left) /
                                 static_cast<float>(rectWidth(pickerSvRect) - 1), 0.0f, 1.0f);
        pickerHsv.v = 1.0f - std::clamp(static_cast<float>(point.y - pickerSvRect.top) /
                                        static_cast<float>(rectHeight(pickerSvRect) - 1), 0.0f, 1.0f);
        color = color_picker_math::hsvToRgb(pickerHsv.h, pickerHsv.s, pickerHsv.v);
        invalidateButton(7);
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void updatePickerFromHuePoint(POINT point) {
        if (rectHeight(pickerHueRect) <= 1) return;
        const float ratio = std::clamp(static_cast<float>(point.y - pickerHueRect.top) /
                                       static_cast<float>(rectHeight(pickerHueRect) - 1), 0.0f, 1.0f);
        pickerHsv.h = ratio * 359.999f;
        color = color_picker_math::hsvToRgb(pickerHsv.h, pickerHsv.s, pickerHsv.v);
        invalidateButton(7);
        invalidateRectPadded(palettePanelBounds, 3);
    }

    void updatePickerFromAlphaPoint(POINT point) {
        if (rectHeight(pickerAlphaRect) <= 1) return;
        const float ratio = std::clamp(static_cast<float>(point.y - pickerAlphaRect.top) /
                                       static_cast<float>(rectHeight(pickerAlphaRect) - 1), 0.0f, 1.0f);
        colorAlpha = static_cast<BYTE>(std::lround((1.0f - ratio) * 255.0f));
        invalidateButton(7);
        invalidateRectPadded(palettePanelBounds, 3);
    }

    bool sampleCapturedColor(POINT point) {
        if (point.x < 0 || point.y < 0 ||
            point.x >= capture.width || point.y >= capture.height) return false;
        COLORREF sampled{};
        if (!capture.samplePixel(point.x, point.y, sampled)) return false;
        setCurrentColor(sampled, 255);
        return true;
    }

    RECT brushPreviewBounds(POINT point) const {
        if (!hasSelection || !isDrawingTool(tool) || point.x < 0 || point.y < 0 ||
            point.x >= capture.width || point.y >= capture.height) return RECT{0, 0, 0, 0};
        const int diameter = std::max(1, static_cast<int>(std::ceil(currentStrokeWidth())));
        const int radius = (diameter + 1) / 2 + 2;
        return clampToClient(RECT{point.x - radius, point.y - radius,
                                  point.x + radius + 1, point.y + radius + 1});
    }

    void updateBrushPreview(POINT point) {
        const RECT previous = brushPreviewRect;
        cursorPoint = point;
        brushPreviewRect = brushPreviewBounds(point);
        invalidateRectPadded(previous, 2);
        invalidateRectPadded(brushPreviewRect, 2);
    }

    void adjustCurrentStrokeWidth(int wheelDelta) {
        float* width = currentStrokeWidthPointer();
        if (!width || wheelDelta == 0) return;
        const float step = tool == Tool::Marker ? 2.0f : 1.0f;
        const float maximum = tool == Tool::Marker ? 96.0f : 64.0f;
        const RECT previous = brushPreviewRect;
        *width = std::clamp(*width + (wheelDelta > 0 ? -step : step), 1.0f, maximum);
        persistEditorPreferences();
        brushPreviewRect = brushPreviewBounds(cursorPoint);
        invalidateRectPadded(previous, 3);
        invalidateRectPadded(brushPreviewRect, 3);
    }

    void releaseScratchBuffer() {
        if (scratchDc && oldScratchBitmap && oldScratchBitmap != HGDI_ERROR) SelectObject(scratchDc, oldScratchBitmap);
        oldScratchBitmap = nullptr;
        if (scratchBitmap) DeleteObject(scratchBitmap);
        scratchBitmap = nullptr;
        if (scratchDc) DeleteDC(scratchDc);
        scratchDc = nullptr;
        scratchPixels = nullptr;
        scratchWidth = 0;
        scratchHeight = 0;
        scratchStride = 0;
    }

    bool ensureScratchBuffer(HDC target, int width, int height) {
        if (width <= 0 || height <= 0) return false;
        if (scratchDc && scratchBitmap && scratchWidth >= width && scratchHeight >= height) return true;

        releaseScratchBuffer();
        scratchWidth = ((width + 127) / 128) * 128;
        scratchHeight = ((height + 63) / 64) * 64;
        scratchStride = scratchWidth * 4;
        scratchDc = CreateCompatibleDC(target);
        if (!scratchDc) return false;

        BITMAPINFO info{};
        info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        info.bmiHeader.biWidth = scratchWidth;
        info.bmiHeader.biHeight = -scratchHeight;
        info.bmiHeader.biPlanes = 1;
        info.bmiHeader.biBitCount = 32;
        info.bmiHeader.biCompression = BI_RGB;
        void* pixels = nullptr;
        scratchBitmap = CreateDIBSection(target, &info, DIB_RGB_COLORS, &pixels, nullptr, 0);
        if (!scratchBitmap) {
            releaseScratchBuffer();
            return false;
        }
        scratchPixels = static_cast<std::uint8_t*>(pixels);
        oldScratchBitmap = SelectObject(scratchDc, scratchBitmap);
        if (!oldScratchBitmap || oldScratchBitmap == HGDI_ERROR) {
            oldScratchBitmap = nullptr;
            releaseScratchBuffer();
            return false;
        }
        return true;
    }

    RECT clampToClient(RECT r) const {
        r.left = std::clamp(r.left, 0L, static_cast<LONG>(capture.width));
        r.top = std::clamp(r.top, 0L, static_cast<LONG>(capture.height));
        r.right = std::clamp(r.right, 0L, static_cast<LONG>(capture.width));
        r.bottom = std::clamp(r.bottom, 0L, static_cast<LONG>(capture.height));
        return r;
    }

    RECT visibleSelectionFromLogical(RECT logical) const {
        const RECT client{0, 0, static_cast<LONG>(capture.width), static_cast<LONG>(capture.height)};
        return intersectRects(logical, client);
    }

    RECT keepLogicalSelectionReachable(RECT logical) const {
        // Let the full selection move beyond the virtual desktop, but always keep
        // a small draggable strip visible. The hidden part is retained in
        // logicalSelection and returns as soon as the user drags back.
        constexpr LONG minVisible = 8L;
        if (logical.right < minVisible) OffsetRect(&logical, minVisible - logical.right, 0);
        if (logical.left > static_cast<LONG>(capture.width) - minVisible)
            OffsetRect(&logical, static_cast<LONG>(capture.width) - minVisible - logical.left, 0);
        if (logical.bottom < minVisible) OffsetRect(&logical, 0, minVisible - logical.bottom);
        if (logical.top > static_cast<LONG>(capture.height) - minVisible)
            OffsetRect(&logical, 0, static_cast<LONG>(capture.height) - minVisible - logical.top);
        return logical;
    }

    void invalidateRectPadded(RECT r, int padding = 0) {
        if (!hwnd) return;
        InflateRect(&r, padding, padding);
        r = clampToClient(r);
        if (r.right > r.left && r.bottom > r.top) InvalidateRect(hwnd, &r, FALSE);
    }

    RECT toolbarBounds(const std::vector<Button>& buttons) const {
        if (buttons.empty()) return RECT{0, 0, 0, 0};
        RECT bounds = buttons.front().rect;
        for (const Button& button : buttons) {
            bounds.left = std::min(bounds.left, button.rect.left);
            bounds.top = std::min(bounds.top, button.rect.top);
            bounds.right = std::max(bounds.right, button.rect.right);
            bounds.bottom = std::max(bounds.bottom, button.rect.bottom);
        }
        InflateRect(&bounds, ui.panelPadding + 3, ui.panelPadding + 4);
        return clampToClient(bounds);
    }

    RECT popupBoundsNearButton(int combinedIndex, int width, int height) const {
        const Button* button = nullptr;
        bool vertical = false;
        if (combinedIndex >= 0 && combinedIndex < static_cast<int>(verticalButtons.size())) {
            button = &verticalButtons[combinedIndex];
            vertical = true;
        } else {
            const int horizontalIndex = combinedIndex - static_cast<int>(verticalButtons.size());
            if (horizontalIndex >= 0 && horizontalIndex < static_cast<int>(horizontalButtons.size()))
                button = &horizontalButtons[horizontalIndex];
        }
        if (!button) return RECT{0, 0, 0, 0};

        POINT center{(button->rect.left + button->rect.right) / 2,
                     (button->rect.top + button->rect.bottom) / 2};
        const RECT safe = safeMonitorBounds(monitorIndexForPoint(center));
        const int gap = std::max(5, ui.gap + 4);
        std::array<RECT, 4> candidates{};
        if (vertical) {
            candidates = {{
                {button->rect.left - gap - width, button->rect.top + (rectHeight(button->rect) - height) / 2,
                 button->rect.left - gap, button->rect.top + (rectHeight(button->rect) - height) / 2 + height},
                {button->rect.right + gap, button->rect.top + (rectHeight(button->rect) - height) / 2,
                 button->rect.right + gap + width, button->rect.top + (rectHeight(button->rect) - height) / 2 + height},
                {button->rect.left + (rectWidth(button->rect) - width) / 2, button->rect.top - gap - height,
                 button->rect.left + (rectWidth(button->rect) - width) / 2 + width, button->rect.top - gap},
                {button->rect.left + (rectWidth(button->rect) - width) / 2, button->rect.bottom + gap,
                 button->rect.left + (rectWidth(button->rect) - width) / 2 + width, button->rect.bottom + gap + height}}};
        } else {
            candidates = {{
                {button->rect.left + (rectWidth(button->rect) - width) / 2, button->rect.top - gap - height,
                 button->rect.left + (rectWidth(button->rect) - width) / 2 + width, button->rect.top - gap},
                {button->rect.left + (rectWidth(button->rect) - width) / 2, button->rect.bottom + gap,
                 button->rect.left + (rectWidth(button->rect) - width) / 2 + width, button->rect.bottom + gap + height},
                {button->rect.left - gap - width, button->rect.top + (rectHeight(button->rect) - height) / 2,
                 button->rect.left - gap, button->rect.top + (rectHeight(button->rect) - height) / 2 + height},
                {button->rect.right + gap, button->rect.top + (rectHeight(button->rect) - height) / 2,
                 button->rect.right + gap + width, button->rect.top + (rectHeight(button->rect) - height) / 2 + height}}};
        }

        auto fits = [&](const RECT& r) {
            return r.left >= safe.left && r.top >= safe.top && r.right <= safe.right && r.bottom <= safe.bottom &&
                   !rectsIntersect(r, dimensionBadgeRect);
        };
        for (const RECT& candidate : candidates) if (fits(candidate)) return candidate;

        RECT result = candidates.front();
        if (result.left < safe.left) OffsetRect(&result, safe.left - result.left, 0);
        if (result.right > safe.right) OffsetRect(&result, safe.right - result.right, 0);
        if (result.top < safe.top) OffsetRect(&result, 0, safe.top - result.top);
        if (result.bottom > safe.bottom) OffsetRect(&result, 0, safe.bottom - result.bottom);
        return clampToClient(result);
    }

    RECT tooltipBoundsApprox(int combinedIndex) const {
        if (combinedIndex < 0) return RECT{0, 0, 0, 0};
        const Button* button = nullptr;
        if (combinedIndex < static_cast<int>(verticalButtons.size())) button = &verticalButtons[combinedIndex];
        else {
            const int index = combinedIndex - static_cast<int>(verticalButtons.size());
            if (index >= 0 && index < static_cast<int>(horizontalButtons.size())) button = &horizontalButtons[index];
        }
        if (!button) return RECT{0, 0, 0, 0};
        const std::wstring label = actionName(button->action);
        const float scale = std::max(0.85f, static_cast<float>(ui.icon) / 17.0f);
        const int width = std::max(44, static_cast<int>(std::lround(label.size() * 6.4f * scale)) + 16);
        const int height = std::max(24, static_cast<int>(std::lround(25.0f * scale)));
        return popupBoundsNearButton(combinedIndex, width, height);
    }

    RECT hintRectForMonitor(int index) const {
        index = std::clamp(index, 0, static_cast<int>(monitors.size()) - 1);
        const RECT safe = monitors[index].workBounds;
        const float scale = std::clamp(static_cast<float>(monitors[index].dpi) / 96.0f, 0.85f, 2.25f);
        const int width = static_cast<int>(std::lround(248.0f * scale));
        const int height = static_cast<int>(std::lround(76.0f * scale));
        const int cx = (safe.left + safe.right) / 2;
        const int cy = (safe.top + safe.bottom) / 2;
        return RECT{cx - width / 2, cy - height / 2, cx - width / 2 + width, cy - height / 2 + height};
    }

    RECT uiBounds() const {
        RECT bounds{0, 0, 0, 0};
        bool any = false;
        auto include = [&](RECT r) {
            if (r.right <= r.left || r.bottom <= r.top) return;
            if (!any) { bounds = r; any = true; return; }
            bounds = unionRects(bounds, r);
        };
        include(toolbarBounds(verticalButtons));
        include(toolbarBounds(horizontalButtons));
        if (paletteOpen) include(palettePanelBounds);
        if (tooltipButton >= 0) include(tooltipBoundsApprox(tooltipButton));
        if (textEditing) include(textEditorRect);
        return any ? clampToClient(bounds) : RECT{0, 0, 0, 0};
    }

    void invalidate() { if (hwnd) InvalidateRect(hwnd, nullptr, FALSE); }
    void invalidateUi() { invalidateRectPadded(uiBounds(), 3); }
    void invalidateUiTransition(RECT oldUiBounds) {
        invalidateRectPadded(oldUiBounds, 3);
        invalidateRectPadded(uiBounds(), 3);
    }

    void invalidateOutline(RECT r, int thickness) {
        if (r.right <= r.left || r.bottom <= r.top) return;
        invalidateRectPadded(RECT{r.left, r.top, r.right, std::min(r.bottom, r.top + thickness)}, thickness);
        invalidateRectPadded(RECT{r.left, std::max(r.top, r.bottom - thickness), r.right, r.bottom}, thickness);
        invalidateRectPadded(RECT{r.left, r.top, std::min(r.right, r.left + thickness), r.bottom}, thickness);
        invalidateRectPadded(RECT{std::max(r.left, r.right - thickness), r.top, r.right, r.bottom}, thickness);
    }

    void invalidateSelectionDifference(RECT oldSelection, RECT newSelection) {
        if (!hwnd) return;
        HRGN oldRegion = CreateRectRgn(oldSelection.left, oldSelection.top, oldSelection.right, oldSelection.bottom);
        HRGN newRegion = CreateRectRgn(newSelection.left, newSelection.top, newSelection.right, newSelection.bottom);
        HRGN difference = CreateRectRgn(0, 0, 0, 0);
        if (oldRegion && newRegion && difference) {
            CombineRgn(difference, oldRegion, newRegion, RGN_XOR);
            InvalidateRgn(hwnd, difference, FALSE);
        }
        if (difference) DeleteObject(difference);
        if (newRegion) DeleteObject(newRegion);
        if (oldRegion) DeleteObject(oldRegion);
    }

    void invalidateSelection() {
        if (!hasSelection && !selecting) { invalidate(); return; }
        invalidateOutline(selection, std::max(8, ui.handle + 4));
        invalidateRectPadded(uiBounds(), 3);
        invalidateRectPadded(dimensionBadgeRect, 5);
        invalidateRectPadded(brushPreviewRect, 3);
    }

    RECT annotationBounds(const Annotation& annotation) const {
        if (annotation.points.empty()) return RECT{0, 0, 0, 0};
        if ((annotation.tool == Tool::Pen || annotation.tool == Tool::Marker) && annotation.hasStrokeBounds) {
            return clampToClient(annotation.strokeBounds);
        }
        float minX = annotation.points.front().X;
        float minY = annotation.points.front().Y;
        float maxX = minX;
        float maxY = minY;
        for (const PointF& point : annotation.points) {
            minX = std::min(minX, point.X);
            minY = std::min(minY, point.Y);
            maxX = std::max(maxX, point.X);
            maxY = std::max(maxY, point.Y);
        }
        int padding = static_cast<int>(std::ceil(annotation.width * 0.5f)) + 5;
        if (annotation.tool == Tool::Arrow) padding += 30;
        if (annotation.tool == Tool::Text) {
            const float size = std::max(14.0f, annotation.textSize);
            maxX += std::max(size * 2.0f, static_cast<float>(annotation.text.size()) * size * 0.72f);
            maxY += size * 1.45f;
            padding = std::max(5, static_cast<int>(std::ceil(size * 0.18f)));
        }
        RECT result{
            static_cast<LONG>(std::floor(minX)) - padding,
            static_cast<LONG>(std::floor(minY)) - padding,
            static_cast<LONG>(std::ceil(maxX)) + padding + 1,
            static_cast<LONG>(std::ceil(maxY)) + padding + 1};
        return clampToClient(result);
    }

    static RECT unionRects(RECT a, RECT b) {
        if (a.right <= a.left || a.bottom <= a.top) return b;
        if (b.right <= b.left || b.bottom <= b.top) return a;
        return RECT{std::min(a.left, b.left), std::min(a.top, b.top),
                    std::max(a.right, b.right), std::max(a.bottom, b.bottom)};
    }

    void invalidateSelectionTransition(RECT oldSelection, RECT oldUiBounds, RECT oldBadgeBounds) {
        invalidateSelectionDifference(oldSelection, selection);
        invalidateOutline(oldSelection, std::max(9, ui.handle + 5));
        invalidateOutline(selection, std::max(9, ui.handle + 5));
        invalidateRectPadded(oldUiBounds, 3);
        invalidateRectPadded(uiBounds(), 3);
        // Invalidate the exact previous badge rectangle. The old broad estimate
        // missed the below-selection placement used for tiny edge selections and
        // left a GIF-like trail behind.
        invalidateRectPadded(oldBadgeBounds, 5);
        invalidateRectPadded(dimensionBadgeRect, 5);
    }

    static RECT clampPanelTo(RECT panel, RECT safe) {
        if (panel.left < safe.left) OffsetRect(&panel, safe.left - panel.left, 0);
        if (panel.right > safe.right) OffsetRect(&panel, safe.right - panel.right, 0);
        if (panel.top < safe.top) OffsetRect(&panel, 0, safe.top - panel.top);
        if (panel.bottom > safe.bottom) OffsetRect(&panel, 0, safe.bottom - panel.bottom);
        return panel;
    }

    void updateLayout() {
        verticalButtons.clear();
        horizontalButtons.clear();
        verticalPanelBounds = RECT{0, 0, 0, 0};
        horizontalPanelBounds = RECT{0, 0, 0, 0};
        palettePanelBounds = RECT{0, 0, 0, 0};
        pickerPreviewRect = RECT{0, 0, 0, 0};
        pickerEyedropperRect = RECT{0, 0, 0, 0};
        pickerSvRect = RECT{0, 0, 0, 0};
        pickerHueRect = RECT{0, 0, 0, 0};
        pickerAlphaRect = RECT{0, 0, 0, 0};
        pickerFieldRects.fill(RECT{0, 0, 0, 0});
        paletteRects.fill(RECT{0, 0, 0, 0});
        updateDimensionBadgeBounds();
        if (!hasSelection) return;

        const POINT uiAnchor{
            selection.right > selection.left ? selection.right - 1 : selection.left,
            selection.bottom > selection.top ? selection.bottom - 1 : selection.top};
        uiMonitorIndex = monitorIndexForPoint(uiAnchor);
        ui = metricsForMonitor(uiMonitorIndex);
        const RECT safe = safeMonitorBounds(uiMonitorIndex);
        updateDimensionBadgeBounds();
        RECT badgeObstacle = dimensionBadgeRect;
        if (badgeObstacle.right > badgeObstacle.left && badgeObstacle.bottom > badgeObstacle.top) {
            const int clearance = std::max(3, ui.panelPadding + 2);
            InflateRect(&badgeObstacle, clearance, clearance);
        }
        RECT visibleSelection = intersectRects(selection, monitors[uiMonitorIndex].bounds);
        if (visibleSelection.right <= visibleSelection.left || visibleSelection.bottom <= visibleSelection.top) {
            visibleSelection = RECT{
                std::clamp(selection.left, safe.left, safe.right - 1),
                std::clamp(selection.top, safe.top, safe.bottom - 1),
                std::clamp(selection.left + 1, safe.left + 1, safe.right),
                std::clamp(selection.top + 1, safe.top + 1, safe.bottom)};
        }

        auto fits = [&](const RECT& rect) {
            return rect.left >= safe.left && rect.top >= safe.top &&
                   rect.right <= safe.right && rect.bottom <= safe.bottom;
        };
        auto chooseCandidate = [&](const auto& candidates, std::initializer_list<RECT> obstacles) {
            RECT best = clampPanelTo(candidates.front(), safe);
            long long bestScore = LLONG_MAX;
            for (const RECT& raw : candidates) {
                RECT candidate = raw;
                const bool fullyFits = fits(candidate);
                if (!fullyFits) candidate = clampPanelTo(candidate, safe);
                long long overlap = 0;
                for (const RECT& obstacle : obstacles) overlap += intersectionArea(candidate, obstacle);
                const long long displacement = std::llabs(static_cast<long long>(candidate.left) - raw.left) +
                                               std::llabs(static_cast<long long>(candidate.top) - raw.top);
                const long long score = overlap * 1000LL + displacement * 10LL + (fullyFits ? 0LL : 100LL);
                if (score < bestScore) {
                    best = candidate;
                    bestScore = score;
                    if (score == 0) break;
                }
            }
            return best;
        };

        const std::array<Action, 9> verticalActions{
            Action::Drag, Action::Pen, Action::Line, Action::Arrow, Action::Rectangle,
            Action::Marker, Action::Text, Action::Color, Action::Undo};
        const int verticalContentHeight = static_cast<int>(verticalActions.size()) * ui.button +
                                          (static_cast<int>(verticalActions.size()) - 1) * ui.gap;
        const int verticalPanelWidth = ui.button + ui.panelPadding * 2;
        const int verticalPanelHeight = verticalContentHeight + ui.panelPadding * 2;
        const int outsideGap = std::max(ui.gap + ui.panelPadding + 2, ui.margin);

        const std::array<RECT, 6> verticalCandidates{{
            {visibleSelection.right + outsideGap, visibleSelection.top,
             visibleSelection.right + outsideGap + verticalPanelWidth, visibleSelection.top + verticalPanelHeight},
            {visibleSelection.left - outsideGap - verticalPanelWidth, visibleSelection.top,
             visibleSelection.left - outsideGap, visibleSelection.top + verticalPanelHeight},
            {visibleSelection.right + outsideGap, visibleSelection.bottom - verticalPanelHeight,
             visibleSelection.right + outsideGap + verticalPanelWidth, visibleSelection.bottom},
            {visibleSelection.left - outsideGap - verticalPanelWidth, visibleSelection.bottom - verticalPanelHeight,
             visibleSelection.left - outsideGap, visibleSelection.bottom},
            {visibleSelection.right - verticalPanelWidth - ui.margin, visibleSelection.top + ui.margin,
             visibleSelection.right - ui.margin, visibleSelection.top + ui.margin + verticalPanelHeight},
            {visibleSelection.left + ui.margin, visibleSelection.top + ui.margin,
             visibleSelection.left + ui.margin + verticalPanelWidth, visibleSelection.top + ui.margin + verticalPanelHeight}}};
        verticalPanelBounds = chooseCandidate(verticalCandidates, {badgeObstacle});
        for (std::size_t i = 0; i < verticalActions.size(); ++i) {
            const int x = verticalPanelBounds.left + ui.panelPadding;
            const int y = verticalPanelBounds.top + ui.panelPadding + static_cast<int>(i) * (ui.button + ui.gap);
            verticalButtons.push_back(Button{RECT{x, y, x + ui.button, y + ui.button}, verticalActions[i], true});
        }

        const std::array<Action, 8> horizontalActions{
            Action::Upload, Action::Share, Action::Search, Action::Gif,
            Action::Print, Action::Copy, Action::Save, Action::Close};
        const int horizontalContentWidth = static_cast<int>(horizontalActions.size()) * ui.button +
                                           (static_cast<int>(horizontalActions.size()) - 1) * ui.gap;
        const int horizontalPanelWidth = horizontalContentWidth + ui.panelPadding * 2;
        const int horizontalPanelHeight = ui.button + ui.panelPadding * 2;
        const int preferredLeft = std::clamp(visibleSelection.right - horizontalPanelWidth,
                                             safe.left, std::max(safe.left, safe.right - horizontalPanelWidth));
        const int leftAligned = std::clamp(visibleSelection.left,
                                           safe.left, std::max(safe.left, safe.right - horizontalPanelWidth));
        const std::array<RECT, 6> horizontalCandidates{{
            {preferredLeft, visibleSelection.bottom + outsideGap,
             preferredLeft + horizontalPanelWidth, visibleSelection.bottom + outsideGap + horizontalPanelHeight},
            {preferredLeft, visibleSelection.top - outsideGap - horizontalPanelHeight,
             preferredLeft + horizontalPanelWidth, visibleSelection.top - outsideGap},
            {leftAligned, visibleSelection.bottom + outsideGap,
             leftAligned + horizontalPanelWidth, visibleSelection.bottom + outsideGap + horizontalPanelHeight},
            {leftAligned, visibleSelection.top - outsideGap - horizontalPanelHeight,
             leftAligned + horizontalPanelWidth, visibleSelection.top - outsideGap},
            {preferredLeft, visibleSelection.bottom - horizontalPanelHeight - ui.margin,
             preferredLeft + horizontalPanelWidth, visibleSelection.bottom - ui.margin},
            {preferredLeft, visibleSelection.top + ui.margin,
             preferredLeft + horizontalPanelWidth, visibleSelection.top + ui.margin + horizontalPanelHeight}}};
        horizontalPanelBounds = chooseCandidate(horizontalCandidates, {verticalPanelBounds, badgeObstacle});
        for (std::size_t i = 0; i < horizontalActions.size(); ++i) {
            const int x = horizontalPanelBounds.left + ui.panelPadding + static_cast<int>(i) * (ui.button + ui.gap);
            const int y = horizontalPanelBounds.top + ui.panelPadding;
            horizontalButtons.push_back(Button{RECT{x, y, x + ui.button, y + ui.button}, horizontalActions[i], true});
        }

        const int hs = ui.handle;
        const int cx = (selection.left + selection.right) / 2;
        const int cy = (selection.top + selection.bottom) / 2;
        const std::array<POINT, 8> points{{
            {selection.left, selection.top}, {cx, selection.top}, {selection.right, selection.top},
            {selection.right, cy}, {selection.right, selection.bottom}, {cx, selection.bottom},
            {selection.left, selection.bottom}, {selection.left, cy}}};
        for (std::size_t i = 0; i < points.size(); ++i) {
            RECT handle{points[i].x - hs / 2, points[i].y - hs / 2,
                        points[i].x - hs / 2 + hs, points[i].y - hs / 2 + hs};
            if (handle.left < 0) OffsetRect(&handle, -handle.left, 0);
            if (handle.top < 0) OffsetRect(&handle, 0, -handle.top);
            if (handle.right > capture.width) OffsetRect(&handle, capture.width - handle.right, 0);
            if (handle.bottom > capture.height) OffsetRect(&handle, 0, capture.height - handle.bottom);
            handleRects[i] = handle;
        }

        if (!verticalButtons.empty()) {
            const RECT anchor = verticalButtons[7].rect;
            const float dpiScale = std::clamp(static_cast<float>(monitors[uiMonitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
            const float widthScale = static_cast<float>(std::max(1, rectWidth(safe))) / 318.0f;
            const float heightScale = static_cast<float>(std::max(1, rectHeight(safe))) / 394.0f;
            const float pickerScale = std::clamp(std::min({dpiScale, widthScale, heightScale}), 0.72f, dpiScale);
            const auto pickerPx = [pickerScale](float value) {
                return std::max(1, static_cast<int>(std::lround(value * pickerScale)));
            };

            const int pad = pickerPx(9.0f);
            const int gap = pickerPx(6.0f);
            const int topHeight = pickerPx(30.0f);
            const int sliderWidth = pickerPx(15.0f);
            const int svHeight = pickerPx(112.0f);
            const int fieldHeight = pickerPx(27.0f);
            pickerPaletteCell = pickerPx(25.0f);
            pickerPaletteSwatch = pickerPx(18.0f);
            const int gridWidth = pickerPaletteCell * 8;
            const int gridHeight = pickerPaletteCell * 6;
            const int panelWidth = std::max(pickerPx(304.0f), gridWidth + pad * 2);
            const int numericHeight = fieldHeight * 2 + gap;
            const int panelHeight = pad * 2 + topHeight + gap + svHeight + gap + numericHeight + gap + gridHeight;
            const int pickerGap = std::max(ui.margin, pickerPx(7.0f));

            const std::array<RECT, 4> pickerCandidates{{
                {verticalPanelBounds.left - pickerGap - panelWidth,
                 std::clamp(anchor.top - topHeight, safe.top, std::max(safe.top, safe.bottom - panelHeight)),
                 verticalPanelBounds.left - pickerGap,
                 std::clamp(anchor.top - topHeight, safe.top, std::max(safe.top, safe.bottom - panelHeight)) + panelHeight},
                {verticalPanelBounds.right + pickerGap,
                 std::clamp(anchor.top - topHeight, safe.top, std::max(safe.top, safe.bottom - panelHeight)),
                 verticalPanelBounds.right + pickerGap + panelWidth,
                 std::clamp(anchor.top - topHeight, safe.top, std::max(safe.top, safe.bottom - panelHeight)) + panelHeight},
                {std::clamp(anchor.left - panelWidth / 2, safe.left, std::max(safe.left, safe.right - panelWidth)),
                 verticalPanelBounds.bottom + pickerGap,
                 std::clamp(anchor.left - panelWidth / 2, safe.left, std::max(safe.left, safe.right - panelWidth)) + panelWidth,
                 verticalPanelBounds.bottom + pickerGap + panelHeight},
                {std::clamp(anchor.left - panelWidth / 2, safe.left, std::max(safe.left, safe.right - panelWidth)),
                 verticalPanelBounds.top - pickerGap - panelHeight,
                 std::clamp(anchor.left - panelWidth / 2, safe.left, std::max(safe.left, safe.right - panelWidth)) + panelWidth,
                 verticalPanelBounds.top - pickerGap}}};
            palettePanelBounds = chooseCandidate(
                pickerCandidates, {verticalPanelBounds, horizontalPanelBounds, badgeObstacle});

            int y = palettePanelBounds.top + pad;
            pickerPreviewRect = RECT{palettePanelBounds.left + pad, y,
                                     palettePanelBounds.left + pad + topHeight, y + topHeight};
            pickerEyedropperRect = RECT{pickerPreviewRect.right + gap, y,
                                        pickerPreviewRect.right + gap + topHeight, y + topHeight};
            pickerFieldRects[0] = RECT{pickerEyedropperRect.right + gap, y,
                                       palettePanelBounds.right - pad, y + topHeight};

            y += topHeight + gap;
            const int svWidth = std::max(pickerPx(100.0f), panelWidth - pad * 2 - sliderWidth * 2 - gap * 2);
            pickerSvRect = RECT{palettePanelBounds.left + pad, y,
                                palettePanelBounds.left + pad + svWidth, y + svHeight};
            pickerHueRect = RECT{pickerSvRect.right + gap, y,
                                 pickerSvRect.right + gap + sliderWidth, y + svHeight};
            pickerAlphaRect = RECT{pickerHueRect.right + gap, y,
                                   pickerHueRect.right + gap + sliderWidth, y + svHeight};

            y += svHeight + gap;
            const int fieldGap = gap;
            const int fieldWidth = (panelWidth - pad * 2 - fieldGap * 3) / 4;
            for (int i = 1; i < 8; ++i) {
                const int numericIndex = i - 1;
                const int row = numericIndex / 4;
                const int col = numericIndex % 4;
                const int left = palettePanelBounds.left + pad + col * (fieldWidth + fieldGap);
                const int top = y + row * (fieldHeight + fieldGap);
                pickerFieldRects[i] = RECT{left, top, left + fieldWidth, top + fieldHeight};
            }

            y += numericHeight + gap;
            const int gridLeft = palettePanelBounds.left + (panelWidth - gridWidth) / 2;
            for (std::size_t i = 0; i < settings::kSavedColorCount; ++i) {
                const int row = static_cast<int>(i) / 8;
                const int col = static_cast<int>(i) % 8;
                const int cellLeft = gridLeft + col * pickerPaletteCell;
                const int cellTop = y + row * pickerPaletteCell;
                const int inset = std::max(1, (pickerPaletteCell - pickerPaletteSwatch) / 2);
                paletteRects[i] = RECT{cellLeft + inset, cellTop + inset,
                                       cellLeft + inset + pickerPaletteSwatch,
                                       cellTop + inset + pickerPaletteSwatch};
            }
        }
    }

    bool buttonEnabled(Action action) const {
        return action != Action::Undo || !annotations.empty();
    }

    int hitButton(POINT p) const {
        for (size_t i = 0; i < verticalButtons.size(); ++i) {
            if (buttonEnabled(verticalButtons[i].action) && pointInRect(verticalButtons[i].rect, p))
                return static_cast<int>(i);
        }
        for (size_t i = 0; i < horizontalButtons.size(); ++i) {
            if (buttonEnabled(horizontalButtons[i].action) && pointInRect(horizontalButtons[i].rect, p))
                return static_cast<int>(verticalButtons.size() + i);
        }
        return -1;
    }

    Button* buttonAtCombinedIndex(int index) {
        if (index < 0) return nullptr;
        if (index < static_cast<int>(verticalButtons.size())) return &verticalButtons[index];
        index -= static_cast<int>(verticalButtons.size());
        if (index < static_cast<int>(horizontalButtons.size())) return &horizontalButtons[index];
        return nullptr;
    }

    const Button* buttonAtCombinedIndex(int index) const {
        if (index < 0) return nullptr;
        if (index < static_cast<int>(verticalButtons.size())) return &verticalButtons[index];
        index -= static_cast<int>(verticalButtons.size());
        if (index < static_cast<int>(horizontalButtons.size())) return &horizontalButtons[index];
        return nullptr;
    }

    bool hitPalette(POINT p) const {
        return paletteOpen && pointInRect(palettePanelBounds, p);
    }

    bool handleColorPickerLeftDown(POINT point) {
        if (!paletteOpen) return false;
        if (pointInRect(pickerEyedropperRect, point)) {
            const RECT previousUi = uiBounds();
            cancelColorFieldEdit();
            paletteOpen = false;
            eyedropperActive = true;
            invalidateUiTransition(previousUi);
            updateCursor(point);
            return true;
        }
        for (int i = 0; i < 8; ++i) {
            if (pointInRect(pickerFieldRects[i], point)) {
                if (activeColorField != ColorField::None) commitColorFieldEdit();
                startColorFieldEdit(fieldForIndex(i));
                return true;
            }
        }
        if (pointInRect(pickerSvRect, point)) {
            commitColorFieldEdit();
            pickerDraggingSv = true;
            updatePickerFromSvPoint(point);
            SetCapture(hwnd);
            return true;
        }
        if (pointInRect(pickerHueRect, point)) {
            commitColorFieldEdit();
            pickerDraggingHue = true;
            updatePickerFromHuePoint(point);
            SetCapture(hwnd);
            return true;
        }
        if (pointInRect(pickerAlphaRect, point)) {
            commitColorFieldEdit();
            pickerDraggingAlpha = true;
            updatePickerFromAlphaPoint(point);
            SetCapture(hwnd);
            return true;
        }
        for (std::size_t i = 0; i < settings::kSavedColorCount; ++i) {
            if (!pointInRect(paletteRects[i], point)) continue;
            commitColorFieldEdit();
            if (savedPaletteOccupied[i]) {
                setCurrentColor(color_picker_math::colorFromArgb(savedPalette[i]),
                                color_picker_math::alphaFromArgb(savedPalette[i]));
                invalidateButton(7);
                invalidateRectPadded(palettePanelBounds, 3);
            } else {
                saveCurrentColorToSlot(i);
            }
            return true;
        }
        if (pointInRect(palettePanelBounds, point)) {
            commitColorFieldEdit();
            return true;
        }
        return false;
    }

    bool handleColorPickerRightDown(POINT point) {
        if (!paletteOpen) return false;
        for (std::size_t i = 0; i < settings::kSavedColorCount; ++i) {
            if (!pointInRect(paletteRects[i], point)) continue;
            const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
            if (shift) clearSavedColorSlot(i);
            else saveCurrentColorToSlot(i);
            return true;
        }
        return pointInRect(palettePanelBounds, point);
    }

    bool pickerDragging() const {
        return pickerDraggingSv || pickerDraggingHue || pickerDraggingAlpha;
    }

    void updatePickerDrag(POINT point) {
        if (pickerDraggingSv) updatePickerFromSvPoint(point);
        else if (pickerDraggingHue) updatePickerFromHuePoint(point);
        else if (pickerDraggingAlpha) updatePickerFromAlphaPoint(point);
    }

    void finishPickerDrag() {
        if (!pickerDragging()) return;
        pickerDraggingSv = false;
        pickerDraggingHue = false;
        pickerDraggingAlpha = false;
        persistEditorPreferences();
        ReleaseCapture();
    }

    bool hitToolbarPanel(POINT p) const {
        return pointInRect(verticalPanelBounds, p) || pointInRect(horizontalPanelBounds, p);
    }

    void invalidateButton(int index) {
        if (const Button* button = buttonAtCombinedIndex(index)) invalidateRectPadded(button->rect, ui.panelPadding + 3);
    }

    void clearHover() {
        if (hoveredButton < 0 && tooltipButton < 0) return;
        const int oldHover = hoveredButton;
        const int oldTooltip = tooltipButton;
        hoveredButton = -1;
        tooltipButton = -1;
        KillTimer(hwnd, kHoverTimer);
        invalidateButton(oldHover);
        invalidateRectPadded(tooltipBoundsApprox(oldTooltip), 3);
    }

    void setHoveredButton(int next) {
        if (next == hoveredButton) return;
        const int oldHover = hoveredButton;
        const int oldTooltip = tooltipButton;
        KillTimer(hwnd, kHoverTimer);
        hoveredButton = next;
        tooltipButton = -1;
        invalidateButton(oldHover);
        invalidateButton(hoveredButton);
        invalidateRectPadded(tooltipBoundsApprox(oldTooltip), 3);
        if (hoveredButton >= 0) SetTimer(hwnd, kHoverTimer, static_cast<UINT>(ui.tooltipDelayMs), nullptr);
    }

    void armMouseLeaveTracking() {
        if (trackingMouseLeave) return;
        TRACKMOUSEEVENT event{};
        event.cbSize = sizeof(event);
        event.dwFlags = TME_LEAVE;
        event.hwndTrack = hwnd;
        trackingMouseLeave = TrackMouseEvent(&event) != FALSE;
    }

    int hitHandle(POINT p) const {
        for (int i = 0; i < 8; ++i) if (pointInRect(handleRects[i], p)) return i;
        return -1;
    }

    bool hitSelectionBorder(POINT p) const {
        constexpr int e = 5;
        RECT outer{selection.left - e, selection.top - e, selection.right + e, selection.bottom + e};
        RECT inner{selection.left + e, selection.top + e, selection.right - e, selection.bottom - e};
        return pointInRect(outer, p) && !pointInRect(inner, p);
    }

    void setTool(Tool value) {
        const RECT previousUi = uiBounds();
        const RECT previousPreview = brushPreviewRect;
        cancelColorFieldEdit();
        eyedropperActive = false;
        tool = value;
        paletteOpen = false;
        brushPreviewRect = brushPreviewBounds(cursorPoint);
        invalidateUiTransition(previousUi);
        invalidateRectPadded(previousPreview, 3);
        invalidateRectPadded(brushPreviewRect, 3);
        if (hwnd) {
            POINT cursor{};
            if (GetCursorPos(&cursor) && ScreenToClient(hwnd, &cursor)) updateCursor(cursor);
        }
    }

    Color annotationColor(bool marker = false) const {
        const BYTE alpha = marker ? static_cast<BYTE>(std::min<int>(colorAlpha, 96)) : colorAlpha;
        return toGdiColor(color, alpha);
    }

    std::unique_ptr<Bitmap> renderSelectionBitmap() {
        if (!hasSelection || rectWidth(selection) <= 0 || rectHeight(selection) <= 0) return {};
        // Screenshots are opaque. RGB avoids the zero-alpha semantics of GDI
        // writes into an ARGB GDI+ bitmap while the sparse monitor capture is
        // copied into this temporary crop.
        auto output = std::make_unique<Bitmap>(rectWidth(selection), rectHeight(selection), PixelFormat32bppRGB);
        Graphics g(output.get());
        g.Clear(Color(255, 0, 0, 0));
        HDC outputDc = g.GetHDC();
        if (!outputDc) return {};
        const bool copied = capture.blitTo(outputDc, 0, 0, selection);
        g.ReleaseHDC(outputDc);
        if (!copied) return {};

        g.SetSmoothingMode(SmoothingModeAntiAlias);
        g.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
        const Rect destination(0, 0, rectWidth(selection), rectHeight(selection));
        g.SetClip(destination);
        // Annotations live in virtual-desktop coordinates. Selection is only a
        // crop rectangle, so moving/resizing it never mutates drawing data.
        for (const auto& annotation : annotations)
            drawAnnotation(g, annotation, static_cast<float>(-selection.left), static_cast<float>(-selection.top));
        return output;
    }

    void doCopy() {
        commitTextEdit();
        auto image = renderSelectionBitmap();
        if (!image || !copyBitmapToClipboard(hwnd, *image)) {
            MessageBoxW(hwnd, L"Could not copy the screenshot to the clipboard.", L"NightShot", MB_ICONERROR);
            return;
        }

        if (notificationTarget && IsWindow(notificationTarget)) {
            PostMessageW(notificationTarget, WM_NIGHTSHOT_SCREENSHOT_COPIED, 0, 0);
        }
        DestroyWindow(hwnd);
    }

    void doUpload() {
        commitTextEdit();
        const settings::AppSettings configuration = settings::load();
        if (configuration.uploadUrl.empty()) {
            MessageBoxW(hwnd,
                        L"Сначала укажи URL API-сервера: ПКМ по иконке NightShot в трее → Настройки.",
                        L"NightShot — загрузка", MB_OK | MB_ICONINFORMATION);
            return;
        }

        auto image = renderSelectionBitmap();
        if (!image) return;

        std::vector<BYTE> png;
        if (!encodeBitmapAsPng(*image, png)) {
            MessageBoxW(hwnd, L"Не удалось подготовить PNG для загрузки.",
                        L"NightShot — загрузка", MB_OK | MB_ICONERROR);
            return;
        }

        if (!uploader::start(notificationTarget, std::move(png), configuration)) {
            MessageBoxW(hwnd, L"Не удалось запустить фоновую загрузку.",
                        L"NightShot — загрузка", MB_OK | MB_ICONERROR);
            return;
        }

        if (configuration.closeEditorAfterUpload) DestroyWindow(hwnd);
    }

    void beginGifRecording(const gif_recorder::Options& options) {
        commitTextEdit();
        if (!hasSelection || !notificationTarget || !IsWindow(notificationTarget)) return;

        auto* request = new gif_recorder::StartRequest();
        request->screenRect = RECT{
            capture.x + selection.left, capture.y + selection.top,
            capture.x + selection.right, capture.y + selection.bottom};
        request->options = options;
        request->notificationTarget = notificationTarget;
        if (!PostMessageW(notificationTarget, WM_NIGHTSHOT_BEGIN_GIF, 0,
                          reinterpret_cast<LPARAM>(request))) {
            delete request;
            MessageBoxW(hwnd, L"Не удалось передать область в GIF-рекордер.",
                        L"NightShot — GIF", MB_OK | MB_ICONERROR);
            return;
        }
        DestroyWindow(hwnd);
    }

    void doGif() {
        const settings::AppSettings configuration = settings::load();
        gif_recorder::Options options;
        if (!gif_options_window::show(hwnd, configuration, options)) return;
        beginGifRecording(options);
    }

    void doQuickGif() {
        const settings::AppSettings configuration = settings::load();
        gif_recorder::Options options;
        options.fps = configuration.gifFps;
        options.quality = configuration.gifQuality;
        options.durationSeconds = 0;
        options.hardLimitSeconds = configuration.gifMaxDurationSeconds;
        options.captureCursor = configuration.gifCaptureCursor;
        beginGifRecording(options);
    }

    void doSave() {
        commitTextEdit();
        auto image = renderSelectionBitmap();
        if (!image) return;
        const settings::AppSettings configuration = settings::load();
        std::wstring path;
        if (!saveScreenshotIncremented(*image, configuration, path)) {
            MessageBoxW(hwnd, L"Не удалось сохранить снимок в выбранную папку.",
                        L"NightShot — сохранение", MB_OK | MB_ICONERROR);
            return;
        }
        if (notificationTarget && IsWindow(notificationTarget)) {
            auto* savedPath = new std::wstring(std::move(path));
            if (!PostMessageW(notificationTarget, WM_NIGHTSHOT_SCREENSHOT_SAVED, 0,
                              reinterpret_cast<LPARAM>(savedPath))) {
                delete savedPath;
            }
        }
        DestroyWindow(hwnd);
    }

    void doPrint() {
        commitTextEdit();
        auto image = renderSelectionBitmap();
        if (!image) return;
        const PrintBitmapResult result = printBitmap(hwnd, *image);
        if (result == PrintBitmapResult::Printed) DestroyWindow(hwnd);
        else if (result == PrintBitmapResult::Failed)
            MessageBoxW(hwnd, L"Could not print the screenshot.", L"NightShot", MB_ICONERROR);
    }

    void execute(Action action) {
        if (isToolAction(action)) {
            setTool(toolFromAction(action));
            return;
        }
        switch (action) {
            case Action::Color: {
                commitTextEdit();
                const RECT previousUi = uiBounds();
                const RECT previousPreview = brushPreviewRect;
                cancelColorFieldEdit();
                eyedropperActive = false;
                syncPickerFromRgb();
                paletteOpen = !paletteOpen;
                updateLayout();
                brushPreviewRect = brushPreviewBounds(cursorPoint);
                invalidateUiTransition(previousUi);
                invalidateRectPadded(previousPreview, 3);
                invalidateRectPadded(brushPreviewRect, 3);
                break;
            }
            case Action::Undo:
                commitTextEdit();
                if (!annotations.empty()) {
                    const RECT dirty = annotationBounds(annotations.back());
                    annotations.pop_back();
                    invalidateRectPadded(dirty, 2);
                    if (annotations.empty()) invalidateButton(8);
                }
                break;
            case Action::Upload: doUpload(); break;
            case Action::Share:
                MessageBoxW(hwnd, L"Share requires an uploaded screenshot URL. Connect an uploader first.",
                            L"Share endpoint not configured", MB_OK | MB_ICONINFORMATION);
                break;
            case Action::Search:
                MessageBoxW(hwnd, L"Reverse image search requires an upload/search provider. The UI hook is ready.",
                            L"Search provider not configured", MB_OK | MB_ICONINFORMATION);
                break;
            case Action::Gif: doGif(); break;
            case Action::Print: doPrint(); break;
            case Action::Copy: doCopy(); break;
            case Action::Save: doSave(); break;
            case Action::Close: DestroyWindow(hwnd); break;
            default: break;
        }
    }

    void drawToolbarContainer(Graphics& g, const std::vector<Button>& buttons) {
        if (buttons.empty()) return;
        RECT bounds = buttons.front().rect;
        for (const Button& button : buttons) {
            bounds.left = std::min(bounds.left, button.rect.left);
            bounds.top = std::min(bounds.top, button.rect.top);
            bounds.right = std::max(bounds.right, button.rect.right);
            bounds.bottom = std::max(bounds.bottom, button.rect.bottom);
        }
        const float pad = static_cast<float>(ui.panelPadding);
        RectF shadow(static_cast<REAL>(bounds.left) - pad + 1.0f,
                     static_cast<REAL>(bounds.top) - pad + 2.0f,
                     static_cast<REAL>(rectWidth(bounds)) + pad * 2.0f,
                     static_cast<REAL>(rectHeight(bounds)) + pad * 2.0f);
        SolidBrush shadowBrush(Color(58, 0, 0, 0));
        fillRoundedRect(g, shadow, static_cast<float>(ui.radius + 3), shadowBrush);

        RectF panel(static_cast<REAL>(bounds.left) - pad,
                    static_cast<REAL>(bounds.top) - pad,
                    static_cast<REAL>(rectWidth(bounds)) + pad * 2.0f,
                    static_cast<REAL>(rectHeight(bounds)) + pad * 2.0f);
        fillRoundedGradient(g, panel, static_cast<float>(ui.radius + 3),
                            toGdiColor(theme::kPanelTop, 248),
                            toGdiColor(theme::kPanelBottom, 248));
        Pen border(toGdiColor(theme::kBorder, 225), 1.0f);
        strokeRoundedRect(g, panel, static_cast<float>(ui.radius + 3), border);
    }

    void drawButton(Graphics& g, const Button& button, bool hovered) {
        const bool enabled = buttonEnabled(button.action);
        const bool active = enabled && ((button.action == Action::Drag && tool == Tool::Drag) ||
                            (button.action == Action::Pen && tool == Tool::Pen) ||
                            (button.action == Action::Line && tool == Tool::Line) ||
                            (button.action == Action::Arrow && tool == Tool::Arrow) ||
                            (button.action == Action::Rectangle && tool == Tool::Rectangle) ||
                            (button.action == Action::Marker && tool == Tool::Marker) ||
                            (button.action == Action::Text && tool == Tool::Text) ||
                            (button.action == Action::Color && paletteOpen));
        const RectF r(static_cast<REAL>(button.rect.left), static_cast<REAL>(button.rect.top),
                      static_cast<REAL>(rectWidth(button.rect)), static_cast<REAL>(rectHeight(button.rect)));

        if (active) {
            fillRoundedGradient(g, r, static_cast<float>(ui.radius),
                                toGdiColor(theme::kAccent),
                                toGdiColor(theme::kAccentEnd),
                                LinearGradientModeForwardDiagonal);
            Pen activeBorder(Color(125, 255, 255, 255), 1.0f);
            strokeRoundedRect(g, r, static_cast<float>(ui.radius), activeBorder);
        } else if (hovered && enabled) {
            RectF hoverRect(r.X + 1.0f, r.Y + 1.0f, r.Width - 2.0f, r.Height - 2.0f);
            const COLORREF hoverColor = button.action == Action::Close ? RGB(103, 42, 54) : theme::kPanelHover;
            SolidBrush hoverBrush(toGdiColor(hoverColor, 205));
            fillRoundedRect(g, hoverRect, static_cast<float>(std::max(4, ui.radius - 1)), hoverBrush);
            Pen hoverBorder(toGdiColor(button.action == Action::Close ? RGB(154, 68, 82) : theme::kBorder, 205), 1.0f);
            strokeRoundedRect(g, hoverRect, static_cast<float>(std::max(4, ui.radius - 1)), hoverBorder);
        }

        const Color iconColor = !enabled ? toGdiColor(theme::kMuted, 105)
                              : active ? Color(255, 255, 255, 255)
                              : toGdiColor(theme::kText, 238);
        const float iconSize = static_cast<float>(ui.icon);
        const RectF iconRect(
            r.X + (r.Width - iconSize) * 0.5f,
            r.Y + (r.Height - iconSize) * 0.5f,
            iconSize,
            iconSize);
        drawUiIcon(g, iconForAction(button.action), iconRect, iconColor, color);

        if (button.action == Action::Color) {
            const float indicatorWidth = std::max(8.0f, iconSize * 0.58f);
            const float indicatorHeight = std::max(2.0f, std::round(iconSize * 0.14f));
            RectF indicator(r.X + (r.Width - indicatorWidth) * 0.5f,
                            r.GetBottom() - indicatorHeight - std::max(3.0f, r.Height * 0.09f),
                            indicatorWidth, indicatorHeight);
            SolidBrush selectedBrush(toGdiColor(color));
            fillRoundedRect(g, indicator, indicatorHeight * 0.5f, selectedBrush);
            if (GetRValue(color) < 45 && GetGValue(color) < 45 && GetBValue(color) < 45) {
                Pen indicatorBorder(Color(160, 255, 255, 255), 1.0f);
                strokeRoundedRect(g, indicator, indicatorHeight * 0.5f, indicatorBorder);
            }
        }
    }

    void drawCheckerboard(Graphics& g, const RECT& rectangle, int cell) const {
        if (rectangle.right <= rectangle.left || rectangle.bottom <= rectangle.top) return;

        // RECT coordinates are LONG in WinAPI. Keep all checkerboard geometry in
        // the same type so MinGW does not have to deduce std::min(int, LONG).
        const LONG cellSize = std::max<LONG>(2L, static_cast<LONG>(cell));
        SolidBrush first(Color(255, 224, 224, 232));
        SolidBrush second(Color(255, 172, 172, 184));
        for (LONG y = rectangle.top; y < rectangle.bottom; y += cellSize) {
            for (LONG x = rectangle.left; x < rectangle.right; x += cellSize) {
                const LONG row = (y - rectangle.top) / cellSize;
                const LONG column = (x - rectangle.left) / cellSize;
                const LONG blockWidth = std::min<LONG>(cellSize, rectangle.right - x);
                const LONG blockHeight = std::min<LONG>(cellSize, rectangle.bottom - y);
                const RectF block(static_cast<REAL>(x), static_cast<REAL>(y),
                                  static_cast<REAL>(blockWidth),
                                  static_cast<REAL>(blockHeight));
                g.FillRectangle(((row + column) & 1L) ? &first : &second, block);
            }
        }
    }

    void drawPickerField(Graphics& g, const RECT& rectangle, ColorField field,
                         const Font& labelFont, const Font& valueFont) const {
        if (rectangle.right <= rectangle.left || rectangle.bottom <= rectangle.top) return;
        const bool active = field == activeColorField;
        const RectF bounds(static_cast<REAL>(rectangle.left), static_cast<REAL>(rectangle.top),
                           static_cast<REAL>(rectWidth(rectangle)), static_cast<REAL>(rectHeight(rectangle)));
        SolidBrush fill(toGdiColor(active ? RGB(42, 49, 72) : RGB(27, 27, 38), 248));
        fillRoundedRect(g, bounds, std::max(4.0f, static_cast<float>(ui.radius) * 0.75f), fill);
        Pen border(toGdiColor(active ? theme::kAccentHover : theme::kBorder, active ? 245 : 210), 1.0f);
        strokeRoundedRect(g, bounds, std::max(4.0f, static_cast<float>(ui.radius) * 0.75f), border);

        const float labelWidth = field == ColorField::Hex ? std::max(30.0f, bounds.Width * 0.19f)
                                                          : std::max(16.0f, bounds.Width * 0.25f);
        RectF labelArea(bounds.X + 5.0f, bounds.Y, labelWidth, bounds.Height);
        RectF valueArea(bounds.X + labelWidth, bounds.Y,
                        std::max(1.0f, bounds.Width - labelWidth - 5.0f), bounds.Height);
        SolidBrush labelBrush(toGdiColor(theme::kMuted));
        SolidBrush valueBrush(toGdiColor(theme::kText));
        StringFormat labelFormat;
        labelFormat.SetAlignment(StringAlignmentNear);
        labelFormat.SetLineAlignment(StringAlignmentCenter);
        StringFormat valueFormat;
        valueFormat.SetAlignment(field == ColorField::Hex ? StringAlignmentNear : StringAlignmentFar);
        valueFormat.SetLineAlignment(StringAlignmentCenter);
        const std::wstring value = active ? colorFieldBuffer : colorFieldValue(field);
        g.DrawString(colorFieldLabel(field), -1, &labelFont, labelArea, &labelFormat, &labelBrush);
        g.DrawString(value.c_str(), -1, &valueFont, valueArea, &valueFormat, &valueBrush);

        if (active) {
            RectF measured{};
            g.MeasureString(value.c_str(), -1, &valueFont, valueArea, &valueFormat, &measured);
            const REAL caretX = std::clamp(measured.GetRight() + 1.0f,
                                           valueArea.X + 1.0f, valueArea.GetRight() - 2.0f);
            Pen caret(toGdiColor(theme::kText), 1.0f);
            g.DrawLine(&caret, caretX, bounds.Y + 6.0f, caretX, bounds.GetBottom() - 6.0f);
        }
    }

    void drawPalette(Graphics& g) {
        if (!paletteOpen) return;
        const RECT panelRect = palettePanelBounds;
        const int monitorIndex = monitorIndexForPoint(POINT{panelRect.left, panelRect.top});
        const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.72f, 2.25f);
        const GraphicsState state = g.Save();
        g.SetSmoothingMode(SmoothingModeAntiAlias);
        g.SetPixelOffsetMode(PixelOffsetModeHalf);
        g.SetTextRenderingHint(TextRenderingHintClearTypeGridFit);

        RectF shadow(static_cast<REAL>(panelRect.left + 1), static_cast<REAL>(panelRect.top + 2),
                     static_cast<REAL>(rectWidth(panelRect)), static_cast<REAL>(rectHeight(panelRect)));
        SolidBrush shadowBrush(Color(72, 0, 0, 0));
        fillRoundedRect(g, shadow, static_cast<float>(ui.radius + 4), shadowBrush);

        RectF panel(static_cast<REAL>(panelRect.left), static_cast<REAL>(panelRect.top),
                    static_cast<REAL>(rectWidth(panelRect)), static_cast<REAL>(rectHeight(panelRect)));
        fillRoundedGradient(g, panel, static_cast<float>(ui.radius + 4),
                            toGdiColor(theme::kPanelTop, 252),
                            toGdiColor(theme::kPanelBottom, 252));
        Pen panelBorder(toGdiColor(theme::kBorder, 235), 1.0f);
        strokeRoundedRect(g, panel, static_cast<float>(ui.radius + 4), panelBorder);

        // Current RGBA preview.
        drawCheckerboard(g, pickerPreviewRect, std::max(3, static_cast<int>(std::lround(5.0f * scale))));
        RectF preview(static_cast<REAL>(pickerPreviewRect.left), static_cast<REAL>(pickerPreviewRect.top),
                      static_cast<REAL>(rectWidth(pickerPreviewRect)), static_cast<REAL>(rectHeight(pickerPreviewRect)));
        SolidBrush previewColor(Color(colorAlpha, GetRValue(color), GetGValue(color), GetBValue(color)));
        g.FillRectangle(&previewColor, preview);
        Pen previewBorder(Color(180, 255, 255, 255), 1.0f);
        strokeRoundedRect(g, preview, std::max(4.0f, 5.0f * scale), previewBorder);

        // Eyedropper button.
        RectF eyedropper(static_cast<REAL>(pickerEyedropperRect.left), static_cast<REAL>(pickerEyedropperRect.top),
                         static_cast<REAL>(rectWidth(pickerEyedropperRect)), static_cast<REAL>(rectHeight(pickerEyedropperRect)));
        SolidBrush eyedropperFill(toGdiColor(eyedropperActive ? theme::kPanelActive : RGB(30, 30, 42), 250));
        fillRoundedRect(g, eyedropper, std::max(4.0f, 5.0f * scale), eyedropperFill);
        Pen eyedropperBorder(toGdiColor(eyedropperActive ? theme::kAccentHover : theme::kBorder, 230), 1.0f);
        strokeRoundedRect(g, eyedropper, std::max(4.0f, 5.0f * scale), eyedropperBorder);
        const float dropperSize = std::min(eyedropper.Width, eyedropper.Height) * 0.64f;
        drawUiIcon(g, UiIcon::Colors,
                   RectF(eyedropper.X + (eyedropper.Width - dropperSize) * 0.5f,
                         eyedropper.Y + (eyedropper.Height - dropperSize) * 0.5f,
                         dropperSize, dropperSize),
                   toGdiColor(theme::kText), color);

        // Saturation/value square.
        const RectF sv(static_cast<REAL>(pickerSvRect.left), static_cast<REAL>(pickerSvRect.top),
                       static_cast<REAL>(rectWidth(pickerSvRect)), static_cast<REAL>(rectHeight(pickerSvRect)));
        SolidBrush hueBase(toGdiColor(color_picker_math::hsvToRgb(pickerHsv.h, 1.0f, 1.0f)));
        g.FillRectangle(&hueBase, sv);
        LinearGradientBrush whiteOverlay(sv, Color(255, 255, 255, 255), Color(0, 255, 255, 255),
                                         LinearGradientModeHorizontal);
        g.FillRectangle(&whiteOverlay, sv);
        LinearGradientBrush blackOverlay(sv, Color(0, 0, 0, 0), Color(255, 0, 0, 0),
                                         LinearGradientModeVertical);
        g.FillRectangle(&blackOverlay, sv);
        Pen areaBorder(Color(190, 255, 255, 255), 1.0f);
        g.DrawRectangle(&areaBorder, sv);
        const REAL svX = sv.X + pickerHsv.s * std::max(1.0f, sv.Width - 1.0f);
        const REAL svY = sv.Y + (1.0f - pickerHsv.v) * std::max(1.0f, sv.Height - 1.0f);
        Pen markerShadow(Color(210, 0, 0, 0), std::max(3.0f, 3.0f * scale));
        Pen markerLight(Color(255, 255, 255, 255), std::max(1.0f, 1.2f * scale));
        g.DrawEllipse(&markerShadow, svX - 5.0f * scale, svY - 5.0f * scale, 10.0f * scale, 10.0f * scale);
        g.DrawEllipse(&markerLight, svX - 5.0f * scale, svY - 5.0f * scale, 10.0f * scale, 10.0f * scale);

        // Hue strip.
        constexpr std::array<float, 7> hueStops{0.0f, 60.0f, 120.0f, 180.0f, 240.0f, 300.0f, 360.0f};
        for (std::size_t i = 0; i + 1 < hueStops.size(); ++i) {
            const REAL top = static_cast<REAL>(pickerHueRect.top) +
                             static_cast<REAL>(rectHeight(pickerHueRect)) * static_cast<REAL>(i) / 6.0f;
            const REAL bottom = static_cast<REAL>(pickerHueRect.top) +
                                static_cast<REAL>(rectHeight(pickerHueRect)) * static_cast<REAL>(i + 1) / 6.0f;
            RectF segment(static_cast<REAL>(pickerHueRect.left), top,
                          static_cast<REAL>(rectWidth(pickerHueRect)), std::max(1.0f, bottom - top));
            LinearGradientBrush hueBrush(segment,
                                         toGdiColor(color_picker_math::hsvToRgb(hueStops[i], 1.0f, 1.0f)),
                                         toGdiColor(color_picker_math::hsvToRgb(std::fmod(hueStops[i + 1], 360.0f), 1.0f, 1.0f)),
                                         LinearGradientModeVertical);
            g.FillRectangle(&hueBrush, segment);
        }
        const RectF hueBounds(static_cast<REAL>(pickerHueRect.left), static_cast<REAL>(pickerHueRect.top),
                              static_cast<REAL>(rectWidth(pickerHueRect)), static_cast<REAL>(rectHeight(pickerHueRect)));
        g.DrawRectangle(&areaBorder, hueBounds);
        const REAL hueY = hueBounds.Y + (pickerHsv.h / 360.0f) * std::max(1.0f, hueBounds.Height - 1.0f);
        Pen sliderShadow(Color(220, 0, 0, 0), std::max(3.0f, 3.0f * scale));
        Pen sliderLight(Color(255, 255, 255, 255), std::max(1.0f, 1.0f * scale));
        g.DrawLine(&sliderShadow, hueBounds.X - 2.0f, hueY, hueBounds.GetRight() + 2.0f, hueY);
        g.DrawLine(&sliderLight, hueBounds.X - 2.0f, hueY, hueBounds.GetRight() + 2.0f, hueY);

        // Alpha strip.
        drawCheckerboard(g, pickerAlphaRect, std::max(2, static_cast<int>(std::lround(4.0f * scale))));
        const RectF alphaBounds(static_cast<REAL>(pickerAlphaRect.left), static_cast<REAL>(pickerAlphaRect.top),
                                static_cast<REAL>(rectWidth(pickerAlphaRect)), static_cast<REAL>(rectHeight(pickerAlphaRect)));
        LinearGradientBrush alphaBrush(alphaBounds,
                                       Color(255, GetRValue(color), GetGValue(color), GetBValue(color)),
                                       Color(0, GetRValue(color), GetGValue(color), GetBValue(color)),
                                       LinearGradientModeVertical);
        g.FillRectangle(&alphaBrush, alphaBounds);
        g.DrawRectangle(&areaBorder, alphaBounds);
        const REAL alphaY = alphaBounds.Y + (1.0f - static_cast<float>(colorAlpha) / 255.0f) *
                            std::max(1.0f, alphaBounds.Height - 1.0f);
        g.DrawLine(&sliderShadow, alphaBounds.X - 2.0f, alphaY, alphaBounds.GetRight() + 2.0f, alphaY);
        g.DrawLine(&sliderLight, alphaBounds.X - 2.0f, alphaY, alphaBounds.GetRight() + 2.0f, alphaY);

        FontFamily family(L"Segoe UI");
        Font labelFont(&family, static_cast<REAL>(std::max(9, static_cast<int>(std::lround(9.5f * scale)))),
                       FontStyleRegular, UnitPixel);
        Font valueFont(&family, static_cast<REAL>(std::max(10, static_cast<int>(std::lround(11.0f * scale)))),
                       FontStyleRegular, UnitPixel);
        for (int i = 0; i < 8; ++i) {
            drawPickerField(g, pickerFieldRects[i], fieldForIndex(i), labelFont, valueFont);
        }

        // 8x6 persistent saved-color grid. Empty cells have a subtle plus.
        for (std::size_t i = 0; i < settings::kSavedColorCount; ++i) {
            const RECT& rectangle = paletteRects[i];
            if (rectangle.right <= rectangle.left || rectangle.bottom <= rectangle.top) continue;
            const RectF swatch(static_cast<REAL>(rectangle.left), static_cast<REAL>(rectangle.top),
                               static_cast<REAL>(rectWidth(rectangle)), static_cast<REAL>(rectHeight(rectangle)));
            if (savedPaletteOccupied[i]) {
                const COLORREF slotColor = color_picker_math::colorFromArgb(savedPalette[i]);
                const BYTE slotAlpha = color_picker_math::alphaFromArgb(savedPalette[i]);
                drawCheckerboard(g, rectangle, std::max(2, pickerPaletteSwatch / 4));
                SolidBrush slotBrush(Color(slotAlpha, GetRValue(slotColor), GetGValue(slotColor), GetBValue(slotColor)));
                fillRoundedRect(g, swatch, std::max(3.0f, static_cast<float>(pickerPaletteSwatch) * 0.22f), slotBrush);
                const bool selected = savedPalette[i] == currentArgb();
                Pen slotBorder(selected ? toGdiColor(theme::kAccentHover) : Color(145, 255, 255, 255),
                               selected ? std::max(2.0f, 1.5f * scale) : 1.0f);
                strokeRoundedRect(g, swatch, std::max(3.0f, static_cast<float>(pickerPaletteSwatch) * 0.22f), slotBorder);
            } else {
                SolidBrush emptyFill(toGdiColor(RGB(31, 31, 43), 220));
                fillRoundedRect(g, swatch, std::max(3.0f, static_cast<float>(pickerPaletteSwatch) * 0.22f), emptyFill);
                Pen emptyBorder(toGdiColor(theme::kBorder, 165), 1.0f);
                strokeRoundedRect(g, swatch, std::max(3.0f, static_cast<float>(pickerPaletteSwatch) * 0.22f), emptyBorder);
                Pen plus(toGdiColor(theme::kMuted, 175), 1.0f);
                const REAL centerX = swatch.X + swatch.Width * 0.5f;
                const REAL centerY = swatch.Y + swatch.Height * 0.5f;
                const REAL arm = std::max(2.0f, swatch.Width * 0.18f);
                g.DrawLine(&plus, centerX - arm, centerY, centerX + arm, centerY);
                g.DrawLine(&plus, centerX, centerY - arm, centerX, centerY + arm);
            }
        }
        g.Restore(state);
    }

    std::vector<RECT> collectUpdateRects() const {
        std::vector<RECT> result;
        HRGN region = CreateRectRgn(0, 0, 0, 0);
        if (!region) return result;
        const int type = GetUpdateRgn(hwnd, region, FALSE);
        if (type == NULLREGION || type == ERROR) {
            DeleteObject(region);
            return result;
        }
        const DWORD bytes = GetRegionData(region, 0, nullptr);
        if (bytes >= sizeof(RGNDATAHEADER)) {
            std::vector<std::uint8_t> storage(bytes);
            auto* data = reinterpret_cast<RGNDATA*>(storage.data());
            if (GetRegionData(region, bytes, data) == bytes) {
                const auto* rects = reinterpret_cast<const RECT*>(data->Buffer);
                result.assign(rects, rects + data->rdh.nCount);
            }
        }
        DeleteObject(region);

        if (result.size() > 64) {
            // RECT coordinates are LONG. Keep the whole grid calculation LONG
            // as well; mixing LONG with int makes std::max/std::min ambiguous
            // under MinGW-w64 (where LONG is long, not int).
            constexpr LONG grid = 128L;
            const LONG clientWidth = static_cast<LONG>(capture.width);
            const LONG clientHeight = static_cast<LONG>(capture.height);
            std::unordered_set<std::uint64_t> occupied;
            std::vector<RECT> coarse;
            for (RECT rect : result) {
                rect = clampToClient(rect);
                if (rect.right <= rect.left || rect.bottom <= rect.top) continue;
                const LONG firstX = rect.left / grid;
                const LONG lastX = std::max(firstX, (rect.right - 1L) / grid);
                const LONG firstY = rect.top / grid;
                const LONG lastY = std::max(firstY, (rect.bottom - 1L) / grid);
                for (LONG y = firstY; y <= lastY; ++y) {
                    for (LONG x = firstX; x <= lastX; ++x) {
                        const std::uint64_t key = (static_cast<std::uint64_t>(static_cast<std::uint32_t>(y)) << 32) |
                                                  static_cast<std::uint32_t>(x);
                        if (!occupied.insert(key).second) continue;
                        coarse.push_back(clampToClient(RECT{
                            x * grid,
                            y * grid,
                            std::min(clientWidth, (x + 1L) * grid),
                            std::min(clientHeight, (y + 1L) * grid)}));
                    }
                }
            }
            if (!coarse.empty() && coarse.size() <= 512) result = std::move(coarse);
        }
        return result;
    }

    static std::uint8_t dimChannel(std::uint8_t source, int tint) {
        // Equivalent to alpha-blending the old dark navy veil once, but done
        // directly in the dirty scratch tile instead of asking GDI+ to touch
        // the complete virtual desktop for every mouse move.
        return static_cast<std::uint8_t>((static_cast<int>(source) * 105 + tint * 150 + 127) / 255);
    }

    void dimScratchRect(const RECT& globalRect) {
        const int width = rectWidth(globalRect);
        const int height = rectHeight(globalRect);
        if (!scratchPixels || width <= 0 || height <= 0) return;

        RECT clear{0, 0, 0, 0};
        if ((hasSelection || selecting) && rectWidth(selection) > 0 && rectHeight(selection) > 0) {
            clear = intersectRects(globalRect, selection);
            if (clear.right > clear.left && clear.bottom > clear.top) {
                OffsetRect(&clear, -globalRect.left, -globalRect.top);
            }
        }

        auto dimRange = [&](std::uint8_t* row, int from, int to) {
            from = std::clamp(from, 0, width);
            to = std::clamp(to, 0, width);
            for (int x = from; x < to; ++x) {
                std::uint8_t* pixel = row + x * 4;
                pixel[0] = dimChannel(pixel[0], 14); // B
                pixel[1] = dimChannel(pixel[1], 8);  // G
                pixel[2] = dimChannel(pixel[2], 8);  // R
                pixel[3] = 255;
            }
        };

        for (int y = 0; y < height; ++y) {
            std::uint8_t* row = scratchPixels + y * scratchStride;
            if (clear.right > clear.left && y >= clear.top && y < clear.bottom) {
                dimRange(row, 0, clear.left);
                dimRange(row, clear.right, width);
            } else {
                dimRange(row, 0, width);
            }
        }
    }

    static float estimatedTextWidth(const std::wstring& text, float size) {
        if (text.empty()) return std::max(12.0f, size * 0.35f);
        return std::max(size * 0.6f, static_cast<float>(text.size()) * size * 0.62f);
    }

    void drawTextEditor(Graphics& g, RECT dirty) {
        if (!textEditing || !rectsIntersect(textEditorRect, dirty)) return;
        const int monitorIndex = monitorIndexForPoint(textAnchor);
        const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
        RectF box(static_cast<REAL>(textEditorRect.left), static_cast<REAL>(textEditorRect.top),
                  static_cast<REAL>(rectWidth(textEditorRect)), static_cast<REAL>(rectHeight(textEditorRect)));
        RectF shadow(box.X + 1.0f, box.Y + std::max(2.0f, 2.0f * scale), box.Width, box.Height);
        SolidBrush shadowBrush(Color(72, 0, 0, 0));
        fillRoundedRect(g, shadow, std::max(6.0f, 7.0f * scale), shadowBrush);
        fillRoundedGradient(g, box, std::max(6.0f, 7.0f * scale),
                            toGdiColor(theme::kPanelTop, 252),
                            toGdiColor(theme::kPanelBottom, 252));
        Pen border(toGdiColor(theme::kAccentHover, 235), std::max(1.0f, scale));
        strokeRoundedRect(g, box, std::max(6.0f, 7.0f * scale), border);

        const GraphicsState state = g.Save();
        g.SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
        g.SetTextContrast(0);
        g.SetPixelOffsetMode(PixelOffsetModeDefault);
        const int padX = std::max(7, static_cast<int>(std::lround(8.0f * scale)));
        const REAL originX = static_cast<REAL>(textEditorRect.left + padX);
        const REAL originY = static_cast<REAL>(textEditorRect.top + std::max(4, static_cast<int>(std::lround(5.0f * scale))));
        RectF textClip(originX, static_cast<REAL>(textEditorRect.top + 2),
                       static_cast<REAL>(std::max(1, rectWidth(textEditorRect) - padX * 2)),
                       static_cast<REAL>(std::max(1, rectHeight(textEditorRect) - 4)));
        g.SetClip(textClip, CombineModeIntersect);
        FontFamily family(L"Segoe UI");
        Font font(&family, std::round(textEditSize), FontStyleRegular, UnitPixel);
        SolidBrush brush(toGdiColor(color));
        StringFormat format;
        format.SetFormatFlags(StringFormatFlagsNoWrap | StringFormatFlagsMeasureTrailingSpaces);
        g.DrawString(textEditBuffer.c_str(), -1, &font, PointF(originX, originY), &format, &brush);

        RectF measured{};
        g.MeasureString(textEditBuffer.c_str(), -1, &font, PointF(originX, originY), &format, &measured);
        const REAL caretX = std::min<REAL>(static_cast<REAL>(textEditorRect.right - padX),
                                           std::max(originX, measured.GetRight() + 1.0f));
        Pen caret(toGdiColor(theme::kText), std::max(1.0f, scale));
        const REAL caretTop = originY + std::max(1.0f, textEditSize * 0.08f);
        const REAL caretBottom = std::min<REAL>(static_cast<REAL>(textEditorRect.bottom - 5),
                                                originY + textEditSize * 1.18f);
        g.DrawLine(&caret, caretX, caretTop, caretX, caretBottom);
        g.Restore(state);
    }

    void drawBrushPreview(Graphics& g, RECT dirty) {
        if (!hasSelection || selecting || draggingSelection || resizeHandle >= 0 ||
            paletteOpen || eyedropperActive || !isDrawingTool(tool) ||
            !rectsIntersect(brushPreviewRect, dirty)) return;

        const float diameter = std::max(1.0f, currentStrokeWidth());
        const float x = static_cast<float>(cursorPoint.x) - diameter * 0.5f;
        const float y = static_cast<float>(cursorPoint.y) - diameter * 0.5f;
        const GraphicsState state = g.Save();
        g.SetSmoothingMode(SmoothingModeAntiAlias);
        g.SetPixelOffsetMode(PixelOffsetModeHalf);

        // Preview is deliberately hollow: it represents the exact physical
        // brush diameter without covering the pixels the user is trying to aim
        // at. Keep the border at one physical pixel on every monitor.
        Pen border(toGdiColor(color, static_cast<BYTE>(std::max<int>(colorAlpha, 160))), 1.0f);
        g.DrawEllipse(&border, x, y, diameter, diameter);
        g.Restore(state);
    }

    void drawScene(Graphics& g, RECT dirty) {
        // Drawing is a virtual-desktop layer, independent from the crop. It is
        // intentionally visible even outside the selected rectangle and keeps
        // absolute coordinates while the selection moves or resizes.
        for (const auto& annotation : annotations) {
            drawAnnotationClipped(g, annotation, dirty);
        }

        if (hasSelection || selecting) {
            const RECT r = selection;

            const int borderPadding = std::max(10, ui.handle + 6);
            const std::array<RECT, 4> borderBands{{
                {r.left - borderPadding, r.top - borderPadding, r.right + borderPadding, r.top + borderPadding},
                {r.left - borderPadding, r.bottom - borderPadding, r.right + borderPadding, r.bottom + borderPadding},
                {r.left - borderPadding, r.top, r.left + borderPadding, r.bottom},
                {r.right - borderPadding, r.top, r.right + borderPadding, r.bottom}}};
            bool borderDirty = false;
            for (const RECT& band : borderBands) borderDirty = borderDirty || rectsIntersect(band, dirty);
            if (borderDirty) {
                Pen border(toGdiColor(theme::kSelectionBorder), 1.25f);
                REAL pattern[] = {4.0f, 4.0f};
                border.SetDashPattern(pattern, 2);
                g.DrawRectangle(&border, static_cast<REAL>(r.left), static_cast<REAL>(r.top),
                                static_cast<REAL>(std::max(0, rectWidth(r) - 1)),
                                static_cast<REAL>(std::max(0, rectHeight(r) - 1)));

                if (hasSelection && !selecting && tool == Tool::Drag) {
                    SolidBrush handleFill(toGdiColor(theme::kAccentHover));
                    Pen handleBorder(Color(210, 255, 255, 255), 1.0f);
                    for (const RECT& handle : handleRects) {
                        if (!rectsIntersect(handle, dirty)) continue;
                        RectF handleRect(static_cast<REAL>(handle.left), static_cast<REAL>(handle.top),
                                         static_cast<REAL>(rectWidth(handle)), static_cast<REAL>(rectHeight(handle)));
                        fillRoundedRect(g, handleRect, std::max(2.0f, static_cast<float>(ui.handle) * 0.28f), handleFill);
                        strokeRoundedRect(g, handleRect, std::max(2.0f, static_cast<float>(ui.handle) * 0.28f), handleBorder);
                    }
                }
            }

            if (rectsIntersect(dimensionBadgeRect, dirty)) {
                const std::wstring dimensions = std::to_wstring(std::max(0, rectWidth(r))) + L" × " +
                                                std::to_wstring(std::max(0, rectHeight(r)));
                const int badgeMonitor = monitorIndexForPoint(POINT{r.left, r.top});
                const float scale = std::clamp(static_cast<float>(monitors[badgeMonitor].dpi) / 96.0f, 0.85f, 2.25f);
                FontFamily family(L"Segoe UI");
                Font font(&family, static_cast<REAL>(std::lround(12.5f * scale)), FontStyleRegular, UnitPixel);
                RectF badgeRect(static_cast<REAL>(dimensionBadgeRect.left), static_cast<REAL>(dimensionBadgeRect.top),
                                static_cast<REAL>(rectWidth(dimensionBadgeRect)), static_cast<REAL>(rectHeight(dimensionBadgeRect)));
                fillRoundedGradient(g, badgeRect, std::max(5.0f, 6.0f * scale),
                                    toGdiColor(theme::kPanelTop, 242),
                                    toGdiColor(theme::kPanelBottom, 242));
                Pen badgeBorder(toGdiColor(theme::kBorder, 225), 1.0f);
                strokeRoundedRect(g, badgeRect, std::max(5.0f, 6.0f * scale), badgeBorder);
                SolidBrush textBrush(toGdiColor(theme::kText));
                StringFormat format;
                format.SetAlignment(StringAlignmentCenter);
                format.SetLineAlignment(StringAlignmentCenter);
                g.DrawString(dimensions.c_str(), -1, &font, badgeRect, &format, &textBrush);
            }
        } else {
            const int monitorIndex = std::clamp(hintMonitorIndex, 0, static_cast<int>(monitors.size()) - 1);
            const RECT cardBounds = hintRectForMonitor(monitorIndex);
            if (rectsIntersect(cardBounds, dirty)) {
                const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
                FontFamily family(L"Segoe UI");
                Font title(&family, static_cast<REAL>(std::lround(18.0f * scale)), FontStyleBold, UnitPixel);
                Font subtitle(&family, static_cast<REAL>(std::lround(12.5f * scale)), FontStyleRegular, UnitPixel);
                RectF card(static_cast<REAL>(cardBounds.left), static_cast<REAL>(cardBounds.top),
                           static_cast<REAL>(rectWidth(cardBounds)), static_cast<REAL>(rectHeight(cardBounds)));
                RectF shadow(card.X + 1.0f, card.Y + 3.0f, card.Width, card.Height);
                SolidBrush shadowBrush(Color(68, 0, 0, 0));
                fillRoundedRect(g, shadow, 15.0f * scale, shadowBrush);
                fillRoundedGradient(g, card, 15.0f * scale,
                                    toGdiColor(theme::kPanelTop, 244),
                                    toGdiColor(theme::kPanelBottom, 244));
                Pen cardBorder(toGdiColor(theme::kBorder, 230), 1.0f);
                strokeRoundedRect(g, card, 15.0f * scale, cardBorder);

                StringFormat centered;
                centered.SetAlignment(StringAlignmentCenter);
                centered.SetLineAlignment(StringAlignmentCenter);
                SolidBrush titleBrush(toGdiColor(theme::kText));
                SolidBrush subBrush(toGdiColor(theme::kMuted));
                RectF titleArea(card.X, card.Y + 9.0f * scale, card.Width, 30.0f * scale);
                RectF subArea(card.X, card.Y + 39.0f * scale, card.Width, 22.0f * scale);
                g.DrawString(L"Select an area", -1, &title, titleArea, &centered, &titleBrush);
                g.DrawString(L"Drag the mouse to capture", -1, &subtitle, subArea, &centered, &subBrush);
            }
        }

        drawTextEditor(g, dirty);
        drawBrushPreview(g, dirty);

        if (hasSelection && !selecting && rectsIntersect(uiBounds(), dirty)) {
            if (rectsIntersect(toolbarBounds(verticalButtons), dirty)) {
                drawToolbarContainer(g, verticalButtons);
                for (size_t i = 0; i < verticalButtons.size(); ++i) {
                    RECT buttonPaint = verticalButtons[i].rect;
                    InflateRect(&buttonPaint, 2, 2);
                    if (rectsIntersect(buttonPaint, dirty))
                        drawButton(g, verticalButtons[i], hoveredButton == static_cast<int>(i));
                }
            }
            if (rectsIntersect(toolbarBounds(horizontalButtons), dirty)) {
                drawToolbarContainer(g, horizontalButtons);
                for (size_t i = 0; i < horizontalButtons.size(); ++i) {
                    RECT buttonPaint = horizontalButtons[i].rect;
                    InflateRect(&buttonPaint, 2, 2);
                    if (rectsIntersect(buttonPaint, dirty))
                        drawButton(g, horizontalButtons[i], hoveredButton == static_cast<int>(verticalButtons.size() + i));
                }
            }
            if (paletteOpen && rectsIntersect(palettePanelBounds, dirty)) drawPalette(g);

            if (tooltipButton >= 0) {
                const Button* hovered = buttonAtCombinedIndex(tooltipButton);
                if (hovered) {
                    const RECT tipBounds = tooltipBoundsApprox(tooltipButton);
                    if (rectsIntersect(tipBounds, dirty)) {
                        const std::wstring label = actionName(hovered->action);
                        POINT center{(hovered->rect.left + hovered->rect.right) / 2,
                                     (hovered->rect.top + hovered->rect.bottom) / 2};
                        const int monitorIndex = monitorIndexForPoint(center);
                        const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
                        FontFamily family(L"Segoe UI");
                        Font font(&family, static_cast<REAL>(std::lround(12.0f * scale)), FontStyleRegular, UnitPixel);
                        RectF tip(static_cast<REAL>(tipBounds.left), static_cast<REAL>(tipBounds.top),
                                  static_cast<REAL>(rectWidth(tipBounds)), static_cast<REAL>(rectHeight(tipBounds)));
                        fillRoundedGradient(g, tip, 6.0f * scale,
                                            toGdiColor(theme::kPanelTop, 246),
                                            toGdiColor(theme::kPanelBottom, 246));
                        Pen tipBorder(toGdiColor(theme::kBorder, 225), 1.0f);
                        strokeRoundedRect(g, tip, 6.0f * scale, tipBorder);
                        SolidBrush foreground(toGdiColor(theme::kText));
                        StringFormat centered;
                        centered.SetAlignment(StringAlignmentCenter);
                        centered.SetLineAlignment(StringAlignmentCenter);
                        g.DrawString(label.c_str(), -1, &font, tip, &centered, &foreground);
                    }
                }
            }
        }
    }

    void paintTile(HDC target, RECT tile) {
        tile = clampToClient(tile);
        const int width = rectWidth(tile);
        const int height = rectHeight(tile);
        if (width <= 0 || height <= 0 || !ensureScratchBuffer(target, width, height)) return;

        static_cast<void>(capture.blitTo(scratchDc, 0, 0, tile));
        dimScratchRect(tile);

        Graphics graphics(scratchDc);
        graphics.SetSmoothingMode(SmoothingModeAntiAlias);
        graphics.SetPixelOffsetMode(PixelOffsetModeHalf);
        graphics.SetCompositingQuality(CompositingQualityHighSpeed);
        graphics.SetInterpolationMode(InterpolationModeLowQuality);
        graphics.SetTextRenderingHint(TextRenderingHintClearTypeGridFit);
        graphics.SetTextContrast(0);
        graphics.SetClip(Rect(0, 0, width, height), CombineModeReplace);
        graphics.TranslateTransform(static_cast<REAL>(-tile.left), static_cast<REAL>(-tile.top));
        drawScene(graphics, tile);

        BitBlt(target, tile.left, tile.top, width, height, scratchDc, 0, 0, SRCCOPY);
    }

    void paint() {
        std::vector<RECT> dirtyRects = collectUpdateRects();
        PAINTSTRUCT paintStruct{};
        HDC target = BeginPaint(hwnd, &paintStruct);
        if (dirtyRects.empty() && paintStruct.rcPaint.right > paintStruct.rcPaint.left &&
            paintStruct.rcPaint.bottom > paintStruct.rcPaint.top) {
            dirtyRects.push_back(paintStruct.rcPaint);
        }

        for (RECT dirty : dirtyRects) {
            dirty = clampToClient(dirty);
            for (int top = dirty.top; top < dirty.bottom; top += kPaintTileHeight) {
                for (int left = dirty.left; left < dirty.right; left += kPaintTileWidth) {
                    RECT tile{left, top,
                              std::min(static_cast<int>(dirty.right), left + kPaintTileWidth),
                              std::min(static_cast<int>(dirty.bottom), top + kPaintTileHeight)};
                    paintTile(target, tile);
                }
            }
        }
        EndPaint(hwnd, &paintStruct);
    }

    void invalidateSegmentTiles(PointF start, PointF end, int padding) {
        const float dx = end.X - start.X;
        const float dy = end.Y - start.Y;
        const float length = std::sqrt(dx * dx + dy * dy);
        const int step = std::max(24, 48 - padding * 2);
        const int count = std::max(1, static_cast<int>(std::ceil(length / static_cast<float>(step))));
        const int radius = std::max(18, padding + 18);
        for (int i = 0; i <= count; ++i) {
            const float t = static_cast<float>(i) / static_cast<float>(count);
            const int x = static_cast<int>(std::lround(start.X + dx * t));
            const int y = static_cast<int>(std::lround(start.Y + dy * t));
            invalidateRectPadded(RECT{x - radius, y - radius, x + radius + 1, y + radius + 1}, 1);
        }
    }

    void invalidateRectangleOutline(PointF first, PointF second, int padding) {
        RECT rectangle{
            static_cast<LONG>(std::floor(std::min(first.X, second.X))),
            static_cast<LONG>(std::floor(std::min(first.Y, second.Y))),
            static_cast<LONG>(std::ceil(std::max(first.X, second.X))) + 1,
            static_cast<LONG>(std::ceil(std::max(first.Y, second.Y))) + 1};
        invalidateOutline(rectangle, std::max(4, padding));
    }

    void invalidateAnnotationShape(const Annotation& annotation) {
        if (annotation.points.empty()) return;
        const int padding = static_cast<int>(std::ceil(annotation.width * 0.5f)) + 4;
        if ((annotation.tool == Tool::Line || annotation.tool == Tool::Arrow) && annotation.points.size() >= 2) {
            invalidateSegmentTiles(annotation.points[0], annotation.points[1],
                                   padding + (annotation.tool == Tool::Arrow ? 30 : 0));
            if (annotation.tool == Tool::Arrow) {
                const PointF end = annotation.points[1];
                invalidateRectPadded(RECT{static_cast<LONG>(end.X) - 36, static_cast<LONG>(end.Y) - 36,
                                          static_cast<LONG>(end.X) + 37, static_cast<LONG>(end.Y) + 37}, 1);
            }
        } else if (annotation.tool == Tool::Rectangle && annotation.points.size() >= 2) {
            invalidateRectangleOutline(annotation.points[0], annotation.points[1], padding);
        } else {
            invalidateRectPadded(annotationBounds(annotation), 2);
        }
    }

    void beginAnnotation(POINT p) {
        if (!hasSelection || tool == Tool::Drag) return;
        p.x = std::clamp(p.x, 0L, static_cast<LONG>(capture.width - 1));
        p.y = std::clamp(p.y, 0L, static_cast<LONG>(capture.height - 1));
        if (tool == Tool::Text) {
            beginTextEdit(p);
            return;
        }
        const bool undoWasDisabled = annotations.empty();
        Annotation annotation;
        annotation.tool = tool;
        annotation.color = annotationColor(tool == Tool::Marker);
        annotation.width = currentStrokeWidth();
        annotation.points.push_back(PointF(static_cast<REAL>(p.x), static_cast<REAL>(p.y)));
        if (tool == Tool::Line || tool == Tool::Arrow || tool == Tool::Rectangle)
            annotation.points.push_back(annotation.points.front());
        annotations.push_back(std::move(annotation));
        drawing = true;
        if (undoWasDisabled) invalidateButton(8);
        SetCapture(hwnd);
    }

    void updateAnnotation(POINT p) {
        if (!drawing || annotations.empty()) return;
        p.x = std::clamp(p.x, 0L, static_cast<LONG>(capture.width - 1));
        p.y = std::clamp(p.y, 0L, static_cast<LONG>(capture.height - 1));
        Annotation& annotation = annotations.back();

        if (annotation.tool == Tool::Pen || annotation.tool == Tool::Marker) {
            const PointF previous = annotation.points.back();
            const PointF next(static_cast<REAL>(p.x), static_cast<REAL>(p.y));
            const float dx = previous.X - next.X;
            const float dy = previous.Y - next.Y;
            // Sampling every ~2 physical pixels keeps curves smooth while avoiding
            // thousands of nearly identical points on high-polling-rate mice.
            if (dx * dx + dy * dy < 4.0f) return;
            annotation.points.push_back(next);
            appendStrokeChunkBounds(annotation, previous, next);
            const int padding = static_cast<int>(std::ceil(annotation.width * 0.5f)) + 4;
            RECT segment{
                static_cast<LONG>(std::floor(std::min(previous.X, next.X))) - padding,
                static_cast<LONG>(std::floor(std::min(previous.Y, next.Y))) - padding,
                static_cast<LONG>(std::ceil(std::max(previous.X, next.X))) + padding + 1,
                static_cast<LONG>(std::ceil(std::max(previous.Y, next.Y))) + padding + 1};
            invalidateRectPadded(segment, 1);
            return;
        }

        if (annotation.points.size() < 2) return;
        const PointF next(static_cast<REAL>(p.x), static_cast<REAL>(p.y));
        if (annotation.points[1].X == next.X && annotation.points[1].Y == next.Y) return;

        Annotation previousShape = annotation;
        annotation.points[1] = next;
        invalidateAnnotationShape(previousShape);
        invalidateAnnotationShape(annotation);
    }

    void finishAnnotation() {
        if (!drawing) return;
        drawing = false;
        ReleaseCapture();
        if (!annotations.empty()) invalidateAnnotationShape(annotations.back());
    }

    void updateTextEditorRect() {
        if (!textEditing) return;
        const int monitorIndex = monitorIndexForPoint(textAnchor);
        const UiMetrics metrics = metricsForMonitor(monitorIndex);
        RECT safe = monitors[monitorIndex].workBounds;
        RECT insetSafe = safe;
        InflateRect(&insetSafe, -metrics.margin, -metrics.margin);
        if (rectWidth(insetSafe) >= 40 && rectHeight(insetSafe) >= 24) safe = insetSafe;
        if (rectWidth(safe) < 40 || rectHeight(safe) < 24) {
            textEditing = false;
            textEditorRect = RECT{0, 0, 0, 0};
            return;
        }
        const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
        const int padX = std::max(7, static_cast<int>(std::lround(8.0f * scale)));
        const int padY = std::max(5, static_cast<int>(std::lround(6.0f * scale)));
        const int minimumWidth = static_cast<int>(std::lround(140.0f * scale));
        const int desiredWidth = static_cast<int>(std::lround(320.0f * scale));
        const int contentWidth = static_cast<int>(std::ceil(estimatedTextWidth(textEditBuffer, textEditSize))) + padX * 2 + 12;
        int width = std::clamp(std::max(minimumWidth, contentWidth), minimumWidth, desiredWidth);
        const int height = std::max(static_cast<int>(std::lround(40.0f * scale)),
                                    static_cast<int>(std::ceil(textEditSize * 1.35f)) + padY * 2);
        int left = textAnchor.x - padX;
        int top = textAnchor.y - padY;
        if (left + width > safe.right) left = safe.right - width;
        if (top + height > safe.bottom) top = safe.bottom - height;
        left = std::max(left, static_cast<int>(safe.left));
        top = std::max(top, static_cast<int>(safe.top));
        width = std::max(40, std::min(width, static_cast<int>(safe.right) - left));
        const int finalHeight = std::max(24, std::min(height, static_cast<int>(safe.bottom) - top));
        textEditorRect = RECT{left, top, left + width, top + finalHeight};
    }

    void beginTextEdit(POINT p) {
        commitTextEdit();
        const int monitorIndex = monitorIndexForPoint(p);
        const UiMetrics metrics = metricsForMonitor(monitorIndex);
        RECT available = monitors[monitorIndex].workBounds;
        InflateRect(&available, -metrics.margin, -metrics.margin);
        if (rectWidth(available) < 50 || rectHeight(available) < 32) return;

        const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
        textEditSize = static_cast<float>(std::max(18, static_cast<int>(std::lround(22.0f * scale))));
        textAnchor = POINT{std::clamp(p.x, available.left, available.right - 1),
                           std::clamp(p.y, available.top, available.bottom - 1)};
        textEditBuffer.clear();
        textEditing = true;
        updateTextEditorRect();
        invalidateRectPadded(textEditorRect, 4);
        SetFocus(hwnd);
    }

    void closeTextEdit(bool commit) {
        if (!textEditing) return;
        const RECT previousEditor = textEditorRect;
        bool addedAnnotation = false;
        RECT addedBounds{0, 0, 0, 0};
        const bool undoWasDisabled = annotations.empty();
        if (commit && !textEditBuffer.empty()) {
            Annotation annotation;
            annotation.tool = Tool::Text;
            annotation.color = annotationColor();
            annotation.width = 1.0f;
            annotation.textSize = textEditSize;
            const int monitorIndex = monitorIndexForPoint(textAnchor);
            const float scale = std::clamp(static_cast<float>(monitors[monitorIndex].dpi) / 96.0f, 0.85f, 2.25f);
            const int padX = std::max(7, static_cast<int>(std::lround(8.0f * scale)));
            const int padY = std::max(5, static_cast<int>(std::lround(6.0f * scale)));
            annotation.points.emplace_back(static_cast<REAL>(textEditorRect.left + padX),
                                           static_cast<REAL>(textEditorRect.top + padY));
            annotation.text = textEditBuffer;
            annotations.push_back(std::move(annotation));
            addedBounds = annotationBounds(annotations.back());
            addedAnnotation = true;
        }
        textEditing = false;
        textEditBuffer.clear();
        textEditorRect = RECT{0, 0, 0, 0};
        invalidateRectPadded(previousEditor, 5);
        if (addedAnnotation) invalidateRectPadded(addedBounds, 3);
        if (addedAnnotation && undoWasDisabled) invalidateButton(8);
        SetFocus(hwnd);
    }

    void commitTextEdit() { closeTextEdit(true); }
    void cancelTextEdit() { closeTextEdit(false); }

    void appendTextCharacter(wchar_t ch) {
        if (!textEditing) return;
        const RECT previous = textEditorRect;
        if (ch == L'\b') {
            if (!textEditBuffer.empty()) textEditBuffer.pop_back();
        } else if (ch >= 0x20 && ch != 0x7F) {
            textEditBuffer.push_back(ch);
        } else {
            return;
        }
        updateTextEditorRect();
        invalidateRectPadded(unionRects(previous, textEditorRect), 5);
    }

    void pasteTextFromClipboard() {
        if (!textEditing || !OpenClipboard(hwnd)) return;
        HANDLE data = GetClipboardData(CF_UNICODETEXT);
        if (data) {
            const auto* text = static_cast<const wchar_t*>(GlobalLock(data));
            if (text) {
                const RECT previous = textEditorRect;
                for (const wchar_t* p = text; *p; ++p) {
                    if (*p == L'\r' || *p == L'\n' || *p == L'\t') textEditBuffer.push_back(L' ');
                    else if (*p >= 0x20) textEditBuffer.push_back(*p);
                }
                GlobalUnlock(data);
                updateTextEditorRect();
                invalidateRectPadded(unionRects(previous, textEditorRect), 5);
            }
        }
        CloseClipboard();
    }

    void resizeSelectionTo(POINT p) {
        const RECT previousSelection = selection;
        const RECT previousUi = uiBounds();
        const RECT previousBadge = dimensionBadgeRect;
        const RECT previousPreview = brushPreviewRect;
        RECT r = originalSelection;
        const int minSize = 4;
        switch (resizeHandle) {
            case 0: r.left = p.x; r.top = p.y; break;
            case 1: r.top = p.y; break;
            case 2: r.right = p.x; r.top = p.y; break;
            case 3: r.right = p.x; break;
            case 4: r.right = p.x; r.bottom = p.y; break;
            case 5: r.bottom = p.y; break;
            case 6: r.left = p.x; r.bottom = p.y; break;
            case 7: r.left = p.x; break;
            default: break;
        }
        if (r.left > r.right) std::swap(r.left, r.right);
        if (r.top > r.bottom) std::swap(r.top, r.bottom);
        r.left = static_cast<LONG>(std::clamp(static_cast<int>(r.left), 0, capture.width - minSize));
        r.top = static_cast<LONG>(std::clamp(static_cast<int>(r.top), 0, capture.height - minSize));
        r.right = static_cast<LONG>(std::clamp(static_cast<int>(r.right), static_cast<int>(r.left) + minSize, capture.width));
        r.bottom = static_cast<LONG>(std::clamp(static_cast<int>(r.bottom), static_cast<int>(r.top) + minSize, capture.height));
        selection = r;
        logicalSelection = selection;
        updateLayout();
        brushPreviewRect = brushPreviewBounds(cursorPoint);
        invalidateSelectionTransition(previousSelection, previousUi, previousBadge);
        invalidateRectPadded(previousPreview, 3);
        invalidateRectPadded(brushPreviewRect, 3);
    }

    void moveSelectionTo(POINT p) {
        const RECT previousSelection = selection;
        const RECT previousUi = uiBounds();
        const RECT previousBadge = dimensionBadgeRect;
        const RECT previousPreview = brushPreviewRect;

        const LONG requestedDx = p.x - dragStart.x;
        const LONG requestedDy = p.y - dragStart.y;
        RECT nextLogical = originalLogicalSelection;
        OffsetRect(&nextLogical, requestedDx, requestedDy);
        nextLogical = keepLogicalSelectionReachable(nextLogical);

        logicalSelection = nextLogical;
        selection = visibleSelectionFromLogical(logicalSelection);

        // Annotations deliberately stay in absolute virtual-desktop
        // coordinates. Selection is only the crop rectangle.
        updateLayout();
        brushPreviewRect = brushPreviewBounds(cursorPoint);
        invalidateSelectionTransition(previousSelection, previousUi, previousBadge);
        invalidateRectPadded(previousPreview, 3);
        invalidateRectPadded(brushPreviewRect, 3);
    }

    void updateCursor(POINT p) {
        if (eyedropperActive) { SetCursor(LoadCursorW(nullptr, IDC_CROSS)); return; }
        if (textEditing && pointInRect(textEditorRect, p)) { SetCursor(LoadCursorW(nullptr, IDC_IBEAM)); return; }
        if (paletteOpen) {
            for (const RECT& field : pickerFieldRects) {
                if (pointInRect(field, p)) { SetCursor(LoadCursorW(nullptr, IDC_IBEAM)); return; }
            }
            if (pointInRect(pickerSvRect, p) || pointInRect(pickerHueRect, p) ||
                pointInRect(pickerAlphaRect, p)) {
                SetCursor(LoadCursorW(nullptr, IDC_CROSS));
                return;
            }
            if (pointInRect(pickerEyedropperRect, p)) { SetCursor(LoadCursorW(nullptr, IDC_HAND)); return; }
        }
        if (!hasSelection) { SetCursor(LoadCursorW(nullptr, IDC_CROSS)); return; }
        if (hitButton(p) >= 0 || hitPalette(p)) { SetCursor(LoadCursorW(nullptr, IDC_HAND)); return; }
        if (hitToolbarPanel(p)) { SetCursor(LoadCursorW(nullptr, IDC_ARROW)); return; }

        // The selection is interactive only in Drag mode. Drawing tools never
        // accidentally resize/move the crop when a stroke starts near its edge.
        if (tool == Tool::Drag) {
            const int handle = hitHandle(p);
            switch (handle) {
                case 0: case 4: SetCursor(LoadCursorW(nullptr, IDC_SIZENWSE)); return;
                case 2: case 6: SetCursor(LoadCursorW(nullptr, IDC_SIZENESW)); return;
                case 1: case 5: SetCursor(LoadCursorW(nullptr, IDC_SIZENS)); return;
                case 3: case 7: SetCursor(LoadCursorW(nullptr, IDC_SIZEWE)); return;
                default: break;
            }
            if (hitSelectionBorder(p) || pointInRect(selection, p)) {
                SetCursor(LoadCursorW(nullptr, IDC_SIZEALL));
                return;
            }
            SetCursor(LoadCursorW(nullptr, IDC_ARROW));
            return;
        }

        if (tool == Tool::Text) {
            SetCursor(LoadCursorW(nullptr, IDC_IBEAM));
            return;
        }
        if (isDrawingTool(tool)) {
            // The hollow brush preview becomes the cursor over the entire
            // virtual desktop, not just over the crop.
            SetCursor(nullptr);
            return;
        }
        SetCursor(LoadCursorW(nullptr, IDC_CROSS));
    }

};

OverlayWindow::OverlayWindow(ScreenCapture&& capture, HWND notificationTarget, OverlayMode mode)
    : impl_(new Impl(std::move(capture), notificationTarget, mode)) {}
OverlayWindow::~OverlayWindow() { delete impl_; }

HWND OverlayWindow::create(HINSTANCE instance, ScreenCapture&& capture, HWND notificationTarget,
                           OverlayMode mode) {
    static bool registered = false;
    if (!registered) {
        WNDCLASSEXW wc{};
        wc.cbSize = sizeof(wc);
        wc.style = 0;
        wc.lpfnWndProc = &OverlayWindow::windowProc;
        wc.hInstance = instance;
        wc.hCursor = LoadCursorW(nullptr, IDC_CROSS);
        wc.hbrBackground = nullptr;
        wc.lpszClassName = kOverlayClass;
        if (!RegisterClassExW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) return nullptr;
        registered = true;
    }

    auto* self = new OverlayWindow(std::move(capture), notificationTarget, mode);
    HWND hwnd = CreateWindowExW(WS_EX_TOPMOST | WS_EX_TOOLWINDOW,
        kOverlayClass, L"NightShot Capture", WS_POPUP,
        self->impl_->capture.x, self->impl_->capture.y,
        self->impl_->capture.width, self->impl_->capture.height,
        nullptr, nullptr, instance, self);
    if (!hwnd) {
        delete self;
        return nullptr;
    }
    ShowWindow(hwnd, SW_SHOW);
    SetWindowPos(hwnd, HWND_TOPMOST, self->impl_->capture.x, self->impl_->capture.y,
                 self->impl_->capture.width, self->impl_->capture.height,
                 SWP_SHOWWINDOW | SWP_NOOWNERZORDER);
    SetForegroundWindow(hwnd);
    SetFocus(hwnd);
    return hwnd;
}

LRESULT CALLBACK OverlayWindow::windowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
    auto* self = reinterpret_cast<OverlayWindow*>(GetWindowLongPtrW(hwnd, GWLP_USERDATA));
    if (message == WM_NCCREATE) {
        auto* create = reinterpret_cast<CREATESTRUCTW*>(lParam);
        self = static_cast<OverlayWindow*>(create->lpCreateParams);
        SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(self));
        self->impl_->hwnd = hwnd;
    }
    if (!self) return DefWindowProcW(hwnd, message, wParam, lParam);
    ++self->dispatchDepth_;
    const LRESULT result = self->handleMessage(message, wParam, lParam);
    if (message == WM_NCDESTROY) {
        SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0);
        self->deletePending_ = true;
    }
    --self->dispatchDepth_;
    if (self->deletePending_ && self->dispatchDepth_ == 0) delete self;
    return result;
}

LRESULT OverlayWindow::handleMessage(UINT message, WPARAM wParam, LPARAM lParam) {
    Impl& s = *impl_;
    switch (message) {
        case WM_ERASEBKGND: return 1;
        case WM_PAINT: s.paint(); return 0;
        case WM_SETCURSOR: {
            POINT p{}; GetCursorPos(&p); ScreenToClient(s.hwnd, &p); s.updateCursor(p); return TRUE;
        }
        case WM_LBUTTONDOWN: {
            POINT p{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
            s.cursorPoint = p;
            s.clearHover();

            if (s.eyedropperActive) {
                const RECT previousUi = s.uiBounds();
                if (s.sampleCapturedColor(p)) {
                    s.eyedropperActive = false;
                    s.paletteOpen = true;
                    s.updateLayout();
                    s.invalidateUiTransition(previousUi);
                    s.invalidateButton(7);
                }
                s.updateCursor(p);
                return 0;
            }

            if (s.paletteOpen) {
                if (s.handleColorPickerLeftDown(p)) return 0;
                const int clicked = s.hitButton(p);
                if (clicked >= 0) {
                    const Button* button = s.buttonAtCombinedIndex(clicked);
                    if (button && button->action == Action::Color) {
                        s.execute(Action::Color);
                        return 0;
                    }
                }
                const RECT previousUi = s.uiBounds();
                s.commitColorFieldEdit();
                s.paletteOpen = false;
                s.invalidateUiTransition(previousUi);
            }

            s.commitTextEdit();
            if (s.hasSelection) {
                const int button = s.hitButton(p);
                if (button >= 0) {
                    if (Button* b = s.buttonAtCombinedIndex(button)) s.execute(b->action);
                    return 0;
                }
                // Panel padding/gaps are UI, not transparent drawing holes.
                if (s.hitToolbarPanel(p)) return 0;

                if (s.tool != Tool::Drag) {
                    // Drawing/text tools own the entire virtual desktop. The
                    // selection border and resize handles are intentionally
                    // inert until the user explicitly switches back to Drag.
                    s.beginAnnotation(p);
                    s.updateBrushPreview(p);
                    return 0;
                }

                const int handle = s.hitHandle(p);
                if (handle >= 0) {
                    // A manual resize commits the currently visible rectangle as
                    // the new real size and discards any hidden edge overflow.
                    s.logicalSelection = s.selection;
                    s.resizeHandle = handle;
                    s.originalSelection = s.selection;
                    s.originalLogicalSelection = s.logicalSelection;
                    s.dragStart = p;
                    SetCapture(s.hwnd);
                    return 0;
                }
                if (s.hitSelectionBorder(p) || pointInRect(s.selection, p)) {
                    s.draggingSelection = true;
                    s.originalSelection = s.selection;
                    s.originalLogicalSelection = s.logicalSelection;
                    s.dragStart = p;
                    SetCapture(s.hwnd);
                    return 0;
                }

                // Drag mode + click outside the crop starts a new crop. Global
                // annotations are deliberately preserved.
                const RECT abandonedSelection = s.selection;
                const RECT abandonedUi = s.uiBounds();
                const RECT abandonedBadge = s.dimensionBadgeRect;
                const RECT abandonedPreview = s.brushPreviewRect;
                s.hasSelection = false;
                s.selecting = true;
                s.dragStart = p;
                s.selection = RECT{p.x, p.y, p.x, p.y};
                s.logicalSelection = s.selection;
                s.brushPreviewRect = RECT{0, 0, 0, 0};
                s.updateDimensionBadgeBounds();
                s.updateLayout();
                SetCapture(s.hwnd);
                s.invalidateSelectionDifference(abandonedSelection, s.selection);
                s.invalidateOutline(abandonedSelection, std::max(9, s.ui.handle + 5));
                s.invalidateRectPadded(abandonedUi, 4);
                s.invalidateRectPadded(abandonedBadge, 5);
                s.invalidateRectPadded(abandonedPreview, 3);
                return 0;
            }
            s.selecting = true;
            s.dragStart = p;
            s.selection = RECT{p.x, p.y, p.x, p.y};
            s.logicalSelection = s.selection;
            s.updateDimensionBadgeBounds();
            s.updateLayout();
            SetCapture(s.hwnd);
            // The desktop is already dimmed. Only the hint card disappears here;
            // the selected pixels are revealed incrementally by WM_MOUSEMOVE.
            s.invalidateRectPadded(s.hintRectForMonitor(s.hintMonitorIndex), 5);
            return 0;
        }
        case WM_MOUSEMOVE: {
            POINT p{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
            s.cursorPoint = p;
            s.armMouseLeaveTracking();
            if (s.pickerDragging()) {
                s.updatePickerDrag(p);
                s.updateCursor(p);
            } else if (s.eyedropperActive) {
                s.updateCursor(p);
            } else if (s.selecting) {
                const RECT previousSelection = s.selection;
                const RECT previousBadge = s.dimensionBadgeRect;
                POINT clamped{static_cast<LONG>(std::clamp(static_cast<int>(p.x), 0, s.capture.width)),
                              static_cast<LONG>(std::clamp(static_cast<int>(p.y), 0, s.capture.height))};
                s.selection = normalizeRect(s.dragStart, clamped);
                s.logicalSelection = s.selection;
                s.updateDimensionBadgeBounds();
                s.invalidateSelectionTransition(previousSelection, RECT{0, 0, 0, 0}, previousBadge);
            } else if (s.resizeHandle >= 0) {
                s.resizeSelectionTo(p);
            } else if (s.draggingSelection) {
                s.moveSelectionTo(p);
            } else if (s.drawing) {
                s.updateAnnotation(p);
                s.updateBrushPreview(p);
            } else {
                if (!s.hasSelection) {
                    const int nextMonitor = s.monitorIndexForPoint(p);
                    if (nextMonitor != s.hintMonitorIndex) {
                        const RECT oldHint = s.hintRectForMonitor(s.hintMonitorIndex);
                        s.hintMonitorIndex = nextMonitor;
                        s.invalidateRectPadded(oldHint, 5);
                        s.invalidateRectPadded(s.hintRectForMonitor(s.hintMonitorIndex), 5);
                    }
                }
                s.setHoveredButton(s.hitButton(p));
                s.updateBrushPreview(p);
                s.updateCursor(p);
            }
            return 0;
        }
        case WM_LBUTTONUP: {
            const POINT p{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
            s.cursorPoint = p;
            if (s.pickerDragging()) {
                s.finishPickerDrag();
            } else if (s.selecting) {
                s.selecting = false;
                ReleaseCapture();
                if (rectWidth(s.selection) >= 4 && rectHeight(s.selection) >= 4) {
                    s.hasSelection = true;
                    s.logicalSelection = s.selection;
                    s.updateLayout();
                } else {
                    s.hasSelection = false;
                    s.dimensionBadgeRect = RECT{0, 0, 0, 0};
                }
                s.brushPreviewRect = s.brushPreviewBounds(p);
                s.invalidateSelection();
                s.invalidateUi();
                if (s.hasSelection && s.mode == OverlayMode::GifQuick) {
                    s.doQuickGif();
                    return 0;
                }
            } else if (s.resizeHandle >= 0) {
                s.logicalSelection = s.selection;
                s.resizeHandle = -1;
                ReleaseCapture();
                s.updateLayout();
                s.brushPreviewRect = s.brushPreviewBounds(p);
                s.invalidateSelection();
                s.invalidateUi();
            } else if (s.draggingSelection) {
                s.draggingSelection = false;
                ReleaseCapture();
                s.updateLayout();
                s.brushPreviewRect = s.brushPreviewBounds(p);
                s.invalidateSelection();
                s.invalidateUi();
            } else if (s.drawing) {
                s.finishAnnotation();
                s.updateBrushPreview(p);
            }
            s.updateCursor(p);
            return 0;
        }
        case WM_RBUTTONDOWN: {
            const POINT point{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
            if (s.eyedropperActive) {
                const RECT previousUi = s.uiBounds();
                s.eyedropperActive = false;
                s.paletteOpen = true;
                s.updateLayout();
                s.invalidateUiTransition(previousUi);
                s.updateCursor(point);
                return 0;
            }
            if (s.paletteOpen) {
                if (s.handleColorPickerRightDown(point)) return 0;
                const RECT previousUi = s.uiBounds();
                s.commitColorFieldEdit();
                s.paletteOpen = false;
                s.invalidateUiTransition(previousUi);
                s.updateCursor(point);
                return 0;
            }
            if (s.drawing && !s.annotations.empty()) {
                const RECT dirty = s.annotationBounds(s.annotations.back());
                s.annotations.pop_back();
                s.drawing = false;
                ReleaseCapture();
                s.invalidateRectPadded(dirty, 2);
                if (s.annotations.empty()) s.invalidateButton(8);
                s.updateBrushPreview(point);
            } else {
                DestroyWindow(s.hwnd);
            }
            return 0;
        }
        case WM_MOUSEWHEEL: {
            POINT point{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
            ScreenToClient(s.hwnd, &point);
            s.cursorPoint = point;
            if (!s.paletteOpen && !s.eyedropperActive && s.hasSelection &&
                Impl::isDrawingTool(s.tool)) {
                s.adjustCurrentStrokeWidth(GET_WHEEL_DELTA_WPARAM(wParam));
                s.updateCursor(point);
                return 0;
            }
            break;
        }
        case WM_MOUSELEAVE:
            s.trackingMouseLeave = false;
            if (!s.selecting && !s.drawing && !s.draggingSelection && s.resizeHandle < 0) s.clearHover();
            return 0;
        case WM_TIMER:
            if (wParam == Impl::kHoverTimer) {
                KillTimer(s.hwnd, Impl::kHoverTimer);
                POINT cursor{};
                GetCursorPos(&cursor);
                ScreenToClient(s.hwnd, &cursor);
                if (s.hoveredButton >= 0 && s.hitButton(cursor) == s.hoveredButton) {
                    const int previousTooltip = s.tooltipButton;
                    s.tooltipButton = s.hoveredButton;
                    s.invalidateRectPadded(s.tooltipBoundsApprox(previousTooltip), 3);
                    s.invalidateRectPadded(s.tooltipBoundsApprox(s.tooltipButton), 3);
                }
                return 0;
            }
            break;
        case WM_CHAR:
            if (s.activeColorField != ColorField::None) {
                if (wParam == L'\r' || wParam == L'\n') { s.commitColorFieldEdit(); return 0; }
                if (wParam == 0x1B) { s.cancelColorFieldEdit(); return 0; }
                s.appendColorFieldCharacter(static_cast<wchar_t>(wParam));
                return 0;
            }
            if (s.textEditing) {
                if (wParam == L'\r' || wParam == L'\n') { s.commitTextEdit(); return 0; }
                if (wParam == 0x1B) { s.cancelTextEdit(); return 0; }
                s.appendTextCharacter(static_cast<wchar_t>(wParam));
                return 0;
            }
            break;
        case WM_KEYDOWN: {
            const bool ctrl = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
            if (s.activeColorField != ColorField::None) {
                if (wParam == VK_ESCAPE) { s.cancelColorFieldEdit(); return 0; }
                if (wParam == VK_RETURN) { s.commitColorFieldEdit(); return 0; }
                if (ctrl && wParam == 'V') { s.pasteColorFieldFromClipboard(); return 0; }
                return 0;
            }
            if (s.eyedropperActive && wParam == VK_ESCAPE) {
                const RECT previousUi = s.uiBounds();
                s.eyedropperActive = false;
                s.paletteOpen = true;
                s.updateLayout();
                s.invalidateUiTransition(previousUi);
                return 0;
            }
            if (s.paletteOpen && wParam == VK_ESCAPE) {
                const RECT previousUi = s.uiBounds();
                s.paletteOpen = false;
                s.invalidateUiTransition(previousUi);
                return 0;
            }
            if (s.textEditing) {
                if (wParam == VK_ESCAPE) { s.cancelTextEdit(); return 0; }
                if (wParam == VK_RETURN) { s.commitTextEdit(); return 0; }
                if (ctrl && wParam == 'V') { s.pasteTextFromClipboard(); return 0; }
            }
            if (wParam == VK_ESCAPE) { DestroyWindow(s.hwnd); return 0; }
            if (ctrl && wParam == 'Z') { s.execute(Action::Undo); return 0; }
            if (ctrl && wParam == 'C' && s.hasSelection) { s.doCopy(); return 0; }
            if (ctrl && wParam == 'S' && s.hasSelection) { s.doSave(); return 0; }
            if (!ctrl) {
                switch (wParam) {
                    case 'D': s.setTool(Tool::Drag); return 0;
                    case 'P': s.setTool(Tool::Pen); return 0;
                    case 'L': s.setTool(Tool::Line); return 0;
                    case 'A': s.setTool(Tool::Arrow); return 0;
                    case 'R': s.setTool(Tool::Rectangle); return 0;
                    case 'M': s.setTool(Tool::Marker); return 0;
                    case 'T': s.setTool(Tool::Text); return 0;
                    case 'C': s.execute(Action::Color); return 0;
                }
            }
            break;
        }
        case WM_KILLFOCUS:
            // Keep the overlay alive while native save dialogs/message boxes are open.
            return 0;
        case WM_CLOSE: DestroyWindow(s.hwnd); return 0;
        case WM_DESTROY:
            KillTimer(s.hwnd, Impl::kHoverTimer);
            return 0;
        case WM_NCDESTROY: return DefWindowProcW(s.hwnd, message, wParam, lParam);
        default: break;
    }
    return DefWindowProcW(s.hwnd, message, wParam, lParam);
}