feat: 完善代码填充；

Author: Wing-summer

CMakeLists.txt

@@ -312,7 +312,9 @@ set(CLASS_SRC
     src/class/consolehighlighanim.cpp
     src/class/angellsp.h
     src/class/angellsp.cpp
-    src/class/lsp.h)
+    src/class/lsp.h
+    src/class/resettabletimer.h
+    src/class/resettabletimer.cpp)
 
 set(INTERNAL_PLG_SRC
     src/class/wingangelapi.h src/class/wingangelapi.cpp
@@ -492,11 +494,13 @@ if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
                           ${PROJECT_SOURCES} ${app_icon_resource_windows})
     else()
         find_package(Qt6 REQUIRED COMPONENTS Widgets)
+        find_package(Qt6 REQUIRED COMPONENTS Core)
 
         qt_add_executable(WingHexExplorer2 MANUAL_FINALIZATION
                           ${PROJECT_SOURCES})
 
         target_link_libraries(WingHexExplorer2 PRIVATE Qt6::Widgets)
+        target_link_libraries(WingHexExplorer2 PRIVATE Qt6::Core)
     endif()
 endif()
 

src/class/angellsp.cpp

@@ -6,29 +6,7 @@
 #include <QJsonDocument>
 #include <QJsonObject>
 
