#3467 lsp: add context menu and fix markings

Signed-off-by: Patrizio Bekerle <patrizio@bekerle.com>

Author: pbek

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## 26.4.23
 
+- Fixed a URI percent-encoding mismatch that prevented Markdown LSP diagnostics
+  from being applied when a note filename contains spaces; the incoming LSP URI
+  (e.g. `Top%20heading.md`) is now decoded with `QUrl::fromPercentEncoding`
+  before being compared to the stored document URI so wave-underlines appear
+  correctly for notes with spaces in their name
+  (for [#3467](https://github.com/pbek/QOwnNotes/issues/3467))
+- Added an inline **Markdown LSP diagnostic context menu** section that appears
+  when right-clicking on a wave-underlined region in the note editor; it shows
+  the diagnostic message as a header and fetches available LSP code actions
+  (fixes) via a short synchronous wait, then lists each fix as a clickable menu
+  item — matching the same UX pattern used by the LanguageTool and Harper
+  context menus; the old standalone **Code actions** menu item in the
+  **Markdown LSP** submenu has been removed in favour of this inline approach
+  (for [#3467](https://github.com/pbek/QOwnNotes/issues/3467))
 - Fixed shortcuts not being saved or restored in the **Shortcuts** settings;
   `storeShortcutSettings` now iterates the actual menu actions (mirroring how
   `initShortcuts` reads them) and looks up the corresponding widgets in the

src/helpers/qownnotesmarkdownhighlighter.cpp

@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) 2014-2026 Patrizio Bekerle -- <patrizio@bekerle.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -123,6 +123,11 @@ void QOwnNotesMarkdownHighlighter::highlightBlock(const QString &text) {
         // Call the per-block highlightingHook in scripts (only invoked if at
         // least one script provides the hook, checked via cached flag)
         highlightScriptingHook(text);
+
+        // Apply LSP diagnostic underlines last so they overlay all other formatting
+        if (!text.isEmpty()) {
+            highlightMarkdownLsp(text);
+        }
     }
 
     // Only check for encryption end marker if we're highlighting encrypted text
@@ -614,3 +619,111 @@ void QOwnNotesMarkdownHighlighter::highlightSpellChecking(const QString &text) {
         }
     }
 }
+
+/**
+ * Stores LSP diagnostics in the block-keyed cache and triggers a rehighlight
+ * of every affected block so the underlines appear via QSyntaxHighlighter::setFormat(),
+ * exactly like the LanguageTool and Harper integrations.
+ */
+void QOwnNotesMarkdownHighlighter::setMarkdownLspDiagnostics(
+    const QVector<MarkdownLspClient::Diagnostic> &diagnostics) {
+    _lspDiagnosticsCache.clear();
+
+    for (const MarkdownLspClient::Diagnostic &diag : diagnostics) {
+        if (diag.message.isEmpty()) {
+            continue;
+        }
+
+        // Choose underline color based on LSP severity:
+        // 1 = Error, 2 = Warning, 3 = Information, 4 = Hint
+        QColor color;
+        switch (diag.severity) {
+            case 1:
+                color = QColor(214, 68, 68);    // Red for errors
+                break;
+            case 2:
+                color = QColor(210, 140, 30);    // Orange for warnings
+                break;
+            case 3:
+                color = QColor(80, 140, 210);    // Blue for information
+                break;
+            case 4:
+                color = QColor(100, 170, 100);    // Green for hints
+                break;
+            default:
+                color = QColor(214, 68, 68);
+                break;
+        }
+
+        // A diagnostic may span multiple lines; add an entry for every covered line
+        for (int line = diag.range.startLine; line <= diag.range.endLine; ++line) {
+            LspBlockDiagnostic entry;
+            entry.color = color;
+            entry.toolTip = diag.message;
+
+            if (line == diag.range.startLine && line == diag.range.endLine) {
+                entry.startCharacter = diag.range.startCharacter;
+                entry.endCharacter = diag.range.endCharacter;
+            } else if (line == diag.range.startLine) {
+                entry.startCharacter = diag.range.startCharacter;
+                entry.endCharacter = INT_MAX;    // Highlight to end of line
+            } else if (line == diag.range.endLine) {
+                entry.startCharacter = 0;
+                entry.endCharacter = diag.range.endCharacter;
+            } else {
+                entry.startCharacter = 0;
+                entry.endCharacter = INT_MAX;    // Highlight entire intermediate line
+            }
+
+            _lspDiagnosticsCache[line].append(entry);
+        }
+    }
+}
+
+/**
+ * Clears all cached LSP diagnostics.
+ */
+void QOwnNotesMarkdownHighlighter::clearMarkdownLspDiagnostics() { _lspDiagnosticsCache.clear(); }
+
+/**
+ * Applies wave underlines for LSP diagnostics on the current block via
+ * QSyntaxHighlighter::setFormat(), so they behave identically to spell-check
+ * and grammar-checker underlines (document-level, not view-level).
+ */
+void QOwnNotesMarkdownHighlighter::highlightMarkdownLsp(const QString &text) {
+    const int blockNumber = currentBlock().blockNumber();
+    const auto it = _lspDiagnosticsCache.constFind(blockNumber);
+    if (it == _lspDiagnosticsCache.constEnd()) {
+        return;
+    }
+
+    qDebug() << "LSP highlightMarkdownLsp: block" << blockNumber << "entries:" << it->size()
+             << "text:" << text.left(40);
+    for (const LspBlockDiagnostic &entry : *it) {
+        const int start = entry.startCharacter;
+        const int end = (entry.endCharacter == INT_MAX) ? text.length() : entry.endCharacter;
+        const int count = end - start;
+        if (count <= 0 || start >= text.length()) {
+            continue;
+        }
+        setMarkdownLspUnderline(start, qMin(count, text.length() - start), entry.color,
+                                entry.toolTip);
+    }
+}
+
+/**
+ * Applies a wave underline to a character range in the current block, merging
+ * with the existing per-character format to preserve syntax highlighting colors.
+ */
+void QOwnNotesMarkdownHighlighter::setMarkdownLspUnderline(int start, int count,
+                                                           const QColor &color,
+                                                           const QString &toolTip) {
+    for (int i = start; i < start + count; ++i) {
+        QTextCharFormat format = QSyntaxHighlighter::format(i);
+        format.setFontUnderline(true);
+        format.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
+        format.setUnderlineColor(color);
+        format.setToolTip(toolTip);
+        setFormat(i, 1, format);
+    }
+}

src/helpers/qownnotesmarkdownhighlighter.h

@@ -17,6 +17,7 @@
 
 #include <entities/note.h>
 #include <libraries/qmarkdowntextedit/markdownhighlighter.h>
+#include <services/markdownlspclient.h>
 
 #include <QHash>
 
@@ -41,6 +42,9 @@ class QOwnNotesMarkdownHighlighter : public MarkdownHighlighter {
 
     void updateCurrentNote(Note *note);
 
+    void setMarkdownLspDiagnostics(const QVector<MarkdownLspClient::Diagnostic> &diagnostics);
+    void clearMarkdownLspDiagnostics();
+
     struct ScriptingHighlightingRule {
         explicit ScriptingHighlightingRule(const HighlighterState state_) : state(state_) {}
         ScriptingHighlightingRule() = default;
@@ -69,6 +73,9 @@ class QOwnNotesMarkdownHighlighter : public MarkdownHighlighter {
     void highlightWikiLinks(const QString &text);
     void clearWikiLinkCache();
 
+    void highlightMarkdownLsp(const QString &text);
+    void setMarkdownLspUnderline(int start, int count, const QColor &color, const QString &toolTip);
+
     // Set the format of a word as misspelled i.e., red wavy underline
     void setMisspelled(const int start, const int count);
     void highlightSpellChecking(const QString &text);
@@ -93,6 +100,16 @@ class QOwnNotesMarkdownHighlighter : public MarkdownHighlighter {
     QRegularExpression _regexTagStyleLink;
     QRegularExpression _regexBracketLink;
     QHash<QString, bool> _wikiLinkCache;
+
+    // Cache of LSP diagnostics keyed by block (line) number.
+    // Each entry holds one or more diagnostics that touch that block.
+    struct LspBlockDiagnostic {
+        int startCharacter = 0;
+        int endCharacter = 0;
+        QColor color;
+        QString toolTip;
+    };
+    QHash<int, QVector<LspBlockDiagnostic>> _lspDiagnosticsCache;
     void highlightScriptingRules(const QVector<ScriptingHighlightingRule> &rules,
                                  const QString &text);
     void highlightScriptingHook(const QString &text);