#include "UI/CompositorMenus.h"
#include "IO/RecentProjects.h"
#include "Logging.h"
#include "UI/KeyboardShortcuts.h"
#include "UI/ProjectWorkspaceView.h"
#include <QApplication>
#include <QMenu>

namespace {
// An entry's name: Hue/Saturation is newHueSaturationAdjustment.
QString adjustmentName(AdjustmentKind kind)
{
    return QStringLiteral("new%1Adjustment").arg(rawValue(kind).remove(QLatin1Char(' ')).remove(QLatin1Char('/')).remove(QLatin1Char('&')));
}

// A filter's entry from Swift's title: gaussianBlur.
QString filterName(FilterKind kind)
{
    QString name = rawValue(kind);
    name.remove(QLatin1Char(' ')).remove(QLatin1Char('&'));
    name[0] = name[0].toLower();
    return name;
}
}

CompositorMenus::CompositorMenus(ProjectWorkspace &workspace, QMenuBar &bar, ProjectWorkspaceView &window)
    : QObject(&bar), m_workspace(workspace), m_window(window), m_view(window)
{
    QMenu *file = bar.addMenu(QStringLiteral("&File"));
    add(file, QStringLiteral("newCanvas"), QStringLiteral("New Canvas…"), QKeySequence(Qt::CTRL | Qt::Key_N), [this] { projects().newCanvas(); });
    add(file, QStringLiteral("openProject"), QStringLiteral("Open Project…"), QKeySequence(Qt::CTRL | Qt::Key_O), [this] { projects().open(); });
    QMenu *recent = file->addMenu(QStringLiteral("Open Recent"));
    recent->menuAction()->setObjectName(QStringLiteral("openRecent"));
    listRecent(recent);
    connect(&RecentProjects::shared(), &RecentProjects::changed, this, [this, recent] { listRecent(recent); });
    add(file, QStringLiteral("importImages"), QStringLiteral("Import Images…"), QKeySequence(), [this] { session().setShowsImporter(true); });
    file->addSeparator();
    add(file, QStringLiteral("save"), QStringLiteral("Save"), QKeySequence(Qt::CTRL | Qt::Key_S), [this] { projects().save(); });
    add(file, QStringLiteral("saveAs"), QStringLiteral("Save As…"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_S), [this] { projects().save(true); });
    file->addSeparator();
    add(file, QStringLiteral("exportPNG"), QStringLiteral("Export PNG…"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_E), [this] { projects().exportPNG(); });
    add(file, QStringLiteral("exportJPEG"), QStringLiteral("Export JPEG…"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::SHIFT | Qt::Key_S),
        [this] { projects().exportAs(ExportFormat::jpeg); });
    // Swift 1.4.8: Photoshop's Ctrl+Alt+Shift+W.
    add(file, QStringLiteral("exportAs"), QStringLiteral("Export As…"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::SHIFT | Qt::Key_W), [this] { projects().exportAs(); });
    file->addSeparator();
    add(file, QStringLiteral("closeProject"), QStringLiteral("Close Project"), QKeySequence(Qt::CTRL | Qt::Key_W), [this] { projects().close(&m_window); });

    QMenu *edit = bar.addMenu(QStringLiteral("&Edit"));
    add(edit, QStringLiteral("undo"), QStringLiteral("Undo"), QKeySequence(Qt::CTRL | Qt::Key_Z), [this] {
        if (m_field)
            m_field->undo();
        else if (InlineTextEditor *text = typedText())
            text->undo();
        else
            session().undo();
    });
    add(edit, QStringLiteral("redo"), QStringLiteral("Redo"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_Z), [this] {
        if (m_field)
            m_field->redo();
        else if (InlineTextEditor *text = typedText())
            text->redo();
        else
            session().redo();
    });
    edit->addSeparator();
    // Cut, Copy and Paste check when chosen, as Swift's do.
    add(edit, QStringLiteral("cut"), QStringLiteral("Cut"), QKeySequence(Qt::CTRL | Qt::Key_X), [this] {
        if (m_field)
            m_field->cut();
        else if (InlineTextEditor *text = typedText())
            text->cut();
        else if (session().selection() && session().canCopyPixels())
            session().cutSelection();
        else
            qCWarning(lcApp) << "nothing to cut";
    });
    add(edit, QStringLiteral("copy"), QStringLiteral("Copy"), QKeySequence(Qt::CTRL | Qt::Key_C), [this] {
        if (m_field)
            m_field->copy();
        else if (InlineTextEditor *text = typedText())
            text->copy();
        else if (session().canCopyPixels() || session().canCopyLayer())
            session().copySelection();
        else
            qCWarning(lcApp) << "nothing to copy";
    });
    add(edit, QStringLiteral("copyMerged"), QStringLiteral("Copy Merged"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_C), [this] { session().copyMergedSelection(); });
    add(edit, QStringLiteral("paste"), QStringLiteral("Paste"), QKeySequence(Qt::CTRL | Qt::Key_V), [this] {
        if (m_field)
            m_field->paste();
        else if (InlineTextEditor *text = typedText())
            text->paste();
        else if (m_workspace.pasteCopiedLayer())
            return;
        else if (session().canPaste())
            session().paste();
        else
            qCWarning(lcApp) << "nothing to paste";
    });
    edit->addSeparator();
    add(edit, QStringLiteral("keyboardShortcuts"), QStringLiteral("Keyboard Shortcuts…"), QKeySequence(), [this] {
        m_shortcutsPanel.onClose = [this] { m_shortcutsPanel.close(); };
        m_shortcutsPanel.show(QStringLiteral("Keyboard Shortcuts"), new KeyboardShortcutsSheet([this] { m_shortcutsPanel.close(); }));
    });
    // Text fields delete the selection, else back from the caret.
    add(edit, QStringLiteral("fillForeground"), QStringLiteral("Fill with Foreground Color"), QKeySequence(Qt::ALT | Qt::Key_Backspace), [this] {
        if (!m_field) {
            session().fillSelection(EditorSession::FillSource::foreground);
            return;
        }
        if (!m_field->hasSelectedText())
            m_field->cursorWordBackward(true);
        m_field->backspace();
    });
    add(edit, QStringLiteral("fillBackground"), QStringLiteral("Fill with Background Color"), QKeySequence(Qt::CTRL | Qt::Key_Backspace), [this] {
        if (!m_field) {
            session().fillSelection(EditorSession::FillSource::background);
            return;
        }
        if (!m_field->hasSelectedText())
            m_field->home(true);
        m_field->backspace();
    });
    add(edit, QStringLiteral("clearSelectionPixels"), QStringLiteral("Clear Selection Pixels"), QKeySequence(), [this] { session().clearSelectedPixels(); });
    add(edit, QStringLiteral("contentAwareFill"), QStringLiteral("Content-Aware Fill…"), QKeySequence(Qt::SHIFT | Qt::Key_Backspace),
        [this] { session().beginFilter(FilterKind::contentAwareFill); });

    QMenu *view = bar.addMenu(QStringLiteral("&View"));
    add(view, QStringLiteral("searchCommands"), QStringLiteral("Search Commands…"), QKeySequence(Qt::CTRL | Qt::Key_F),
        [this, &bar] { m_palette.toggle(session(), bar, action(QStringLiteral("searchCommands"))); });
    // A plain F; a field takes its letters first.
    add(view, QStringLiteral("toggleFullscreen"), QStringLiteral("Toggle Fullscreen"), QKeySequence(Qt::Key_F), [this] { m_view.toggleCanvasOnly(); })
        ->setCheckable(true);
    view->addSeparator();
    add(view, QStringLiteral("fit"), QStringLiteral("Fit Canvas"), QKeySequence(Qt::CTRL | Qt::Key_0), [this] { session().fit(); });
    add(view, QStringLiteral("actualPixels"), QStringLiteral("Actual Pixels"), QKeySequence(Qt::CTRL | Qt::Key_1), [this] { session().zoom(1); });
    // Swift's stops; open text keeps the keys, as NSText does.
    const auto zoomBy = [this](int step) {
        if (!m_field && !(m_canvas && session().textDraft()))
            session().zoomKeyboard(step);
    };
    add(view, QStringLiteral("zoomIn"), QStringLiteral("Zoom In"), QKeySequence(Qt::CTRL | Qt::Key_Equal), [zoomBy] { zoomBy(1); });
    add(view, QStringLiteral("zoomOut"), QStringLiteral("Zoom Out"), QKeySequence(Qt::CTRL | Qt::Key_Minus), [zoomBy] { zoomBy(-1); });
    add(view, QStringLiteral("pixelGrid"), QStringLiteral("Pixel Grid (800% and above)"), QKeySequence(), [this] { session().setShowsPixelGrid(!session().showsPixelGrid()); })
        ->setCheckable(true);
    // Ctrl+H: the Move tool's box; the desktop hides apps.
    add(view, QStringLiteral("transformControls"), QStringLiteral("Show Transform Controls"), QKeySequence(Qt::CTRL | Qt::Key_H),
        [this] { session().setShowsTransformControls(!session().showsTransformControls()); })
        ->setCheckable(true);
    // Swift 1.1.7's guides, grid, rulers and Snap To.
    view->addSeparator();
    const auto toggle = [this](QMenu *menu, const QString &name, const QString &text, const QKeySequence &key, bool (EditorSession::*read)() const,
                               void (EditorSession::*write)(bool)) {
        add(menu, name, text, key, [this, read, write] { (session().*write)(!(session().*read)()); })->setCheckable(true);
    };
    QMenu *show = view->addMenu(QStringLiteral("Show"));
    toggle(show, QStringLiteral("showGrid"), QStringLiteral("Grid"), QKeySequence(Qt::CTRL | Qt::Key_Apostrophe), &EditorSession::showsGrid,
           &EditorSession::setShowsGrid);
    toggle(show, QStringLiteral("showGuides"), QStringLiteral("Guides"), QKeySequence(Qt::CTRL | Qt::Key_Semicolon), &EditorSession::showsGuides,
           &EditorSession::setShowsGuides);
    add(view, QStringLiteral("gridSettings"), QStringLiteral("Grid Settings…"), QKeySequence(), [this] { projects().gridSettings(); });
    toggle(view, QStringLiteral("showRulers"), QStringLiteral("Rulers"), QKeySequence(Qt::CTRL | Qt::Key_R), &EditorSession::showsRulers,
           &EditorSession::setShowsRulers);
    view->addSeparator();
    toggle(view, QStringLiteral("snapEnabled"), QStringLiteral("Snap"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_Semicolon),
           &EditorSession::snapEnabled, &EditorSession::setSnapEnabled);
    QMenu *snapTo = view->addMenu(QStringLiteral("Snap To"));
    toggle(snapTo, QStringLiteral("snapToGuides"), QStringLiteral("Guides"), QKeySequence(), &EditorSession::snapToGuides, &EditorSession::setSnapToGuides);
    toggle(snapTo, QStringLiteral("snapToGrid"), QStringLiteral("Grid"), QKeySequence(), &EditorSession::snapToGrid, &EditorSession::setSnapToGrid);
    toggle(snapTo, QStringLiteral("snapToLayers"), QStringLiteral("Layers"), QKeySequence(), &EditorSession::snapToLayers, &EditorSession::setSnapToLayers);
    toggle(snapTo, QStringLiteral("snapToDocumentBounds"), QStringLiteral("Document Bounds"), QKeySequence(), &EditorSession::snapToDocumentBounds,
           &EditorSession::setSnapToDocumentBounds);
    view->addSeparator();
    toggle(view, QStringLiteral("lockGuides"), QStringLiteral("Lock Guides"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_Semicolon),
           &EditorSession::locksGuides, &EditorSession::setLocksGuides);
    add(view, QStringLiteral("clearGuides"), QStringLiteral("Clear Guides"), QKeySequence(), [this] { session().clearGuides(); });

    QMenu *select = bar.addMenu(QStringLiteral("&Select"));
    // The focus takes Select All first, as Swift's responder chain.
    add(select, QStringLiteral("selectAll"), QStringLiteral("All"), QKeySequence(Qt::CTRL | Qt::Key_A), [this] {
        if (m_field)
            m_field->selectAll();
        else if (InlineTextEditor *text = typedText())
            text->selectAll();
        else
            session().selectAll();
    });
    add(select, QStringLiteral("deselect"), QStringLiteral("Deselect"), QKeySequence(Qt::CTRL | Qt::Key_D), [this] { session().deselect(); });
    add(select, QStringLiteral("inverse"), QStringLiteral("Inverse"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_I), [this] { session().invertSelection(); });
    add(select, QStringLiteral("layerPixels"), QStringLiteral("Layer's Pixels"), QKeySequence(), [this] {
        if (const std::optional<QUuid> id = session().activeLayerID())
            session().loadLayerSelection(*id);
    });
    add(select, QStringLiteral("subject"), QStringLiteral("Subject"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_A),
        [this] { session().selectSubject(SelectionMode::replace, {}); });
    add(select, QStringLiteral("colorRange"), QStringLiteral("Color Range…"), QKeySequence(), [this] { session().beginColorRange(); });
    add(select, QStringLiteral("maskBlackAreas"), QStringLiteral("Mask's Black Areas"), QKeySequence(), [this] {
        if (const std::optional<QUuid> id = session().activeLayerID())
            session().loadMaskSelection(*id);
    });
    select->addSeparator();
    add(select, QStringLiteral("expandSelection"), QStringLiteral("Expand…"), QKeySequence(),
        [this] { session().promptSelectionAmount(SelectionAmountOperation::expand); });
    add(select, QStringLiteral("contractSelection"), QStringLiteral("Contract…"), QKeySequence(),
        [this] { session().promptSelectionAmount(SelectionAmountOperation::contract); });
    add(select, QStringLiteral("featherSelection"), QStringLiteral("Feather…"), QKeySequence(),
        [this] { session().promptSelectionAmount(SelectionAmountOperation::feather); });

    QMenu *image = bar.addMenu(QStringLiteral("&Image"));
    add(image, QStringLiteral("curves"), QStringLiteral("Curves…"), QKeySequence(Qt::CTRL | Qt::Key_M), [this] { session().beginFilter(FilterKind::curves); });
    add(image, QStringLiteral("levels"), QStringLiteral("Levels…"), QKeySequence(Qt::CTRL | Qt::Key_L), [this] { session().beginLevels(); });
    add(image, QStringLiteral("hueSaturation"), QStringLiteral("Hue/Saturation…"), QKeySequence(Qt::CTRL | Qt::Key_U),
        [this] { session().beginHueSaturation(); });
    for (const FilterKind kind : {FilterKind::blackWhite, FilterKind::colorBalance, FilterKind::exposure, FilterKind::gradientMap, FilterKind::grain})
        add(image, filterName(kind), rawValue(kind).replace(QLatin1Char('&'), QStringLiteral("&&")) + QStringLiteral("…"), QKeySequence(), [this, kind] { session().beginFilter(kind); });
    add(image, QStringLiteral("invert"), QStringLiteral("Invert"), QKeySequence(Qt::CTRL | Qt::Key_I), [this] { session().invertPixels(); });
    image->addSeparator();
    add(image, QStringLiteral("canvasSize"), QStringLiteral("Canvas Size…"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_C), [this] { projects().canvasSize(); });
    add(image, QStringLiteral("imageSize"), QStringLiteral("Image Size…"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_I), [this] { projects().imageSize(); });
    add(image, QStringLiteral("trim"), QStringLiteral("Trim…"), QKeySequence(), [this] { projects().trim(); });
    image->addSeparator();
    add(image, QStringLiteral("rotateCanvasClockwise"), QStringLiteral("Rotate Canvas 90° Clockwise"), QKeySequence(), [this] { session().rotateCanvas(true); });
    add(image, QStringLiteral("rotateCanvasCounterclockwise"), QStringLiteral("Rotate Canvas 90° Counterclockwise"), QKeySequence(),
        [this] { session().rotateCanvas(false); });
    add(image, QStringLiteral("flipCanvasHorizontal"), QStringLiteral("Flip Canvas Horizontal"), QKeySequence(), [this] { session().flipCanvas(true); });
    add(image, QStringLiteral("flipCanvasVertical"), QStringLiteral("Flip Canvas Vertical"), QKeySequence(), [this] { session().flipCanvas(false); });

    QMenu *filter = bar.addMenu(QStringLiteral("Fil&ter"));
    // Ctrl+Meta+F, Swift's Cmd+Control: Ctrl+F searches commands.
    add(filter, QStringLiteral("lastFilter"), QStringLiteral("Last Filter"), QKeySequence(Qt::CTRL | Qt::META | Qt::Key_F),
        [this] { session().repeatLastFilter(); });
    filter->addSeparator();
    for (const FilterKind kind : allFilterKinds) {
        if (kind != FilterKind::contentAwareFill && !isImageAdjustment(kind))
            add(filter, filterName(kind), rawValue(kind) + QStringLiteral("…"), QKeySequence(), [this, kind] { session().beginFilter(kind); });
    }

    QMenu *layer = bar.addMenu(QStringLiteral("&Layer"));
    QMenu *adjustments = layer->addMenu(QStringLiteral("New Adjustment Layer"));
    adjustments->menuAction()->setObjectName(QStringLiteral("newAdjustmentLayer"));
    for (const AdjustmentKind kind : allAdjustmentKinds)
        // A menu reads a lone ampersand as a mnemonic: doubled.
        add(adjustments, adjustmentName(kind), rawValue(kind).replace(QLatin1Char('&'), QStringLiteral("&&")) + (isEditable(kind) ? QStringLiteral("…") : QString()), QKeySequence(),
            [this, kind] { session().addAdjustment(kind); });
    add(layer, QStringLiteral("editAdjustment"), QStringLiteral("Edit Adjustment…"), QKeySequence(),
        [this] { session().setAdjustmentEditingID(session().activeLayerID()); });
    layer->addSeparator();
    // Swift's transformCommand: with selected pixels, Transform Selection.
    add(layer, QStringLiteral("transformLayer"), QStringLiteral("Transform Layer"), QKeySequence(Qt::CTRL | Qt::Key_T), [this] { session().transformCommand(); });
    // Swift's layerViaCopy: a selection makes it Layer via Copy.
    add(layer, QStringLiteral("layerViaCopy"), QStringLiteral("Duplicate Layer"), QKeySequence(Qt::CTRL | Qt::Key_J), [this] { session().layerViaCopy(); });
    layer->addSeparator();
    add(layer, QStringLiteral("clippingMask"), QStringLiteral("Create Clipping Mask"), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_G), [this] {
        if (const std::optional<QUuid> id = session().activeLayerID())
            session().toggleClippingMask(*id);
    });
    layer->addSeparator();
    add(layer, QStringLiteral("groupLayers"), QStringLiteral("Group Selected Layers"), QKeySequence(Qt::CTRL | Qt::Key_G), [this] { session().groupSelectedLayers(); });
    add(layer, QStringLiteral("ungroupLayers"), QStringLiteral("Ungroup Layers"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_G), [this] { session().ungroupLayers(); });
    add(layer, QStringLiteral("moveOutOfFolder"), QStringLiteral("Move Out of Folder"), QKeySequence(), [this] { session().moveActiveLayerOutOfGroup(); });
    add(layer, QStringLiteral("newBlankLayer"), QStringLiteral("New Blank Layer"), QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_N), [this] { session().addBlankLayer(); });
    add(layer, QStringLiteral("renameLayer"), QStringLiteral("Rename Layer…"), QKeySequence(), [this] { session().setRenamingLayerID(session().activeLayerID()); });
    add(layer, QStringLiteral("layerVisibility"), QStringLiteral("Hide Layer"), QKeySequence(), [this] {
        if (const std::optional<QUuid> id = session().activeLayerID())
            session().toggleLayerVisibility(*id);
    });
    layer->addSeparator();
    add(layer, QStringLiteral("moveLayerUp"), QStringLiteral("Move Layer Up"), QKeySequence(Qt::CTRL | Qt::Key_BracketRight), [this] { session().moveActiveLayer(1); });
    add(layer, QStringLiteral("moveLayerDown"), QStringLiteral("Move Layer Down"), QKeySequence(Qt::CTRL | Qt::Key_BracketLeft), [this] { session().moveActiveLayer(-1); });
    add(layer, QStringLiteral("mergeLayers"), QStringLiteral("Merge Down"), QKeySequence(Qt::CTRL | Qt::Key_E), [this] { session().mergeLayers(); });
    layer->addSeparator();
    add(layer, QStringLiteral("flipHorizontal"), QStringLiteral("Flip Layer Horizontal"), QKeySequence(), [this] { session().flipLayers(true); });
    add(layer, QStringLiteral("flipVertical"), QStringLiteral("Flip Layer Vertical"), QKeySequence(), [this] { session().flipLayers(false); });
    layer->addSeparator();
    add(layer, QStringLiteral("deleteLayer"), QStringLiteral("Delete Layer"), QKeySequence(), [this] { session().deleteLayerOrMask(); });

    connect(&m_workspace, &ProjectWorkspace::changed, this, &CompositorMenus::watchFront);
    // A field gaining or losing focus changes Undo's meaning.
    connect(qApp, &QApplication::focusChanged, this, &CompositorMenus::focusMoved);
    connect(&ShortcutSettings::shared(), &ShortcutSettings::changed, this, &CompositorMenus::remap);
    watchFront();
}