-AngelLsp::AngelLsp() {
-    // create a single timer reused for completion debounce
-    m_completionTimer = new QTimer(this);
-    m_completionTimer->setSingleShot(true);
-    connect(m_completionTimer, &QTimer::timeout, this, [this]() {
-        // before sending new completion, cancel previous pending request if any
-        if (m_lastCompletionRequestId != 0) {
-            sendCancelRequest(m_lastCompletionRequestId);
-            // do not reset id here; server may already have processed it
-        }
-        // send actual completion request (async, id returned)
-        QJsonObject pos;
-        pos["line"] = m_pendingCompletion.line;
-        pos["character"] = m_pendingCompletion.character;
-        QJsonObject p;
-        p["textDocument"] = QJsonObject{{"uri", m_pendingCompletion.uri}};
-        p["position"] = pos;
-        int id = sendRequest("textDocument/completion", p);
-        m_lastCompletionRequestId = id;
-        // response will be delivered to handleIncomingMessage ->
-        // requestFinished signal
-    });
-}
+AngelLsp::AngelLsp() {}
 
 AngelLsp &AngelLsp::instance() {
     static AngelLsp ins;
@@ -227,9 +205,9 @@ QJsonValue AngelLsp::requestResolve(const QJsonValue &symbol, int timeoutMs) {
     return sendRequestSync("completionItem/resolve", symbol, timeoutMs);
 }
 
-int AngelLsp::sendRequest(const QString &method, const QJsonValue &params,
-                          int) {
-    int id = m_nextId++;
+qint64 AngelLsp::sendRequest(const QString &method, const QJsonValue &params,
+                             int) {
+    qint64 id = m_nextId++;
     QJsonObject obj;
     obj["jsonrpc"] = "2.0";
     obj["id"] = id;
@@ -261,7 +239,7 @@ void AngelLsp::changeDocument(const QString &uri, qint64 version,
 
 QJsonValue AngelLsp::sendRequestSync(const QString &method,
                                      const QJsonValue &params, int timeoutMs) {
-    int id = m_nextId++;
+    qint64 id = m_nextId++;
     QJsonObject obj;
     obj["jsonrpc"] = "2.0";
     obj["id"] = id;
@@ -480,20 +458,6 @@ void AngelLsp::handleIncomingMessage(const QJsonObject &msg) {
             m_outstandingRequests.remove(id);
         }
 
-        // if this response is for a completion request, emit completionReceived
-        if (!method.isEmpty() &&
-            method == QStringLiteral("textDocument/completion")) {
-            Q_EMIT completionReceived(payload);
-            // if it matches the last completion id, clear it
-            if (m_lastCompletionRequestId == id)
-                m_lastCompletionRequestId = 0;
-        }
-        // if response matches lastCompletionRequestId but method mapping not
-        // present, still check and clear
-        if (m_lastCompletionRequestId == id) {
-            m_lastCompletionRequestId = 0;
-        }
-
         if (m_pendingLoops.contains(id)) {
             QEventLoop *loop = m_pendingLoops[id];
             if (loop)
@@ -640,14 +604,3 @@ QJsonObject AngelLsp::jsonLSPDocLocation(const LSP::Location &loc) {
     r["character"] = loc.character;
     return r;
 }
-
-void AngelLsp::requestCompletionDebounced(const QString &uri, int line,
-                                          int character, int debounceMs) {
-    // store latest requested position
-    m_pendingCompletion.uri = uri;
-    m_pendingCompletion.line = line;
-    m_pendingCompletion.character = character;
-    // restart debounce timer
-    m_completionTimer->stop();
-    m_completionTimer->start(debounceMs);
-}

src/class/angellsp.h

@@ -37,13 +37,6 @@ class AngelLsp : public QObject {
 
     void closeDocument(const QString &uri);
 
-public:
-    // Debounced completion: if user types quickly, use this so only one
-    // completion fires after pause. debounceMs default 150ms (tweak to taste:
-    // smaller for snappier UI, larger to reduce server load).
-    void requestCompletionDebounced(const QString &uri, int line, int character,
-                                    int debounceMs = 150);
-
 public:
     // High-level feature wrappers (sync)
     QJsonValue requestDocumentSymbol(const QString &uri, int timeoutMs = 3000);
@@ -65,9 +58,9 @@ class AngelLsp : public QObject {
 private:
     // Generic request/notification
     // Returns request id
-    int sendRequest(const QString &method,
-                    const QJsonValue &params = QJsonValue(),
-                    int /*timeoutMs*/ = 0);
+    qint64 sendRequest(const QString &method,
+                       const QJsonValue &params = QJsonValue(),
+                       int /*timeoutMs*/ = 0);
 
     // Blocking request
     QJsonValue sendRequestSync(const QString &method,
@@ -105,11 +98,6 @@ class AngelLsp : public QObject {
     void serverRequestReceived(const QString &method, const QJsonValue &params,
                                int id);
 
-    // New: emitted when a completion response arrives from server (either
-    // result or error). items: the "result" (or "error" if no result). For
-    // typical successful completion, items is the completion list/array.
-    void completionReceived(const QJsonValue &items);
-
 public slots:
     // convenience: synchronous shutdown
     void shutdownAndExit();
@@ -136,23 +124,14 @@ private slots:
     QProcess *m_proc = nullptr;
     QByteArray m_stdoutBuffer;
 
-    int m_nextId = 1;
-    QMap<int, QEventLoop *> m_pendingLoops;
-    QMap<int, QJsonValue> m_pendingResponses;
+    qint64 m_nextId = 1;
+    QMap<qint64, QEventLoop *> m_pendingLoops;
+    QMap<qint64, QJsonValue> m_pendingResponses;
 
-    QMap<int, QString> m_outstandingRequests; // map request id -> method
+    QMap<qint64, QString> m_outstandingRequests; // map request id -> method
 
     // Debounce/coalesce document change support
     QHash<QString, QTimer *> m_docTimers; // per-document debouncers
-
-    // Debounced completion support
-    QTimer *m_completionTimer = nullptr;
-    struct PendingCompletion {
-        QString uri;
-        int line = 0;
-        int character = 0;
-    } m_pendingCompletion;
-    int m_lastCompletionRequestId = 0;
 };
 
 #endif // ANGELLSP_H

src/class/ascompletion.cpp

@@ -82,6 +82,10 @@ AsCompletion::AsCompletion(WingCodeEdit *p) : WingCompleter(p) {
             });
 
     p->installEventFilter(this);
+
+    _timer = new ResettableTimer(this);
+    connect(_timer, &ResettableTimer::timeoutTriggered, this,
+            &AsCompletion::onCodeComplete);
 }
 
 AsCompletion::~AsCompletion() {}
@@ -140,6 +144,10 @@ bool AsCompletion::processTrigger(const QString &trigger,
         clearFunctionTip();
     }
 
+    if (!_ok) {
+        return false;
+    }
+
     auto url = Utilities::getUrlString(editor->fileName());
     auto tc = editor->editor()->textCursor();
     auto &lsp = AngelLsp::instance();
@@ -171,10 +179,10 @@ bool AsCompletion::processTrigger(const QString &trigger,
 
     auto ret = lsp.requestCompletion(url, line, character);
     auto nodes = parseCompletion(ret);
-
-    // TODO
     setModel(new CodeCompletionModel(nodes, this));
     setCompletionPrefix(prefix);
+    _ok = false;
+    _timer->reset(300);
 
     return true;
 }
@@ -203,3 +211,5 @@ bool AsCompletion::eventFilter(QObject *watched, QEvent *event) {
     }
     return WingCompleter::eventFilter(watched, event);
 }
+
+void AsCompletion::onCodeComplete() { _ok = true; }

src/class/ascompletion.h

@@ -20,6 +20,7 @@
 
 #include "WingCodeEdit/wingcompleter.h"
 #include "class/codeinfotip.h"
+#include "class/resettabletimer.h"
 
 class AsCompletion : public WingCompleter {
     Q_OBJECT
@@ -50,8 +51,14 @@ class AsCompletion : public WingCompleter {
 public:
     virtual bool eventFilter(QObject *watched, QEvent *event) override;
 
+private slots:
+    void onCodeComplete();
+
 private:
     QList<CodeInfoTip> _keywordNode;
+    ResettableTimer *_timer;
+
+    bool _ok = true;
 };
 
 #endif // _CPP_COMPLETION_H_

src/class/resettabletimer.cpp

@@ -0,0 +1,81 @@
+/*==============================================================================
+** Copyright (C) 2024-2027 WingSummer
+**
+** This program is free software: you can redistribute it and/or modify it under
+** the terms of the GNU Affero General Public License as published by the Free
+** Software Foundation, version 3.
+**
+** This program is distributed in the hope that it will be useful, but WITHOUT
+** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+** FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+** details.
+**
+** You should have received a copy of the GNU Affero General Public License
+** along with this program. If not, see <https://www.gnu.org/licenses/>.
+** =============================================================================
+*/
+
+#include "resettabletimer.h"
+
+#include <QDebug>
+
+ResettableTimer::ResettableTimer(QObject *parent) : QObject(parent) {
+    m_timer.setSingleShot(true);
+    connect(&m_timer, &QTimer::timeout, this, &ResettableTimer::onTimeout);
+}
+
+void ResettableTimer::start(int intervalMs) {
+    if (intervalMs <= 0) {
+        qWarning()
+            << "ResettableTimer::start called with non-positive interval:"
+            << intervalMs;
+        return;
+    }
+    m_intervalMs = intervalMs;
+    m_timer.start(m_intervalMs);
+}
+
+void ResettableTimer::reset(int newIntervalMs) {
+    if (newIntervalMs > 0) {
+        m_intervalMs = newIntervalMs;
+    }
+
+    if (m_intervalMs <= 0) {
+        // nothing to start/restart
+        qWarning() << "ResettableTimer::reset called but interval not set.";
+        return;
+    }
+
+    // restart works even if timer was about to fire
+    m_timer.start(m_intervalMs);
+}
+
+void ResettableTimer::stop() { m_timer.stop(); }
+
+void ResettableTimer::triggerNow() {
+    // Stop current timer (if running) then immediately call handler
+    m_timer.stop();
+    onTimeout();
+}
+
+bool ResettableTimer::isActive() const { return m_timer.isActive(); }
+
+int ResettableTimer::interval() const { return m_intervalMs; }
+
+void ResettableTimer::setInterval(int intervalMs) {
+    if (intervalMs <= 0) {
+        qWarning() << "ResettableTimer::setInterval non-positive:"
+                   << intervalMs;
+        return;
+    }
+    m_intervalMs = intervalMs;
+    if (m_timer.isActive()) {
+        // restart with new interval
+        m_timer.start(m_intervalMs);
+    }
+}
+
+void ResettableTimer::onTimeout() {
+    // Timer single-shot -> it's stopped now.
+    Q_EMIT timeoutTriggered();
+}

src/class/resettabletimer.h

@@ -0,0 +1,63 @@
+/*==============================================================================
+** Copyright (C) 2024-2027 WingSummer
+**
+** This program is free software: you can redistribute it and/or modify it under
+** the terms of the GNU Affero General Public License as published by the Free
+** Software Foundation, version 3.
+**
+** This program is distributed in the hope that it will be useful, but WITHOUT
+** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+** FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+** details.
+**
+** You should have received a copy of the GNU Affero General Public License
+** along with this program. If not, see <https://www.gnu.org/licenses/>.
+** =============================================================================
+*/
+
+#ifndef RESETTABLETIMER_H
+#define RESETTABLETIMER_H
+
+#include <QObject>
+
+#include <QObject>
+#include <QTimer>
+
+class ResettableTimer : public QObject {
+    Q_OBJECT
+public:
+    explicit ResettableTimer(QObject *parent = nullptr);
+
+public slots:
+    // Start with specified interval (ms). Replaces saved interval.
+    void start(int intervalMs);
+
+    // Reset (restart) with previously set interval.
+    // If newIntervalMs >= 0, update interval and restart with it.
+    void reset(int newIntervalMs = -1);
+
+    // Stop the timer (no callback until start/reset again).
+    void stop();
+
+    // Force immediate trigger (calls callback / emits signal).
+    void triggerNow();
+
+    void setInterval(int intervalMs);
+
+public:
+    bool isActive() const;
+    int interval() const;
+
+signals:
+    // Emitted when timeout happens.
+    void timeoutTriggered();
+
+private slots:
+    void onTimeout();
+
+private:
+    QTimer m_timer;
+    int m_intervalMs = 0; // last used interval in ms
+};
+
+#endif // RESETTABLETIMER_H