void CompositorMenus::listRecent(QMenu *recent)
{
    recent->clear();
    for (const QString &path : RecentProjects::shared().paths())
        // A name's ampersand is literal, no mnemonic.
        connect(recent->addAction(ProjectTab::nameWithoutSuffix(path).replace(QLatin1Char('&'), QStringLiteral("&&"))), &QAction::triggered, this, [this, path] { projects().open(path); });
    recent->addSeparator();
    QAction *clear = recent->addAction(QStringLiteral("Clear Menu"));
    clear->setObjectName(QStringLiteral("clearRecent"));
    clear->setEnabled(!RecentProjects::shared().paths().isEmpty());
    connect(clear, &QAction::triggered, this, [] { RecentProjects::shared().clear(); });
}

QAction *CompositorMenus::add(QMenu *menu, const QString &name, const QString &text, const QKeySequence &shortcut, const std::function<void()> &run)
{
    QAction *made = menu->addAction(text);
    made->setObjectName(name);
    made->setProperty("originalShortcut", shortcut);
    made->setShortcut(ShortcutSettings::shared().menu(shortcut));
    // Keys still work while Canvas Only hides the bar.
    m_window.addAction(made);
    connect(made, &QAction::triggered, this, run);
    return made;
}

void CompositorMenus::remap()
{
    for (QAction *entry : parent()->findChildren<QAction *>()) {
        const QVariant original = entry->property("originalShortcut");
        if (original.isValid())
            entry->setShortcut(ShortcutSettings::shared().menu(original.value<QKeySequence>()));
    }
}

QAction *CompositorMenus::action(const QString &name) const
{
    return parent()->findChild<QAction *>(name);
}

void CompositorMenus::watchFront()
{
    // The front tab's session drives every entry.
    if (m_watchedTab != std::optional(m_workspace.current().id)) {
        m_watchedTab = m_workspace.current().id;
        disconnect(m_sessionWatch);
        m_sessionWatch = connect(&session(), &EditorSession::changed, this, &CompositorMenus::synchronize);
    }
    synchronize();
}

void CompositorMenus::focusMoved(QWidget *, QWidget *to)
{
    // The menu bar borrows focus; the field keeps Undo.
    if (qobject_cast<QMenuBar *>(to) == nullptr) {
        m_field = qobject_cast<QLineEdit *>(to);
        m_canvas = qobject_cast<CanvasView *>(to);
    }
    synchronize();
}

void CompositorMenus::synchronize()
{
    EditorSession &s = session();
    ProjectController &p = projects();
    const std::optional<ImageLayer> active = s.activeLayer();
    const bool drawn = s.document().has_value();
    // Swift's text branch: open text makes the entries bare.
    const bool typing = m_field != nullptr || s.textDraft().has_value();
    action(QStringLiteral("newCanvas"))->setEnabled(p.canStart());
    action(QStringLiteral("openProject"))->setEnabled(p.canStart());
    action(QStringLiteral("openRecent"))->setEnabled(p.canStart());
    action(QStringLiteral("importImages"))->setEnabled(!s.levels() && !s.showsBusy() && !s.isImporting() && !s.showsNewDocument());
    action(QStringLiteral("save"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("saveAs"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("exportPNG"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("exportJPEG"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("exportAs"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("closeProject"))->setEnabled(p.canStart());
    // A step's ampersand, doubled: a lone one is a mnemonic.
    const auto shown = [](QString name) { return name.replace(QLatin1Char('&'), QStringLiteral("&&")); };
    // In a field, Undo is the field's and bare.
    action(QStringLiteral("undo"))->setText(!typing && s.canUndo() ? QStringLiteral("Undo %1").arg(shown(s.history.undoName())) : QStringLiteral("Undo"));
    action(QStringLiteral("undo"))->setEnabled(typing || s.canUndo());
    action(QStringLiteral("redo"))->setText(!typing && s.canRedo() ? QStringLiteral("Redo %1").arg(shown(s.history.redoName())) : QStringLiteral("Redo"));
    action(QStringLiteral("redo"))->setEnabled(typing || s.canRedo());
    for (const char *name : {"fit", "actualPixels", "zoomIn", "zoomOut"})
        action(QString::fromLatin1(name))->setEnabled(drawn);
    action(QStringLiteral("pixelGrid"))->setChecked(s.showsPixelGrid());
    action(QStringLiteral("toggleFullscreen"))->setChecked(s.canvasOnly());
    action(QStringLiteral("toggleFullscreen"))->setEnabled(s.canToggleCanvasOnly());
    const bool opened = s.document().has_value();
    for (const auto &[name, value] : std::initializer_list<std::pair<const char *, bool>>{
             {"showGrid", s.showsGrid()}, {"showGuides", s.showsGuides()}, {"showRulers", s.showsRulers()}, {"snapEnabled", s.snapEnabled()},
             {"snapToGuides", s.snapToGuides()}, {"snapToGrid", s.snapToGrid()}, {"snapToLayers", s.snapToLayers()},
             {"snapToDocumentBounds", s.snapToDocumentBounds()}, {"lockGuides", s.locksGuides()}}) {
        action(QString::fromLatin1(name))->setChecked(value);
        action(QString::fromLatin1(name))->setEnabled(opened);
    }
    action(QStringLiteral("clearGuides"))->setEnabled(s.canClearGuides());
    action(QStringLiteral("gridSettings"))->setEnabled(opened);
    action(QStringLiteral("transformControls"))->setChecked(s.showsTransformControls());
    action(QStringLiteral("transformControls"))->setEnabled(s.tool() == NavigationTool::move && s.document().has_value());
    const bool selected = s.selection().has_value();
    action(QStringLiteral("deselect"))->setEnabled(selected && s.canEditSelection());
    action(QStringLiteral("inverse"))->setEnabled(selected && s.canEditSelection());
    action(QStringLiteral("layerPixels"))->setEnabled(active && active->asset && s.canEditSelection());
    action(QStringLiteral("maskBlackAreas"))->setEnabled(active && active->mask && s.canEditSelection());
    action(QStringLiteral("subject"))->setEnabled(s.canSelectSubject());
    action(QStringLiteral("colorRange"))->setEnabled(s.canSelectColorRange());
    for (const char *name : {"expandSelection", "contractSelection", "featherSelection"})
        action(QString::fromLatin1(name))->setEnabled(s.canModifySelection());
    action(QStringLiteral("levels"))->setEnabled(s.canAdjustColors() && !s.hueSaturation());
    action(QStringLiteral("lastFilter"))->setText(s.lastFilter() ? QStringLiteral("Last Filter: ") + rawValue(s.lastFilter().value()) : QStringLiteral("Last Filter"));
    action(QStringLiteral("lastFilter"))->setEnabled(s.canRepeatLastFilter());
    for (const FilterKind kind : allFilterKinds) {
        if (kind != FilterKind::contentAwareFill)
            action(filterName(kind))->setEnabled((kind == FilterKind::vignette ? s.canVignette() : s.canAdjustColors()) && !s.hueSaturation());
    }
    action(QStringLiteral("hueSaturation"))->setEnabled(s.canAdjustColors());
    action(QStringLiteral("invert"))->setText(s.isMaskSelected() ? QStringLiteral("Invert Mask") : QStringLiteral("Invert"));
    action(QStringLiteral("invert"))->setEnabled(s.canInvert());
    action(QStringLiteral("canvasSize"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("imageSize"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("trim"))->setEnabled(drawn && p.canStart());
    action(QStringLiteral("rotateCanvasClockwise"))->setEnabled(s.canEditLayers());
    action(QStringLiteral("rotateCanvasCounterclockwise"))->setEnabled(s.canEditLayers());
    action(QStringLiteral("flipCanvasHorizontal"))->setEnabled(s.canEditLayers());
    action(QStringLiteral("flipCanvasVertical"))->setEnabled(s.canEditLayers());
    action(QStringLiteral("newAdjustmentLayer"))->setEnabled(s.canEditLayers());
    // Beyond Swift: Invert has no editor, so nothing to open.
    action(QStringLiteral("editAdjustment"))->setEnabled(s.canEditLayers() && active && active->adjustment && isEditable(active->adjustment->kind));
    action(QStringLiteral("transformLayer"))->setText(s.canTransformSelection() ? QStringLiteral("Transform Selection") : QStringLiteral("Transform Layer"));
    action(QStringLiteral("transformLayer"))->setEnabled(s.canTransform() || s.canTransformSelection());
    action(QStringLiteral("clippingMask"))->setText(active && active->maskSourceID ? QStringLiteral("Release Clipping Mask") : QStringLiteral("Create Clipping Mask"));
    action(QStringLiteral("clippingMask"))->setEnabled(s.activeLayerID() && s.canToggleClippingMask(*s.activeLayerID()));
    action(QStringLiteral("groupLayers"))->setEnabled(s.canEditLayers());
    action(QStringLiteral("ungroupLayers"))->setEnabled(s.canUngroupLayers());
    action(QStringLiteral("moveOutOfFolder"))->setEnabled(s.canEditLayers() && active && active->parentID);
    action(QStringLiteral("newBlankLayer"))->setEnabled(s.canEditLayers());
    action(QStringLiteral("renameLayer"))->setEnabled(s.canEditLayers() && active);
    action(QStringLiteral("layerVisibility"))->setText(active && !active->isVisible ? QStringLiteral("Show Layer") : QStringLiteral("Hide Layer"));
    action(QStringLiteral("layerVisibility"))->setEnabled(s.canEditLayers() && active);
    action(QStringLiteral("moveLayerUp"))->setEnabled(s.canMoveActiveLayer(1));
    action(QStringLiteral("moveLayerDown"))->setEnabled(s.canMoveActiveLayer(-1));
    action(QStringLiteral("copyMerged"))->setEnabled(s.canCopyMerged());
    action(QStringLiteral("contentAwareFill"))->setEnabled(s.canContentAwareFill());
    action(QStringLiteral("fillForeground"))->setEnabled(s.canEditPixels());
    action(QStringLiteral("fillBackground"))->setEnabled(s.canEditPixels());
    action(QStringLiteral("clearSelectionPixels"))->setEnabled(s.selection().has_value() && s.canEditPixels());
    action(QStringLiteral("layerViaCopy"))->setText(s.selection() ? QStringLiteral("Layer via Copy") : QStringLiteral("Duplicate Layer"));
    action(QStringLiteral("layerViaCopy"))->setEnabled(s.canCopyPixels() || (!s.selection() && s.canEditLayers() && active));
    action(QStringLiteral("mergeLayers"))->setText(s.mergeTitle());
    action(QStringLiteral("mergeLayers"))->setEnabled(s.canMergeLayers());
    action(QStringLiteral("flipHorizontal"))->setEnabled(s.canTransform());
    action(QStringLiteral("flipVertical"))->setEnabled(s.canTransform());
    const std::optional<LayerEffectSelection> effect = s.selectedEffect();
    action(QStringLiteral("deleteLayer"))->setText(effect ? QStringLiteral("Delete ") + rawValue(effect->kind)
                                                   : s.isMaskSelected() && active && active->mask ? QStringLiteral("Delete Layer Mask")
                                                   : s.selectedLayerIDs().size() > 1 ? QStringLiteral("Delete Layers")
                                                                                     : QStringLiteral("Delete Layer"));
    action(QStringLiteral("deleteLayer"))->setEnabled(s.canEditLayers() && active);
}