From e6b7bf66ecb28de454f564b9fc867da0ba5d771d Mon Sep 17 00:00:00 2001
From: "DeepSeek V4.1 Flash" <>
Date: Fri, 16 Oct 2026 04:02:36 +0800
Subject: [PATCH] =?UTF-8?q?=E6=8C=89=E7=BB=84=E4=BB=B6=E7=9B=AE=E5=BD=95?=
 =?UTF-8?q?=E7=BB=93=E6=9E=84=E6=8A=8A=E5=9B=9B=E4=B8=AA=E5=B7=A8=E5=9E=8B?=
 =?UTF-8?q?=E5=AE=9E=E7=8E=B0=E6=96=87=E4=BB=B6=E6=8B=86=E5=88=86=E4=B8=BA?=
 =?UTF-8?q?=E5=A4=9A=E4=B8=AA=E5=8D=8F=E4=BD=9C=E6=96=87=E4=BB=B6=EF=BC=88?=
 =?UTF-8?q?PlotView=20/=20SignalPanel=20/=20Application=20/=20DataModel?=
 =?UTF-8?q?=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

承接上一条提交（0871eb0）—— 该提交只完成了 Components/Shared 与注释/命名清理，并**主动未做**
大文件拆分；本提交把大文件拆分补齐，至此“按功能拆分逻辑块到各组件自己的 Inc/Src”已落地。

## 一、拆分结果

| 原文件 | 拆分后 |
| --- | --- |
| Components/PlotView/Src/PlotView.cpp（13 695 行 / 544 KB） | PlotView.cpp(787) + PlotViewPaint.cpp(6 367) + PlotViewInteraction.cpp(2 715) + PlotViewFeatures.cpp(3 005) + PlotViewInternal.hpp(936) |
| Components/SignalPanel/Src/SignalPanel.cpp（4 184 行） | SignalPanel.cpp(1 141) + SignalPanelPaint.cpp(697) + SignalPanelInteraction.cpp(2 095) + SignalPanelInternal.hpp |
| Components/Application/Src/Application.cpp（3 135 行） | Application.cpp(1 427) + ApplicationCommands.cpp(1 184) + ApplicationLoading.cpp(270) + ApplicationInternal.hpp |
| Utilities/Src/DataModel.cpp（2 615 行） | DataModel.cpp(1 583，含自由函数区) + DataModelTab.cpp(732) + DataModelInternal.hpp |

分片职责（以 PlotView 为例）：
  core        视图核心：构造/析构、上下文、布局、坐标映射、视界与平移、网格结构与归属
  paint       渲染与像素缓存：全部绘制、场景/装饰缓存、每网格图层、宽基底与滚动补条
  interaction 交互与编辑：命中测试、鼠标/键盘、光标形状、内联输入框、浮动面板层序
  features    视图特性与派生数据：光标读数/提示/缩放、自适应、吸附、单点、派生曲线线程池、
              边沿统计、实验性功能参数
（SignalPanel 为 core/paint/interaction；Application 为 core/commands/loading；
  DataModel 为 core/tab。）

## 二、关键手法（这是能安全拆开的前提）

原文件的辅助区都是**匿名命名空间**（PlotView 约 870 行常量与工具函数），被所有成员函数广泛引用。
直接拆文件会让各 .cpp 拿不到这些工具，因此：

1. 把该块整块搬进 `<组件>Internal.hpp`，从 `namespace { }` 改为**具名**命名空间
   （pvdetail / spdetail / appdetail / dmdetail）；
2. 块内**每个函数与常量都标 inline** ⇒ 多个翻译单元共用同一个定义：既不重复符号，
   也不产生 N 份函数定义；
3. 头部末尾 `using namespace <ns>;` ⇒ 各 .cpp 函数体里原有的非限定调用（IntersectRect /
   NiceStep / ClampDouble …）**一行都不用改**；
4. 成员定义按「方法名 → 分片」归类后**整块搬移** —— 全程**纯代码搬移**，没有改动任何一行函数体。

## 三、拆分过程中踩到并修正的四个坑（已固化到 .preflight/perf/split_component.ps1）

1. `[[maybe_unused]]` 等属性**必须排在 inline 之前**（`inline [[x]] T` 非法）；
   单独的 `{`/`}` 行、注释行、`struct`/`enum`/`using`/`template` 行不能加 inline。
2. 匿名命名空间的**结束行可能带注释**（`} // namespace`），只认 `^\t}$` 会一路匹配到后面
   某个成员函数的结束括号，把大段成员定义误当成“辅助区”搬走。
3. **首个成员定义之前的所有行**必须跟着进核心文件：DataModel.cpp 在匿名命名空间之后、
   首个成员定义之前还有约 390 行命名空间外的自由函数（SignalStats / ComputeStats /
   CacheSparseSamples / ApplySinglePointDefaultStyle …），漏掉会被静默丢弃。
4. 内部头必须带上原文件真正用到的全部头：DataModel 需要 Theme.hpp / <cstring> / <cstdio> /
   <deque> / <atomic> / <cwctype> / <new>（原文件靠这些头才编译得过）。

## 四、附带完成的命名审计

PlotView 中残留的 File 语义命名一并修正：LaneSpansMultipleFiles → LaneSpansMultipleGroups、
firstFile → firstGroup、multiFile → multiGroup、SceneCacheKey::haloFile → haloGroup。

## 五、验证（全部离屏：SW_HIDE + 不注入真实输入 + 进程/线程 BELOW_NORMAL）

- .preflight/perf/verify.exe（PlotView 渲染/交互，含逐像素断言）49/49
- .preflight/perf/panelanim.exe（信号面板：卷尺式折起/展开、筛选态、悬浮组名、目标行）156/156
- .preflight/perf/datacheck.exe（数据层：单轴/多时间轴 CSV、MF4、重命名语义）69/69
- .preflight/perf/edgecheck.exe（边沿统计与面板排版）46/46
- make release / make debug 零警告。
即：拆分后**行为与拆分前完全一致**（纯代码搬移，四套探针全绿）。

## 六、体积（诚实记录）

  Target.exe: 754 176 → 764 416 B（+10 240 B，+1.4%）
因为 inline 工具函数会在每个引用它的翻译单元里各生成一份（PE/COFF 链接器没有 ICF 合并）。
这再次印证：拆分解决的是**可维护性**，不是体积（本轮的 −24.6% 全部来自 ICO 256×256 条目改 PNG）。

## 七、文档

Documents/agent_mem.md：§9.37 新增“七、多文件拆分（已完成）”与“八、仍未完成”（只剩
Lane → LanePanelState、模态提示解耦、MF4 压缩块三项）；§11.2 新增第 91、92 条（多文件化的
唯一安全手法 + 体积代价）。Documents/refactor_report_2026-10-16.md 同步更新 §五/§七/§八。
---
 Components/Application/Src/Application.cpp    |  1720 +-
 .../Application/Src/ApplicationCommands.cpp   |  1184 ++
 .../Application/Src/ApplicationInternal.hpp   |   312 +
 .../Application/Src/ApplicationLoading.cpp    |   270 +
 Components/PlotView/Inc/PlotView.hpp          |     4 +-
 Components/PlotView/Src/PlotView.cpp          | 12945 +---------------
 Components/PlotView/Src/PlotViewFeatures.cpp  |  3005 ++++
 .../PlotView/Src/PlotViewInteraction.cpp      |  2715 ++++
 Components/PlotView/Src/PlotViewInternal.hpp  |   932 ++
 Components/PlotView/Src/PlotViewPaint.cpp     |  6365 ++++++++
 Components/SignalPanel/Src/SignalPanel.cpp    |  3054 +---
 .../Src/SignalPanelInteraction.cpp            |  2095 +++
 .../SignalPanel/Src/SignalPanelInternal.hpp   |   316 +
 .../SignalPanel/Src/SignalPanelPaint.cpp      |   697 +
 Documents/agent_mem.md                        |    60 +-
 Documents/refactor_report_2026-10-16.md       |    99 +-
 Utilities/Src/DataModel.cpp                   |  1044 +-
 Utilities/Src/DataModelInternal.hpp           |   352 +
 Utilities/Src/DataModelTab.cpp                |   732 +
 19 files changed, 19130 insertions(+), 18771 deletions(-)
 create mode 100644 Components/Application/Src/ApplicationCommands.cpp
 create mode 100644 Components/Application/Src/ApplicationInternal.hpp
 create mode 100644 Components/Application/Src/ApplicationLoading.cpp
 create mode 100644 Components/PlotView/Src/PlotViewFeatures.cpp
 create mode 100644 Components/PlotView/Src/PlotViewInteraction.cpp
 create mode 100644 Components/PlotView/Src/PlotViewInternal.hpp
 create mode 100644 Components/PlotView/Src/PlotViewPaint.cpp
 create mode 100644 Components/SignalPanel/Src/SignalPanelInteraction.cpp
 create mode 100644 Components/SignalPanel/Src/SignalPanelInternal.hpp
 create mode 100644 Components/SignalPanel/Src/SignalPanelPaint.cpp
 create mode 100644 Utilities/Src/DataModelInternal.hpp
 create mode 100644 Utilities/Src/DataModelTab.cpp

diff --git a/Components/Application/Src/Application.cpp b/Components/Application/Src/Application.cpp
index 2f640c5..ef009f0 100644
--- a/Components/Application/Src/Application.cpp
+++ b/Components/Application/Src/Application.cpp
@@ -1,291 +1,12 @@
-#include "Application.hpp"
-
-#include <algorithm>
-#include <atomic>
-#include <cmath>
-#include <thread>
-
-#include <commdlg.h>
-#include <psapi.h>
-#include <shellapi.h>
-#include <windowsx.h>
-
-#include "DataLoader.hpp"
-#include "ResourceIds.h"
-#include "Utf8Util.hpp"
-
-#ifndef WM_DPICHANGED
-#define WM_DPICHANGED 0x02E0
-#endif
-
-#ifndef DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
-#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 (reinterpret_cast<HANDLE>(-4))
-#endif
+// Application 实现分片 —— 本文件只包含 Application 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 ApplicationInternal.hpp（命名空间 `appdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "ApplicationInternal.hpp"
 
 namespace jdi
 {
 
-	namespace
-	{
-		const wchar_t* kWindowClassName = L"JustDataInspectorMainWindow";	/**< 窗口类名。 */
-		const wchar_t* kWindowTitle = L"Just DataInspector";				/**< 窗口标题中的应用名称部分。 */
-		/**
-		 * @brief 应用名称与内存占用之间的分隔竖线。
-		 *
-		 * 与信号分组标题里「组X ｜ 组名」的分隔方式一致：竖线两侧各留出空隙
-		 *（`kGroupSeparatorGap` 是那个分隔线的左右间距，这里用两个空格达到同等观感）。
-		 */
-		const wchar_t* kTitleSeparator = L"  |  ";
-		/** @brief 内存占用的显示前缀（与具体数值之间保留一个空格）。 */
-		const wchar_t* kRamTitlePrefix = L"RAM ： ";
-		const float kSplitterWidth = 4.0f;									/**< 分隔条宽度（逻辑像素）。 */
-		const float kMinPanelWidth = 260.0f;								/**< 面板最小宽度（逻辑像素）。 */
-		const float kMaxPanelWidth = 400.0f;								/**< 面板最大宽度（逻辑像素）。 */
-		const int kMinClientWidth = 860;									/**< 窗口最小客户区宽度。 */
-		const int kMinClientHeight = 540;									/**< 窗口最小客户区高度。 */
-		const UINT kMessageRemoveGroup = WM_APP + 1;							/**< 面板请求移除分组的自定义消息。 */
-		const UINT kMessageRemoveSignal = WM_APP + 2;						/**< 面板请求移除单个信号的自定义消息。 */
-		const UINT_PTR kHintTimerId = 1;									/**< 提示浮层淡出用的定时器 ID。 */
-		const UINT kHintTimerPeriodMs = 33;									/**< 提示浮层淡出的重绘间隔（约 30fps）。 */
-		const UINT_PTR kRamTimerId = 2;									/**< 标题栏内存占用刷新的定时器 ID。 */
-		const UINT kRamTimerPeriodMs = 1000;								/**< 标题栏内存占用的刷新间隔（1 秒）。 */
-		/**
-		 * @brief 信号列表「滚动到目标信号」动画的定时器 ID。
-		 *
-		 * 用户 2026-10-15 要求：联动时列表要**平滑滚动**（不是立刻翻到目标位置），
-		 * 且"整个动画过程不要太久"。动画本身由 `SignalPanel::AdvanceScrollAnimation()`
-		 * 按经过时间推进，这里只负责按帧驱动它（约 60fps）。
-		 */
-		const UINT_PTR kScrollTimerId = 3;
-		const UINT kScrollTimerPeriodMs = 16;
-
-		/**
-		 * @brief 查询本进程当前占用的内存（**私有工作集**，与任务管理器"内存"列同口径）。
-		 *
-		 * ⚠️ 原先取的是 `PROCESS_MEMORY_COUNTERS::WorkingSetSize`（**总工作集**），它把映射进来的
-		 * DLL / 共享页面以及已经释放但尚未被系统回收的驻留页面都算进去 —— 加载一个大文件再
-		 * 关闭分组后，实际占用的私有内存已经回到几 MB，标题栏却还显示几十 MB，
-		 * 与任务管理器（资源管理器里看到的"内存"）对不上（用户报告）。
-		 * `PROCESS_MEMORY_COUNTERS_EX2::PrivateWorkingSetSize` 正是任务管理器"内存"列的口径：
-		 * 只统计**属于本进程的私有、且驻留在物理内存中**的页面。
-		 *
-		 * 结构体在这里就地声明（MinGW 的 psapi.h 未提供 `PROCESS_MEMORY_COUNTERS_EX2`），
-		 * 布局与 Win32 文档一致；EX2 查询失败（老系统）时退回 `PrivateUsage`（私有提交），
-		 * 再不行退回 `WorkingSetSize`，保证标题栏永远有值。
-		 *
-		 * @return 内存占用字节数；查询失败返回 0。
-		 */
-		unsigned long long ProcessPrivateWorkingSetBytes()
-		{
-			struct MemoryCountersEx2
-			{
-				DWORD cb;
-				DWORD PageFaultCount;
-				SIZE_T PeakWorkingSetSize;
-				SIZE_T WorkingSetSize;
-				SIZE_T QuotaPeakPagedPoolUsage;
-				SIZE_T QuotaPagedPoolUsage;
-				SIZE_T QuotaPeakNonPagedPoolUsage;
-				SIZE_T QuotaNonPagedPoolUsage;
-				SIZE_T PagefileUsage;
-				SIZE_T PeakPagefileUsage;
-				SIZE_T PrivateUsage;
-				SIZE_T PrivateWorkingSetSize;
-				SIZE_T SharedCommitUsage;
-			};
-
-			MemoryCountersEx2 ex2 = {};
-			ex2.cb = sizeof(ex2);
-			if (K32GetProcessMemoryInfo(GetCurrentProcess(),
-			                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&ex2),
-			                            sizeof(ex2)) != FALSE &&
-			    ex2.PrivateWorkingSetSize > 0)
-			{
-				return static_cast<unsigned long long>(ex2.PrivateWorkingSetSize);
-			}
-
-			PROCESS_MEMORY_COUNTERS_EX counters = {};
-			counters.cb = sizeof(counters);
-			if (K32GetProcessMemoryInfo(GetCurrentProcess(),
-			                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&counters),
-			                            sizeof(counters)) == FALSE)
-			{
-				return 0ull;
-			}
-			if (counters.PrivateUsage > 0)
-			{
-				return static_cast<unsigned long long>(counters.PrivateUsage);
-			}
-			return static_cast<unsigned long long>(counters.WorkingSetSize);
-		}
-
-		/**
-		 * @brief 只失效绘图区所在的矩形。
-		 *
-		 * 配合 WM_PAINT 中对更新区域的判断，可以走“只重绘、只回送绘图区”的快路径；
-		 * 绘图区矩形无效时退化为整窗失效，保证不会漏画。
-		 *
-		 * @param [IN] hwnd 窗口句柄。
-		 * @param [IN] plotRect 绘图区矩形（客户区坐标）。
-		 */
-		void InvalidatePlotRect(HWND hwnd, const gd::RectF& plotRect)
-		{
-			RECT invalid = {};
-			invalid.left = static_cast<LONG>(std::floor(plotRect.X));
-			invalid.top = static_cast<LONG>(std::floor(plotRect.Y));
-			invalid.right = static_cast<LONG>(std::ceil(plotRect.X + plotRect.Width));
-			invalid.bottom = static_cast<LONG>(std::ceil(plotRect.Y + plotRect.Height));
-			if (invalid.right > invalid.left && invalid.bottom > invalid.top)
-			{
-				InvalidateRect(hwnd, &invalid, FALSE);
-			}
-			else
-			{
-				InvalidateRect(hwnd, nullptr, FALSE);
-			}
-		}
-
-		/** @brief 标签页右键菜单命令 ID。 */
-		const int kMenuTabNew = 1;
-		const int kMenuTabClose = 2;
-		const int kMenuTabCloseOthers = 3;
-
-		/**
-		 * @brief 从应用资源中按指定尺寸加载图标。
-		 * @param [IN] cx 期望宽度（像素）。
-		 * @param [IN] cy 期望高度（像素）。
-		 * @return 图标句柄，加载失败返回 nullptr。
-		 */
-		HICON LoadAppIcon(int cx, int cy)
-		{
-			HINSTANCE module = GetModuleHandleW(nullptr);
-			// LR_DEFAULTSIZE 之外的显式尺寸请求会挑选 ICO 中最接近的一帧并由系统缩放，
-			// 因此 256/64/48/32/16 的多尺寸资源在任意 DPI 下都能取到合适的一帧。
-			HICON icon = static_cast<HICON>(LoadImageW(module, MAKEINTRESOURCEW(IDI_APP_ICON), IMAGE_ICON,
-			                                           cx, cy, LR_DEFAULTCOLOR));
-			if (icon == nullptr)
-			{
-				icon = static_cast<HICON>(LoadImageW(module, MAKEINTRESOURCEW(IDI_APP_ICON), IMAGE_ICON, 0, 0,
-				                                     LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
-			}
-			return icon;
-		}
-
-		/**
-		 * @brief 后台加载任务的共享状态。
-		 *
-		 * `done` 是唯一的同步点：工作线程写完其它字段后以 release 语义置位，
-		 * 主线程以 acquire 语义读取，因此无需额外锁。
-		 */
-		struct AsyncLoadState
-		{
-			std::atomic<bool> done{false};		/**< 工作线程是否已结束。 */
-			std::atomic<bool> cancelled{false};	/**< 是否请求取消。 */
-			std::atomic<float> progress{0.0f};	/**< 0-1 进度。 */
-			std::atomic<unsigned long long> bytesRead{0}; /**< 已读取字节数（解析阶段）。 */
-			std::atomic<unsigned long long> totalBytes{0}; /**< 文件总字节数（0 表示未知）。 */
-			bool ok = false;					/**< 加载是否成功。 */
-			std::wstring error;					/**< 失败原因。 */
-			SignalGroup group;						/**< 构建结果。 */
-		};
-
-		/**
-		 * @brief 工作线程主体：按扩展名选择加载器读入文件并构建信号分组（不接触 DataSet）。
-		 * @param [IN,OUT] state 共享状态。
-		 * @param [IN] path 文件路径。
-		 * @param [IN] paletteBase 调色板起始序号。
-		 */
-		void RunAsyncLoad(AsyncLoadState* state, std::wstring path, std::size_t paletteBase)
-		{
-			// 解析阶段占总进度的 0-75%，列重组与统计占 75-100%。
-			LoadProgress parseProgress = [state](const LoadProgressInfo& info)
-			{
-				state->progress.store(static_cast<float>(info.ratio * 0.75), std::memory_order_relaxed);
-				if (info.hasBytes)
-				{
-					state->bytesRead.store(info.bytesRead, std::memory_order_relaxed);
-					state->totalBytes.store(info.totalBytes, std::memory_order_relaxed);
-				}
-				return !state->cancelled.load(std::memory_order_relaxed);
-			};
-
-			LoadedSource source;
-			std::wstring error;
-			if (!LoadSignalSource(path, source, error, parseProgress))
-			{
-				state->error = error;
-				state->done.store(true, std::memory_order_release);
-				return;
-			}
-
-			LoadProgress buildProgress = [state](const LoadProgressInfo& info)
-			{
-				state->progress.store(static_cast<float>(0.75 + info.ratio * 0.25),
-				                      std::memory_order_relaxed);
-				return !state->cancelled.load(std::memory_order_relaxed);
-			};
-
-			SignalGroup group;
-			if (!BuildSignalGroup(std::move(source), paletteBase, group, error, buildProgress))
-			{
-				state->error = error;
-				state->done.store(true, std::memory_order_release);
-				return;
-			}
-
-			state->group = std::move(group);
-			state->ok = true;
-			state->progress.store(1.0f, std::memory_order_relaxed);
-			state->done.store(true, std::memory_order_release);
-		}
-
-		/**
-		 * @brief 开启进程级 DPI 感知（优先 Per-Monitor V2）。
-		 */
-		void EnableDpiAwareness()
-		{
-			HMODULE user32 = GetModuleHandleW(L"user32.dll");
-			if (user32 != nullptr)
-			{
-				typedef BOOL(WINAPI * SetProcessDpiAwarenessContextFn)(HANDLE);
-				SetProcessDpiAwarenessContextFn setContext =
-				    reinterpret_cast<SetProcessDpiAwarenessContextFn>(
-				        reinterpret_cast<void*>(GetProcAddress(user32, "SetProcessDpiAwarenessContext")));
-				if (setContext != nullptr && setContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) != FALSE)
-				{
-					return;
-				}
-			}
-			SetProcessDPIAware();
-		}
-
-		/**
-		 * @brief 查询屏幕 DPI。
-		 * @return DPI 数值，失败时返回 96。
-		 */
-		UINT QuerySystemDpi()
-		{
-			HDC hdc = GetDC(nullptr);
-			if (hdc == nullptr)
-			{
-				return 96u;
-			}
-			const int dpi = GetDeviceCaps(hdc, LOGPIXELSX);
-			ReleaseDC(nullptr, hdc);
-			return (dpi > 0) ? static_cast<UINT>(dpi) : 96u;
-		}
-
-		/**
-		 * @brief 依据 DPI 缩放逻辑像素。
-		 * @param [IN] value 逻辑像素值。
-		 * @param [IN] scale 缩放比例。
-		 * @return 物理像素值。
-		 */
-		float ScaleOf(float value, float scale)
-		{
-			return value * scale;
-		}
-	}
 
 	Application& Application::Instance()
 	{
@@ -503,23 +224,6 @@ namespace jdi
 		return m_tabs[static_cast<std::size_t>(m_activeTab)];
 	}
 
-	void Application::NewTab(bool collapseGroups)
-	{
-		TabConfig tab;
-		tab.SetName(NextTabName());
-		// 用户新建的标签页：信号分组**默认折起**（用户明确要求：列表默认紧凑；
-		// 之后在该标签页里新加载的分组也沿用这个默认值）。
-		tab.SetGroupsCollapsedByDefault(collapseGroups);
-		tab.SyncToDataSet(m_dataSet);
-		if (collapseGroups)
-		{
-			tab.SetAllCollapsed(true);
-		}
-
-		m_tabs.push_back(std::move(tab));
-		SetActiveTab(static_cast<int>(m_tabs.size()) - 1);
-	}
-
 	std::wstring Application::NextTabName() const
 	{
 		// 取当前未被占用的最小编号，使关闭标签页后编号可以被复用（3 开 2 关再新建回到「视图 2」）。
@@ -543,200 +247,6 @@ namespace jdi
 		return L"视图 " + std::to_wstring(m_tabs.size() + 1);
 	}
 
-	void Application::CloseTab(int index)
-	{
-		if (index < 0 || index >= static_cast<int>(m_tabs.size()))
-		{
-			return;
-		}
-		if (m_tabs.size() <= 1)
-		{
-			SetStatusMessage(L"至少需要保留一个标签页。", true);
-			return;
-		}
-
-		m_tabs.erase(m_tabs.begin() + index);
-
-		int next = index;
-		if (next >= static_cast<int>(m_tabs.size()))
-		{
-			next = static_cast<int>(m_tabs.size()) - 1;
-		}
-		SetActiveTab(next);
-	}
-
-	void Application::SetActiveTab(int index)
-	{
-		if (index < 0 || index >= static_cast<int>(m_tabs.size()))
-		{
-			return;
-		}
-
-		m_activeTab = index;
-
-		// 重新绑定上下文：面板与绘图区均指向同一数据层与当前标签页配置。
-		m_panel.SetContext(&m_dataSet, &m_tabs[static_cast<std::size_t>(m_activeTab)]);
-		m_plot.SetContext(&m_dataSet, &m_tabs[static_cast<std::size_t>(m_activeTab)]);
-
-		RefreshTabBar();
-		Relayout();
-
-		// 切换标签页后把该页已选中的信号滚动到可见位置。
-		// 切换标签页后把共享的选中信号滚动到可见位置（选中状态跨页保持一致）。
-		m_panel.ScrollToSignal(m_dataSet.Selected());
-
-		SynchronizeView(true);
-		UpdateWindowTitle();
-		InvalidateRect(m_hwnd, nullptr, TRUE);
-	}
-
-	void Application::RefreshTabBar()
-	{
-		std::vector<std::wstring> names;
-		names.reserve(m_tabs.size());
-		for (const TabConfig& tab : m_tabs)
-		{
-			names.push_back(tab.Name());
-		}
-		m_tabBar.SetTabs(names);
-		m_tabBar.SetActiveIndex(m_activeTab);
-	}
-
-	void Application::SynchronizeView(bool force)
-	{
-		if (m_tabs.empty() || m_activeTab < 0)
-		{
-			return;
-		}
-
-		TabConfig& tab = m_tabs[static_cast<std::size_t>(m_activeTab)];
-
-		const int visibleCount = tab.VisibleCount();
-		const bool anyVisible = tab.AnyVisible();
-		const std::size_t laneCount = tab.Lanes().size();
-
-		const bool changed = (visibleCount != m_cachedVisibleCount) || (anyVisible != m_cachedAnyVisible) ||
-		                     (laneCount != m_cachedLaneCount);
-		if (!changed && !force)
-		{
-			return;
-		}
-
-		const std::size_t previousLaneCount = m_cachedLaneCount;
-		m_cachedVisibleCount = visibleCount;
-		m_cachedAnyVisible = anyVisible;
-		m_cachedLaneCount = laneCount;
-
-		// 标签页首次出现可见信号时，把时间轴对齐到可见数据的范围。
-		// 没有任何可见信号时（未勾选 / 全部取消勾选 / 清空网格）主动复位自适应标记，
-		// 这样用户下一次勾选信号时会重新做一次自适应，而不是停留在上次的视图范围。
-		if (!anyVisible)
-		{
-			tab.ViewInitialized() = false;
-		}
-		else if (!tab.ViewInitialized())
-		{
-			// 首次出现可见信号时做一次自适应。单点信号（时间/幅值范围退化成 0）由
-			// `FitAll` 内部按"单值散点"的规则处理（居中 + 一大格 1s），这里不再分开判断。
-			m_plot.FitAll();
-		}
-
-		const bool laneCountChanged = (laneCount != previousLaneCount);
-		if (laneCountChanged || force)
-		{
-			// 网格数量变化会影响滚动条与绘图区宽度，必须重新布局。
-			Relayout();
-		}
-		else
-		{
-			m_plot.RefreshLanes();
-		}
-	}
-
-	void Application::SyncTabsToDataSet()
-	{
-		for (TabConfig& tab : m_tabs)
-		{
-			tab.SyncToDataSet(m_dataSet);
-		}
-
-		// 选中状态由数据层共享维护，数据变动后需校验其是否仍指向存在的信号。
-		m_dataSet.ValidateSelection();
-		m_panel.InvalidateRows();
-
-		// 分组/信号结构变化会让信号引用与分组地址改变，派生缓存必须整体作废。
-		m_plot.InvalidateDerivedCaches();
-
-		// 强制下一次同步重新计算视图状态。
-		m_cachedVisibleCount = -1;
-		m_cachedAnyVisible = false;
-		m_cachedLaneCount = 0;
-
-		if (m_hwnd != nullptr)
-		{
-			InvalidateRect(m_hwnd, nullptr, TRUE);
-		}
-	}
-
-	void Application::RemoveGroup(int groupIndex)
-	{
-		const SignalGroup* group = m_dataSet.GroupAt(groupIndex);
-		if (group == nullptr)
-		{
-			return;
-		}
-		const std::wstring name = group->name;
-
-		// 移除分组会释放大量采样内存：先暂停后台派生曲线计算，避免其读取已释放内存。
-		m_plot.PauseDerivedAsync();
-		// 先按旧下标修正各标签页配置与共享选中项，再从数据层移除，最后统一对齐。
-		for (TabConfig& tab : m_tabs)
-		{
-			tab.RemapAfterGroupRemoval(groupIndex);
-		}
-		m_dataSet.RemapSelectionAfterGroupRemoval(groupIndex);
-		m_dataSet.RemoveGroup(groupIndex);
-		SyncTabsToDataSet();
-
-		SetStatusMessage(L"已从工作区移除：" + name, false);
-		UpdateWindowTitle();
-	}
-
-	void Application::RemoveSignal(int groupIndex, int signalIndex)
-	{
-		SignalRef target;
-		target.groupIndex = groupIndex;
-		target.signalIndex = signalIndex;
-
-		const SignalData* signal = m_dataSet.Resolve(target);
-		const SignalGroup* group = m_dataSet.GroupAt(groupIndex);
-		if (signal == nullptr || group == nullptr)
-		{
-			return;
-		}
-		const std::wstring name = signal->name;
-
-		if (group->signals.size() <= 1)
-		{
-			// 组内只剩这一条信号：直接移除整个分组，避免在列表里留下一个空分组。
-			RemoveGroup(groupIndex);
-			return;
-		}
-
-		// 移除信号会释放采样内存：先暂停后台派生曲线计算，避免其读取已释放内存。
-		m_plot.PauseDerivedAsync();
-		// 先按旧下标修正各标签页配置与共享选中项，再从数据层移除（释放采样内存），最后对齐。
-		for (TabConfig& tab : m_tabs)
-		{
-			tab.RemapAfterSignalRemoval(groupIndex, signalIndex);
-		}
-		m_dataSet.RemapSelectionAfterSignalRemoval(groupIndex, signalIndex);
-		m_dataSet.RemoveSignal(groupIndex, signalIndex);
-		SyncTabsToDataSet();
-
-		SetStatusMessage(L"已从工作区移除信号：" + name, false);
-	}
-
 	void Application::Relayout()
 	{
 		RECT client = {};
@@ -985,1225 +495,6 @@ namespace jdi
 		MessageBoxW(m_hwnd, text.c_str(), kWindowTitle, MB_ICONWARNING | MB_OK);
 	}
 
-	void Application::UpdateWindowTitle()
-	{
-		// 标题栏 = 应用名称 + 分隔竖线 + 内存占用（单位在 KB/MB/GB 间自适应，保留两位小数）。
-		// 除内存占用外不再附带标签页、文件数量等无关信息。
-		// ⚠️ 内存口径 = **私有工作集**（与任务管理器"内存"列一致），不是总工作集。
-		std::wstring title = kWindowTitle;
-		title += kTitleSeparator;
-		title += kRamTitlePrefix;
-		title += FormatByteSize(ProcessPrivateWorkingSetBytes());
-		// 数值未变化时不调用 SetWindowTextW，避免无谓地重绘标题栏。
-		if (title == m_windowTitleText)
-		{
-			return;
-		}
-		m_windowTitleText = title;
-		SetWindowTextW(m_hwnd, m_windowTitleText.c_str());
-	}
-
-	void Application::OpenFileDialog()
-	{
-		// 允许一次选择多个文件，便于跨文件对比信号。
-		std::vector<wchar_t> buffer(static_cast<std::size_t>(MAX_PATH) * 16, L'\0');
-
-		OPENFILENAMEW dialog = {};
-		dialog.lStructSize = sizeof(dialog);
-		dialog.hwndOwner = m_hwnd;
-		dialog.lpstrFilter = SignalFileDialogFilter();
-		dialog.lpstrFile = buffer.data();
-		dialog.nMaxFile = static_cast<DWORD>(buffer.size());
-		dialog.lpstrTitle = L"打开测量数据文件（可多选）";
-		dialog.lpstrDefExt = L"csv";
-		dialog.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_NOCHANGEDIR |
-		               OFN_ALLOWMULTISELECT;
-
-		if (GetOpenFileNameW(&dialog) == FALSE)
-		{
-			return;
-		}
-
-		// 多选时首段为目录，其余为文件名；单选时整段即为完整路径。
-		const std::wstring first(buffer.data());
-		const wchar_t* cursor = buffer.data() + first.size() + 1;
-
-		int loaded = 0;
-		if (*cursor == L'\0')
-		{
-			if (LoadFile(first))
-			{
-				++loaded;
-			}
-		}
-		else
-		{
-			while (*cursor != L'\0')
-			{
-				const std::wstring name(cursor);
-				if (LoadFile(first + L"\\" + name))
-				{
-					++loaded;
-				}
-				cursor += name.size() + 1;
-			}
-		}
-
-		if (loaded > 0)
-		{
-			SetStatusMessage(L"已加载 " + std::to_wstring(loaded) +
-			                     L" 个文件，请在左侧勾选需要查看的信号。",
-			                 false);
-		}
-	}
-
-	bool Application::LoadFile(const std::wstring& path)
-	{
-		if (path.empty())
-		{
-			return false;
-		}
-
-		// 大文件在工作线程解析并构建，主线程播放加载过渡动画，界面不再整块卡住。
-		SignalGroup group;
-		std::wstring error;
-		if (!LoadFileAsync(path, group, error))
-		{
-			if (!error.empty())
-			{
-				SetStatusMessage(L"解析失败：" + error, true);
-			}
-			InvalidateRect(m_hwnd, nullptr, FALSE);
-			return false;
-		}
-
-		int groupIndex = -1;
-		// 插入新分组会移动 SignalGroup/SignalData 的存储位置，必须先暂停后台派生曲线计算，
-		// 否则后台线程可能正在读取即将被移动的采样数据。
-		m_plot.PauseDerivedAsync();
-		// 此处只做一次指针/缓冲移动，不拷贝任何采样数据，因此不会造成可见卡顿。
-		if (!m_dataSet.AddGroup(std::move(group), groupIndex))
-		{
-			SetStatusMessage(L"解析失败：数据为空。", true);
-			InvalidateRect(m_hwnd, nullptr, FALSE);
-			return false;
-		}
-
-		// 新分组的信号在全部标签页中默认均为未勾选状态，由用户自行决定查看内容。
-		SyncTabsToDataSet();
-		UpdateWindowTitle();
-
-		const SignalGroup* loaded = m_dataSet.GroupAt(groupIndex);
-		if (loaded != nullptr)
-		{
-			// 行数取各时间轴的**最大值**（多时间轴文件的各轴长度可能不同）。
-			std::size_t rowCount = 0;
-			bool anyNonMonotonic = false;
-			std::wstring timeNames;
-			for (const TimeAxis& axis : loaded->axes)
-			{
-				rowCount = std::max(rowCount, axis.Count());
-				anyNonMonotonic = anyNonMonotonic || !axis.monotonic;
-				if (!timeNames.empty())
-				{
-					timeNames += L"、";
-				}
-				timeNames += axis.name;
-			}
-			std::wstring message = L"已加载 组" + std::to_wstring(groupIndex + 1) + L"｜" + loaded->name +
-			                       L"（" + FormatCount(static_cast<unsigned long long>(rowCount)) +
-			                       L" 行采样，" + std::to_wstring(loaded->signals.size()) +
-				                       L" 条信号，" + std::to_wstring(loaded->axes.size()) + L" 条时间轴：" +
-				                       timeNames + L"）";
-			if (anyNonMonotonic)
-			{
-				message += L" 提示：时间列非单调递增，光标取值使用最近邻策略。";
-			}
-			SetStatusMessage(message, false);
-		}
-		return true;
-	}
-
-	bool Application::LoadFileAsync(const std::wstring& path, SignalGroup& group, std::wstring& error)
-	{
-		error.clear();
-
-		AsyncLoadState state;
-		const std::size_t paletteBase = m_dataSet.SignalCount();
-
-		m_loading = true;
-		m_loadingProgress = 0.0f;
-		m_loadingBytesRead = 0;
-		m_loadingTotalBytes = 0;
-		const std::size_t slashPos = path.find_last_of(L"\\/");
-		m_loadingText = (slashPos == std::wstring::npos) ? path : path.substr(slashPos + 1);
-
-		std::thread worker(RunAsyncLoad, &state, path, paletteBase);
-
-		// 主线程循环：抽送消息 + 刷新动画，直到后台完成或用户取消。
-		while (!state.done.load(std::memory_order_acquire))
-		{
-			MSG message = {};
-			while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE))
-			{
-				if (message.message == WM_QUIT)
-				{
-					// 退出请求：让后台停下并重新投递 WM_QUIT，由主循环正常收尾。
-					state.cancelled.store(true, std::memory_order_relaxed);
-					PostQuitMessage(static_cast<int>(message.wParam));
-					break;
-				}
-				// 加载期间屏蔽鼠标与其它按键，避免重入加载或误改数据；
-				// 保留 Esc 作为取消入口。
-				if (message.message >= WM_MOUSEFIRST && message.message <= WM_MOUSELAST)
-				{
-					continue;
-				}
-				if (message.message == WM_KEYDOWN && message.wParam == VK_ESCAPE)
-				{
-					state.cancelled.store(true, std::memory_order_relaxed);
-					continue;
-				}
-				if (message.message >= WM_KEYFIRST && message.message <= WM_KEYLAST)
-				{
-					continue;
-				}
-				TranslateMessage(&message);
-				DispatchMessageW(&message);
-			}
-
-			m_loadingProgress = state.progress.load(std::memory_order_relaxed);
-			m_loadingBytesRead = state.bytesRead.load(std::memory_order_relaxed);
-			m_loadingTotalBytes = state.totalBytes.load(std::memory_order_relaxed);
-			InvalidateRect(m_hwnd, nullptr, FALSE);
-			UpdateWindow(m_hwnd);
-			Sleep(15);
-		}
-
-		m_loadingProgress = 1.0f;
-		m_loadingBytesRead = m_loadingTotalBytes;
-		worker.join();
-		m_loading = false;
-
-		if (state.cancelled.load(std::memory_order_relaxed))
-		{
-			// 用户主动取消：不弹错误框（与 Esc 取消缩放选区的静默语义一致）。
-			InvalidateRect(m_hwnd, nullptr, TRUE);
-			return false;
-		}
-		if (!state.ok)
-		{
-			error = state.error;
-			return false;
-		}
-
-		group = std::move(state.group);
-		return true;
-	}
-
-	void Application::PaintLoadingOverlay(gd::Graphics& g, int width, int height)
-	{
-		if (!m_loading)
-		{
-			return;
-		}
-
-		// 半透明遮罩压暗整个界面，形成明确的"正在加载"状态。
-		UiFillRect(g, gd::RectF(0.0f, 0.0f, static_cast<float>(width), static_cast<float>(height)),
-		           0x66000000u);
-
-		const float cardWidth = std::min(420.0f * m_scale, static_cast<float>(width) - 40.0f * m_scale);
-		const float cardHeight = 132.0f * m_scale;
-		const gd::RectF card((static_cast<float>(width) - cardWidth) * 0.5f,
-		                     (static_cast<float>(height) - cardHeight) * 0.5f, cardWidth, cardHeight);
-
-		UiFillRoundRect(g, card, 8.0f * m_scale, m_theme.cardBg);
-		UiDrawRoundRect(g, card, 8.0f * m_scale, m_theme.borderStrong, 1.0f);
-
-		// 旋转弧线：用时间驱动的起始角度形成持续的加载动画。
-		const float spinnerRadius = 11.0f * m_scale;
-		const gd::RectF spinner(card.X + 26.0f * m_scale, card.Y + 30.0f * m_scale - spinnerRadius,
-		                        spinnerRadius * 2.0f, spinnerRadius * 2.0f);
-		m_loadingSpin += 12.0f;
-		if (m_loadingSpin >= 360.0f)
-		{
-			m_loadingSpin -= 360.0f;
-		}
-		gd::Pen trackPen(ToGdiColor(m_theme.border), 3.0f * m_scale);
-		gd::Pen spinPen(ToGdiColor(m_theme.accent), 3.0f * m_scale);
-		g.DrawArc(&trackPen, spinner, 0.0f, 359.0f);
-		g.DrawArc(&spinPen, spinner, m_loadingSpin, 110.0f);
-
-		const float textLeft = card.X + 52.0f * m_scale;
-		const float textWidth = cardWidth - 52.0f * m_scale - 20.0f * m_scale;
-
-		UiText(g, L"正在加载数据…", m_fonts.uiBold,
-		       gd::RectF(textLeft, card.Y + 18.0f * m_scale, textWidth, 22.0f * m_scale), m_theme.text,
-		       TextAlign::LEFT);
-
-		// 超长文件名用省略号截断，避免撑破卡片。
-		const std::wstring nameText =
-		    UiEllipsize(m_loadingText, m_fonts.uiSmall, textWidth);
-		UiText(g, nameText, m_fonts.uiSmall,
-		       gd::RectF(textLeft, card.Y + 42.0f * m_scale, textWidth, 20.0f * m_scale),
-		       m_theme.textMuted, TextAlign::LEFT);
-
-		// 进度条（复用样式区滑块以外的简单圆角矩形，填充宽度严格按比例）。
-		const gd::RectF track(card.X + 26.0f * m_scale, card.Y + 76.0f * m_scale,
-		                      cardWidth - 52.0f * m_scale, 8.0f * m_scale);
-		UiFillRoundRect(g, track, track.Height * 0.5f, m_theme.pressed);
-		float ratio = m_loadingProgress;
-		ratio = std::max(0.0f, std::min(ratio, 1.0f));
-		const float fillWidth = track.Width * ratio;
-		if (fillWidth > 1.0f)
-		{
-			UiFillRoundRect(g, gd::RectF(track.X, track.Y, fillWidth, track.Height), track.Height * 0.5f,
-			                m_theme.accent);
-		}
-
-		wchar_t buffer[64];
-		swprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), L"%.2f%%", ratio * 100.0);
-
-		// 已读取 / 总大小：两者都只显示数字与自适应单位（GB / MB / KB），均保留两位小数；
-		// 百分比同样是两位小数。总大小未知（如列重组阶段）时只显示百分比。
-		{
-			std::wstring statusText = buffer;
-			if (m_loadingTotalBytes > 0)
-			{
-				statusText = FormatByteSize(m_loadingBytesRead) + L" / " +
-				             FormatByteSize(m_loadingTotalBytes) + L"  " + buffer;
-			}
-			UiText(g, statusText, m_fonts.monoSmall,
-			       gd::RectF(track.X, card.Y + 92.0f * m_scale, track.Width, 20.0f * m_scale),
-			       m_theme.text, TextAlign::LEFT);
-		}
-
-		UiText(g, L"按 Esc 取消", m_fonts.uiSmall,
-		       gd::RectF(track.X, card.Y + 92.0f * m_scale, track.Width, 20.0f * m_scale),
-		       m_theme.textMuted, TextAlign::RIGHT);
-	}
-
-	void Application::LoadCommandLineFiles()
-	{
-		int argumentCount = 0;
-		LPWSTR* arguments = CommandLineToArgvW(GetCommandLineW(), &argumentCount);
-		if (arguments == nullptr)
-		{
-			return;
-		}
-
-		int loaded = 0;
-		for (int index = 1; index < argumentCount; ++index)
-		{
-			const std::wstring argument = arguments[index];
-			if (argument.empty() || argument[0] == L'-' || argument[0] == L'/')
-			{
-				continue;
-			}
-			if (LoadFile(argument))
-			{
-				++loaded;
-			}
-		}
-		LocalFree(arguments);
-
-		if (loaded > 0)
-		{
-			SetStatusMessage(L"已加载 " + std::to_wstring(loaded) +
-			                     L" 个文件，请在左侧勾选需要查看的信号。",
-			                 false);
-		}
-	}
-
-	void Application::ExecuteToolbarAction(ToolbarAction action)
-	{
-		switch (action)
-		{
-		case ToolbarAction::OPEN_FILE:
-			OpenFileDialog();
-			break;
-		case ToolbarAction::FIT_ALL:
-			// 自适应同时回到初始状态：退出缩放模式并显示全部信号范围。
-			m_plot.FitAll();
-			SetStatusMessage(L"已恢复自适应视图。", false);
-			break;
-		case ToolbarAction::AUTO_FIT_Y:
-		{
-			// 与网格右键菜单中的「选区 Y 轴自适应（全局）」同一开关：
-			// 打开后立即按当前视图自适应一次，之后每次时间轴选区放大都会自动匹配。
-			const bool enable = !m_plot.AllLanesAutoFitToSelection();
-			m_plot.SetAllLanesAutoFitToSelection(enable, true);
-			SetStatusMessage(enable ? L"已开启选区 Y 轴自适应：时间轴选区放大后自动匹配各网格 Y 轴。"
-			                        : L"已关闭选区 Y 轴自适应。",
-			                false);
-			break;
-		}
-		case ToolbarAction::ZOOM_SELECT:
-			m_plot.ToggleZoomMode(PlotZoomMode::SELECT);
-			break;
-		case ToolbarAction::CURSOR:
-			m_plot.CycleCursorMode();
-			break;
-		case ToolbarAction::MERGE_LANES:
-			if (!m_dataSet.Empty())
-			{
-				ActiveTab().SetMode(LaneMode::MERGED);
-				SetStatusMessage(L"已将当前标签页的全部可见信号合并到同一网格。", false);
-			}
-			break;
-		case ToolbarAction::SPLIT_LANES:
-			if (!m_dataSet.Empty())
-			{
-				ActiveTab().SetMode(LaneMode::PER_SIGNAL);
-				SetStatusMessage(L"当前标签页已切换为「每信号一格」。", false);
-			}
-			break;
-		case ToolbarAction::CLEAR_ALL:
-			if (!m_dataSet.Empty())
-			{
-				ActiveTab().SetAllVisible(false);
-				m_panel.InvalidateRows();
-				SetStatusMessage(L"已清空当前标签页的全部网格。", false);
-			}
-			break;
-		case ToolbarAction::NONE:
-		default:
-			break;
-		}
-
-		if (m_hwnd != nullptr)
-		{
-			InvalidateRect(m_hwnd, nullptr, TRUE);
-		}
-	}
-
-	bool Application::HandleKeyDown(WPARAM key)
-	{
-		const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
-
-		if (control && key == L'O')
-		{
-			OpenFileDialog();
-			return true;
-		}
-		if (control && key == L'T')
-		{
-			NewTab(true);
-			return true;
-		}
-		if (control && key == L'W')
-		{
-			CloseTab(m_activeTab);
-			return true;
-		}
-		if (control && key == VK_TAB)
-		{
-			if (m_tabs.size() > 1)
-			{
-				const bool backward = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
-				const int count = static_cast<int>(m_tabs.size());
-				SetActiveTab((m_activeTab + (backward ? count - 1 : 1)) % count);
-			}
-			return true;
-		}
-
-		switch (key)
-		{
-		case VK_ESCAPE:
-		{
-			// Esc 的语义：
-			// 1) 放弃当前正在进行的拖拽（典型场景：缩放的框选选区还没松开左键）；
-			//    取消后不应用选区、视图范围保持不变；
-			// 2) 同时退出全部缩放模式，使工具栏「时间轴选区」「Y 轴选区」回到未选中态。
-			// Esc 不与时间光标关联：关闭光标请用工具栏「光标」按钮，避免误关指针。
-			bool changed = m_plot.CancelDrag();
-			changed = m_plot.ExitZoomModes() || changed;
-			return changed;
-		}
-		case VK_ADD:
-		case VK_OEM_PLUS:
-			m_plot.ZoomTimeStep(1.4);
-			return true;
-		case VK_SUBTRACT:
-		case VK_OEM_MINUS:
-			m_plot.ZoomTimeStep(1.0 / 1.4);
-			return true;
-		case VK_LEFT:
-			m_plot.PanTimeByFraction(-0.12);
-			return true;
-		case VK_RIGHT:
-			m_plot.PanTimeByFraction(0.12);
-			return true;
-		case VK_UP:
-			m_plot.ScrollLanesByFraction(-0.12);
-			return true;
-		case VK_DOWN:
-			m_plot.ScrollLanesByFraction(0.12);
-			return true;
-		default:
-			break;
-		}
-
-		if (key == L'F')
-		{
-			m_plot.FitAll();
-			return true;
-		}
-		return false;
-	}
-
-	void Application::UpdateDragCursor(int x, int y)
-	{
-		// 鼠标捕获期间不再有 WM_SETCURSOR，只能自己按当前状态设置光标。
-		HCURSOR cursor = nullptr;
-		if (m_activeTarget == Target::PLOT)
-		{
-			cursor = m_plot.QueryCursor(x, y);
-		}
-		SetCursor(cursor != nullptr ? cursor : LoadCursorW(nullptr, IDC_ARROW));
-	}
-
-	bool Application::HandleMouseMove(int x, int y, bool buttonDown)
-	{
-		if (buttonDown && m_activeTarget != Target::NONE)
-		{
-			switch (m_activeTarget)
-			{
-			case Target::SPLITTER:
-				if (m_draggingSplitter && m_scale > 0.0f)
-				{
-					const float desired = static_cast<float>(x - m_splitterGrabOffset) / m_scale;
-					const float maximum =
-					    std::min(kMaxPanelWidth, static_cast<float>(kMinClientWidth) / m_scale);
-					m_panelWidth = std::max(kMinPanelWidth, std::min(desired, maximum));
-					Relayout();
-					return true;
-				}
-				return false;
-			case Target::PLOT:
-				return m_plot.OnMouseMove(x, y);
-			case Target::PANEL:
-				return m_panel.OnMouseMove(x, y);
-			case Target::TOOLBAR:
-				return m_toolbar.OnMouseMove(x, y);
-			case Target::TAB_BAR:
-				return m_tabBar.OnMouseMove(x, y);
-			case Target::EDIT_FIELD:
-			{
-				// 输入框拖拽框选：按当前正在编辑的组件分发。
-				bool changed = m_tabBar.OnEditMouseMove(x);
-				changed = m_panel.OnEditMouseMove(x) || changed;
-				changed = m_plot.OnEditMouseMove(x) || changed;
-				changed = m_colorPicker.OnEditMouseMove(x) || changed;
-				return changed;
-			}
-			case Target::NONE:
-			default:
-				return false;
-			}
-		}
-
-		bool changed = false;
-		changed =
-		    (m_tabBar.HitTest(x, y) ? m_tabBar.OnMouseMove(x, y) : m_tabBar.OnMouseLeave()) || changed;
-		// ⚠️ 按住工具栏按钮期间**绝不能**走 `OnMouseLeave()`：它会清掉按下态（`m_pressedIndex`），
-		//    于是随后在按钮上松手时什么也不会发生 —— 这正是“快速点击工具栏按钮时状态没切换”
-		//    的另一个成因（鼠标带着按下态从按钮边缘移出时会命中这里）。
-		if (m_toolbar.HitTest(x, y))
-		{
-			changed = m_toolbar.OnMouseMove(x, y) || changed;
-		}
-		else if (m_activeTarget != Target::TOOLBAR)
-		{
-			changed = m_toolbar.OnMouseLeave() || changed;
-		}
-		changed = (m_panel.HitTest(x, y) ? m_panel.OnMouseMove(x, y) : m_panel.OnMouseLeave()) || changed;
-		changed = (m_plot.HitTest(x, y) ? m_plot.OnMouseMove(x, y) : m_plot.OnMouseLeave()) || changed;
-		return changed;
-	}
-
-	void Application::OnTabBarResult(const TabBarResult& result)
-	{
-		switch (result.type)
-		{
-		case TabBarResult::Type::ADD:
-			NewTab(true);
-			break;
-		case TabBarResult::Type::SELECT:
-			if (result.index != m_activeTab)
-			{
-				SetActiveTab(result.index);
-			}
-			break;
-		case TabBarResult::Type::CLOSE:
-			CloseTab(result.index);
-			break;
-		case TabBarResult::Type::CONTEXT:
-			ShowTabContextMenu(result);
-			break;
-		case TabBarResult::Type::REORDER:
-			MoveTab(result.index, result.targetIndex);
-			break;
-		case TabBarResult::Type::RENAME:
-			if (result.index >= 0 && result.index < static_cast<int>(m_tabs.size()) && !result.text.empty())
-			{
-				m_tabs[static_cast<std::size_t>(result.index)].SetName(result.text);
-				RefreshTabBar();
-				// SetTabs 会重置各标签的矩形，必须重新布局才能把它们算回来。
-				Relayout();
-				InvalidateRect(m_hwnd, nullptr, TRUE);
-			}
-			break;
-		case TabBarResult::Type::NONE:
-		default:
-			break;
-		}
-	}
-
-	void Application::MoveTab(int from, int target)
-	{
-		if (from < 0 || from >= static_cast<int>(m_tabs.size()))
-		{
-			return;
-		}
-		if (target < 0 || target > static_cast<int>(m_tabs.size()))
-		{
-			return;
-		}
-
-		// 拖拽语义：target 表示「插入到该下标之前」；向后拖时需扣除自身占位。
-		int destination = target;
-		if (destination > from)
-		{
-			--destination;
-		}
-		destination = std::max(0, std::min(destination, static_cast<int>(m_tabs.size()) - 1));
-		if (destination == from)
-		{
-			return;
-		}
-
-		// 保持当前激活的标签页在重排后仍处于激活状态。
-		TabConfig moved = m_tabs[static_cast<std::size_t>(from)];
-		const int activeIndex = m_activeTab;
-
-		m_tabs.erase(m_tabs.begin() + from);
-		m_tabs.insert(m_tabs.begin() + destination, std::move(moved));
-
-		int newActive = activeIndex;
-		if (activeIndex == from)
-		{
-			newActive = destination;
-		}
-		else if (from < activeIndex && destination >= activeIndex)
-		{
-			--newActive;
-		}
-		else if (from > activeIndex && destination <= activeIndex)
-		{
-			++newActive;
-		}
-
-		SetActiveTab(newActive);
-		InvalidateRect(m_hwnd, nullptr, TRUE);
-	}
-
-	bool Application::ApplyPendingRename()
-	{
-		SignalRef ref;
-		std::wstring name;
-		if (!m_plot.TakePendingRename(ref, name))
-		{
-			return false;
-		}
-
-		if (!m_dataSet.RenameSignal(ref.groupIndex, ref.signalIndex, name))
-		{
-			return false;
-		}
-
-		// 改名只影响显示，但需要刷新左侧列表与绘图区图例。
-		m_panel.InvalidateRows();
-		SetStatusMessage(L"信号已重命名为：" + name, false);
-		InvalidateRect(m_hwnd, nullptr, TRUE);
-		return true;
-	}
-
-	bool Application::BuildDerivedSignal(const DerivedSignalRequest& request, bool makeVisible)
-	{
-		const SignalGroup* group = m_dataSet.GroupAt(request.groupIndex);
-		if (group == nullptr || request.signalIndex < 0 ||
-		    request.signalIndex >= static_cast<int>(group->signals.size()))
-		{
-			return false;
-		}
-		const SignalData& source = group->signals[static_cast<std::size_t>(request.signalIndex)];
-		const TimeAxis& axis = group->AxisOf(source);
-		const std::wstring baseName = source.name;
-
-		// 0. 先把源信号的「调整」变换快照下来（下面 `InsertDerivedSignal` 会移动信号存储，
-		//    之后再取 `source` 会悬垂）。
-		//
-		// ⚠️ **变换要"烘进数据"，而不是让新信号继承这套指纹**（用户明确要求）：
-		// 网格里的预览曲线画的是 `变换(滤波结果)`。若新信号只存 `滤波结果` 再**继承变换**，
-		// 它的「调整」面板里就会莫名其妙带着一整套系数 / 镜像 / 偏移 —— 用户看到的是
-		// "新信号只是继承了原信号的指纹，数据本身没变"。现在改为：
-		//   * 数值域变换（系数 → 绝对值 → 垂直镜像 → Y 偏移）**与**水平镜像（数据反序）
-		//     全部作用在派生采样值上；
-		//   * 于是新信号**用默认外观**绘制出来就与预览曲线逐位一致。
-		//   * ⚠️ **时间轴偏移也一并烘进数据**（见 2c：按 `time[i] - offsetTime` 重采样）。
-		//     新信号与源信号共用同一个文件时间轴，因此时间平移只能写进采样值 —— 这样
-		//     新信号**不启用任何「调整」**就与预览逐点重合（用户明确要求）。
-		//     只有"无法烘值"的退化情形才退回把 `offsetTime` 带在样式上（见 3b）。
-		SignalStyle sourceTransform;
-		bool hasSourceStyle = false;
-		{
-			SignalRef sourceRef;
-			sourceRef.groupIndex = request.groupIndex;
-			sourceRef.signalIndex = request.signalIndex;
-			if (const SignalStyle* sourceStyle = m_dataSet.Style(sourceRef))
-			{
-				sourceTransform = *sourceStyle;
-				hasSourceStyle = true;
-			}
-		}
-
-		// 1. 计算派生采样值（与网格内的预览曲线共用同一实现，因此逐位一致）。
-		//    多次迭代均值滤波形如「<原信号名称> (N点均值 M次迭代)」，
-		//    弱峰调整形如「<原信号名称> (弱峰调整 M% N次迭代)」。
-		std::vector<float> derived_values;
-		SignalData derived;
-		if (request.weakPeak)
-		{
-			ComputeWeakPeakAdjust(source.values, static_cast<double>(request.amountPercent) / 100.0,
-			                     request.iterations, derived_values);
-			derived.name = baseName + L" (弱峰调整 " + std::to_wstring(request.amountPercent) + L"% " +
-			               std::to_wstring(request.iterations) + L"次迭代)";
-		}
-		else
-		{
-			ComputeMovingAverageIterated(source.values, request.points, request.iterations, derived_values);
-			derived.name = baseName + L" (" + std::to_wstring(request.points) + L"点均值 " +
-			               std::to_wstring(request.iterations) + L"次迭代)";
-		}
-
-		// 2. 组装新信号（外观一律用默认值：变换已经烘进采样数据，不再是"继承的指纹"）。
-		//    ⚠️ 新信号**沿用源信号的时间轴**（`axisIndex`）：派生只改采样值，不改时间基准。
-		derived.axisIndex = source.axisIndex;
-		derived.values.assign(derived_values.begin(), derived_values.end());
-
-		// 2b. 把源信号的「调整」变换**烘进派生采样值**：
-		//     * 数值域（系数 → 绝对值 → 垂直镜像 → Y 偏移）逐点套用 `ApplyDrawTransform`；
-		//     * 水平镜像 = 数据反序，等价于把采样数组整体反转。
-		//     ⚠️ `ApplyDrawTransform` 是逐点函数，因此"先变换再反转"与"先反转再变换"等价。
-		if (hasSourceStyle)
-		{
-			const bool valueTransform =
-			    (sourceTransform.gain != 1.0f || sourceTransform.absolute ||
-			     sourceTransform.mirrorVertical || sourceTransform.offsetY != 0.0f);
-			if (valueTransform)
-			{
-				for (double& value : derived.values)
-				{
-					value = ApplyDrawTransform(sourceTransform, value);
-				}
-			}
-			if (sourceTransform.mirrorHorizontal)
-			{
-				std::reverse(derived.values.begin(), derived.values.end());
-			}
-		}
-
-		// 2c. 时间轴偏移：把 `offsetTime` 也**重采样烘进采样值**。
-		//
-		// 预览曲线是按「源信号样式」绘制的，它的时间轴偏移会把曲线整体横向平移。
-		// 派生信号与源信号**共用同一个文件时间轴**，所以时间平移本无法写进"时间列"；
-		// 但用户明确要求：**新信号不启用任何「调整」也要与预览逐点重合**
-		//（新信号的「调整」面板必须是默认值，不允许靠"继承 offsetTime"来表达）。
-		// 因此这里把平移直接写进数据：
-		//   * 新信号第 i 个采样 = 预览曲线在 `time[i]` 时刻显示的值
-		//     = 已变换的曲线在 `time[i] - offsetTime` 处的取值（取最近的采样点）；
-		//   * 平移后落在数据范围之外的采样置 NaN —— 与预览"该处没有曲线"完全一致。
-		// ⚠️ 一次整段重采样需要一份等长的临时缓冲（千万级采样 ≈ 数十 MB），用完立即释放；
-		//    这是"构建为新信号"的一次性操作，不在交互路径上。
-		// ⚠️ 时间轴非单调时无法按下标单调推进取样（只能整表扫描），此时退回"继承
-		//    `offsetTime`"（见 3b）：两条路径的**显示效果相同**，只是偏移留在样式里。
-		bool timeShiftBaked = false;
-		if (hasSourceStyle && sourceTransform.offsetTime != 0.0 && axis.monotonic)
-		{
-			const std::vector<double>& times = axis.time;
-			const std::size_t total = derived.values.size();
-			if (total > 1 && times.size() >= total)
-			{
-				const double shift = sourceTransform.offsetTime;
-				std::vector<double> shifted(total, std::numeric_limits<double>::quiet_NaN());
-				// 目标时刻 `times[index] - shift` 随 index 单调不减 → 游标只前进，整体 O(n)。
-				std::size_t probe = 0;
-				for (std::size_t index = 0; index < total; ++index)
-				{
-					const double target = times[index] - shift;
-					if (!std::isfinite(target) || target < times[0] || target > times[total - 1])
-					{
-						continue;	// 平移后越界：该处没有曲线
-					}
-					while (probe + 1 < total && times[probe + 1] < target)
-					{
-						++probe;
-					}
-					std::size_t nearest = probe;
-					if (probe + 1 < total &&
-					    std::fabs(times[probe + 1] - target) < std::fabs(times[probe] - target))
-					{
-						nearest = probe + 1;
-					}
-					shifted[index] = derived.values[nearest];
-				}
-				derived.values.swap(shifted);
-				timeShiftBaked = true;
-			}
-		}
-
-		// 3. 插入到原信号的下方（数据层 + 各标签页引用重映射）。
-		int newIndex = -1;
-		// 插入派生信号会移动该分组的信号存储：先暂停后台计算，避免其读取已移动的数据。
-		m_plot.PauseDerivedAsync();
-		if (!m_dataSet.InsertDerivedSignal(request.groupIndex, request.signalIndex, std::move(derived),
-		                                   newIndex))
-		{
-			return false;
-		}
-		for (TabConfig& tab : m_tabs)
-		{
-			tab.RemapAfterSignalInsert(request.groupIndex, newIndex);
-		}
-
-		// 3b. 时间轴偏移正常情况下已烘进采样值（见 2c），新信号的「调整」全部保持默认。
-		//     ⚠️ 只有"无法烘值"的退化情形（时间轴非单调 / 时间列缺失）才退回到把
-		//     `offsetTime` 带在新信号样式上 —— 无论如何都要让**显示**与预览一致。
-		if (hasSourceStyle && sourceTransform.offsetTime != 0.0 && !timeShiftBaked)
-		{
-			if (SignalStyle* derivedStyle = m_dataSet.Style(SignalRef{request.groupIndex, newIndex}))
-			{
-				derivedStyle->offsetTime = sourceTransform.offsetTime;
-			}
-		}
-
-		// 4. 在当前标签页中勾选新信号，并把它所在的网格移到原信号网格的下方。
-		if (makeVisible && !m_tabs.empty())
-		{
-			SignalRef derivedRef;
-			derivedRef.groupIndex = request.groupIndex;
-			derivedRef.signalIndex = newIndex;
-			ActiveTab().SetVisible(derivedRef, true);
-
-			SignalRef sourceRef;
-			sourceRef.groupIndex = request.groupIndex;
-			sourceRef.signalIndex = request.signalIndex;
-			ActiveTab().MoveLaneOfSignalBelow(derivedRef, sourceRef);
-		}
-
-		// 5. 数据层结构变化：刷新列表、作废折线/派生缓存并重绘。
-		SyncTabsToDataSet();
-		return true;
-	}
-
-	bool Application::ApplyPendingPanelScroll()
-	{
-		SignalRef ref;
-		if (!m_plot.TakePanelScrollRequest(ref) || !ref.IsValid())
-		{
-			return false;
-		}
-		// 平滑滚动（带动画）：用户要求"是滚动的而不是立刻翻到目标信号位置"。
-		m_panel.ScrollToSignalAnimated(ref);
-		return true;
-	}
-
-	bool Application::ApplyPendingDerivedBuild()
-	{
-		// 两类「构建为新信号」请求（均值滤波 / 弱峰调整）机制完全一致，
-		// 统一整理成同一份构建清单后按下标降序处理。
-		std::vector<DerivedSignalRequest> requests;
-		{
-			int laneIndex = -1;
-			std::vector<PlotView::MeanFilterBuild> items;
-			if (m_plot.TakePendingMeanFilterBuild(laneIndex, items))
-			{
-				for (const PlotView::MeanFilterBuild& item : items)
-				{
-					DerivedSignalRequest request;
-					request.groupIndex = item.groupIndex;
-					request.signalIndex = item.signalIndex;
-					request.points = item.points;
-					request.iterations = item.iterations;
-					request.weakPeak = false;
-					requests.push_back(request);
-				}
-			}
-		}
-		{
-			int laneIndex = -1;
-			std::vector<PlotView::WeakPeakBuild> items;
-			if (m_plot.TakePendingWeakPeakBuild(laneIndex, items))
-			{
-				for (const PlotView::WeakPeakBuild& item : items)
-				{
-					DerivedSignalRequest request;
-					request.groupIndex = item.groupIndex;
-					request.signalIndex = item.signalIndex;
-					request.amountPercent = item.amountPercent;
-					request.iterations = item.iterations;
-					request.weakPeak = true;
-					requests.push_back(request);
-				}
-			}
-		}
-		if (requests.empty())
-		{
-			return false;
-		}
-		if (m_tabs.empty())
-		{
-			return false;
-		}
-
-		// **同一文件内必须按下标降序处理**：每次插入只让插入点之后的信号下标 +1，
-		// 降序处理可保证尚未处理的信号下标始终有效（升序会把新插入的信号当成原信号）。
-		std::sort(requests.begin(), requests.end(),
-		          [](const DerivedSignalRequest& a, const DerivedSignalRequest& b)
-		          {
-			          if (a.groupIndex != b.groupIndex)
-			          {
-				          return a.groupIndex < b.groupIndex;
-			          }
-			          return a.signalIndex > b.signalIndex;
-		          });
-
-		int built = 0;
-		DerivedSignalRequest last;
-		for (const DerivedSignalRequest& request : requests)
-		{
-			if (BuildDerivedSignal(request, true))
-			{
-				++built;
-				last = request;
-			}
-		}
-
-		if (built > 0)
-		{
-			std::wstring text = L"已构建 " + std::to_wstring(built) + L" 条 ";
-			if (last.weakPeak)
-			{
-				text += L"弱峰调整 " + std::to_wstring(last.amountPercent) + L"% " +
-				        std::to_wstring(last.iterations) + L"次迭代信号。";
-			}
-			else
-			{
-				text += std::to_wstring(last.points) + L"点均值 " +
-				        std::to_wstring(last.iterations) + L"次迭代滤波信号。";
-			}
-			SetStatusMessage(text, false);
-		}
-		return built > 0;
-	}
-
-	void Application::ShowTabContextMenu(const TabBarResult& result)
-	{
-		if (result.index < 0 || result.index >= static_cast<int>(m_tabs.size()))
-		{
-			return;
-		}
-
-		m_tabMenuIndex = result.index;
-
-		std::vector<MenuItem> items;
-
-		MenuItem header;
-		header.kind = MenuItemKind::HEADER;
-		header.label = m_tabs[static_cast<std::size_t>(result.index)].Name();
-		items.push_back(header);
-
-		MenuItem create;
-		create.label = L"新建标签页";
-		create.id = kMenuTabNew;
-		items.push_back(create);
-
-		MenuItem close;
-		close.label = L"关闭该标签页";
-		close.id = kMenuTabClose;
-		close.enabled = (m_tabs.size() > 1);
-		items.push_back(close);
-
-		MenuItem closeOthers;
-		closeOthers.label = L"关闭其它标签页";
-		closeOthers.id = kMenuTabCloseOthers;
-		closeOthers.enabled = (m_tabs.size() > 1);
-		items.push_back(closeOthers);
-
-		// 菜单绘制在客户区内，因此把屏幕坐标换算为客户区坐标。
-		POINT anchor = {result.screenX, result.screenY};
-		ScreenToClient(m_hwnd, &anchor);
-
-		RECT client = {};
-		GetClientRect(m_hwnd, &client);
-		const gd::RectF bounds(0.0f, 0.0f, static_cast<float>(client.right - client.left),
-		                       static_cast<float>(client.bottom - client.top));
-
-		m_menu.Open(MenuScope::TAB_BAR, bounds, anchor.x, anchor.y, items);
-	}
-
-	void Application::ShowPlotContextMenu(int laneIndex, int x, int y)
-	{
-		if (laneIndex < 0)
-		{
-			return;
-		}
-
-		m_plotMenuLane = laneIndex;
-
-		std::vector<MenuItem> items;
-
-		MenuItem header;
-		header.kind = MenuItemKind::HEADER;
-		header.label = L"网格 " + std::to_wstring(laneIndex + 1);
-		items.push_back(header);
-
-		// 当前网格的 Y 轴上下限值直接在菜单内的输入框里显示，单击即可就地编辑（菜单不关闭）。
-		double laneYMin = 0.0;
-		double laneYMax = 1.0;
-		m_plot.LaneRange(laneIndex, laneYMin, laneYMax);
-
-		MenuItem maxItem;
-		maxItem.kind = MenuItemKind::EDIT;
-		maxItem.label = L"Y 轴最大值";
-		maxItem.id = PLOT_CMD_LANE_Y_MAX;
-		maxItem.value = FormatValue(laneYMax);
-		maxItem.filter = EditFilter::NUMBER;
-		items.push_back(maxItem);
-
-		MenuItem minItem;
-		minItem.kind = MenuItemKind::EDIT;
-		minItem.label = L"Y 轴最小值";
-		minItem.id = PLOT_CMD_LANE_Y_MIN;
-		minItem.value = FormatValue(laneYMin);
-		minItem.filter = EditFilter::NUMBER;
-		items.push_back(minItem);
-
-		// 选区自适应（切换项）：勾选后每次本网格的时间轴选区放大都会自动匹配 Y 轴幅值。
-		MenuItem autoViewItem;
-		autoViewItem.label = L"选区 Y 轴自适应";
-		autoViewItem.id = PLOT_CMD_LANE_AUTO_VIEW;
-		autoViewItem.checked = m_plot.LaneAutoFitToSelection(laneIndex);
-		items.push_back(autoViewItem);
-
-		// 时间轴自适应到本网格信号范围（原先位于分隔线下方，现移到分隔线上方）。
-		MenuItem fitLaneTime;
-		fitLaneTime.label = L"按网格时间轴展开";
-		fitLaneTime.id = PLOT_CMD_LANE_FIT_TIME;
-		items.push_back(fitLaneTime);
-
-		// 「拆分当前网格」：把该网格内的信号按个拆成独立网格，插到其下方依次排列。
-		// 可点击时在后方追加「（N个信号）」说明将拆出的网格数；只有 1 条信号时置灰且不加尾缀。
-		MenuItem splitLane;
-		const std::size_t laneSignalCount = m_plot.LaneSignalCount(laneIndex);
-		splitLane.label = (laneSignalCount > 1)
-		                      ? (L"拆分当前网格（" + std::to_wstring(laneSignalCount) + L"个信号）")
-		                      : L"拆分当前网格";
-		splitLane.id = PLOT_CMD_LANE_SPLIT;
-		splitLane.enabled = laneSignalCount > 1;
-		items.push_back(splitLane);
-
-		// 实验性功能（二级菜单）：横线上方，鼠标悬停即向右展开。
-		MenuItem experimental;		experimental.kind = MenuItemKind::SUBMENU;
-		experimental.label = L"实验性功能";
-		{
-			MenuItem edgeCount;
-			edgeCount.label = L"边沿计数";
-			edgeCount.id = PLOT_CMD_LANE_EDGE_COUNT;
-			edgeCount.checked = m_plot.LaneEdgeCount(laneIndex);
-			experimental.submenu.push_back(edgeCount);
-
-			MenuItem edgeCenter;
-			edgeCenter.label = L"边沿计数（中心轴）";
-			edgeCenter.id = PLOT_CMD_LANE_EDGE_CENTER;
-			edgeCenter.checked = m_plot.LaneEdgeCenterCount(laneIndex);
-			experimental.submenu.push_back(edgeCenter);
-
-			MenuItem meanFilter;
-			meanFilter.label = L"均值滤波";
-			meanFilter.id = PLOT_CMD_LANE_MEAN_FILTER;
-			meanFilter.checked = m_plot.LaneMeanFilter(laneIndex);
-			experimental.submenu.push_back(meanFilter);
-
-			MenuItem weakPeak;
-			weakPeak.label = L"弱峰调整";
-			weakPeak.id = PLOT_CMD_LANE_WEAK_PEAK;
-			weakPeak.checked = m_plot.LaneWeakPeak(laneIndex);
-			experimental.submenu.push_back(weakPeak);
-		}
-		items.push_back(experimental);
-
-		MenuItem separator;
-		separator.kind = MenuItemKind::SEPARATOR;
-		items.push_back(separator);
-
-		// 全局开关：一次性打开/关闭全部网格各自的「选区 Y 轴自适应」。
-		MenuItem autoFitAllItem;
-		autoFitAllItem.label = L"选区 Y 轴自适应（全局）";
-		autoFitAllItem.id = PLOT_CMD_AUTO_FIT_ALL;
-		autoFitAllItem.checked = m_plot.AllLanesAutoFitToSelection();
-		items.push_back(autoFitAllItem);
-
-		MenuItem fitItem;
-		fitItem.label = L"全部自适应";
-		fitItem.id = PLOT_CMD_FIT_ALL;
-		items.push_back(fitItem);
-
-		RECT client = {};
-		GetClientRect(m_hwnd, &client);
-		const gd::RectF bounds(0.0f, 0.0f, static_cast<float>(client.right - client.left),
-		                       static_cast<float>(client.bottom - client.top));
-
-		m_menu.Open(MenuScope::PLOT_VIEW, bounds, x, y, items);
-	}
-
-	void Application::RefreshPlotMenuValues(int laneIndex)
-	{
-		if (laneIndex < 0)
-		{
-			return;
-		}
-
-		double laneYMin = 0.0;
-		double laneYMax = 1.0;
-		m_plot.LaneRange(laneIndex, laneYMin, laneYMax);
-		m_menu.UpdateItemValue(PLOT_CMD_LANE_Y_MAX, FormatValue(laneYMax));
-		m_menu.UpdateItemValue(PLOT_CMD_LANE_Y_MIN, FormatValue(laneYMin));
-
-		// 「选区 Y 轴自适应」（本网格）与「（全局）」都是切换项，实时反映各自的勾选状态。
-		m_menu.UpdateItemLabel(PLOT_CMD_LANE_AUTO_VIEW, L"选区 Y 轴自适应",
-		                       m_plot.LaneAutoFitToSelection(laneIndex), true);
-		m_menu.UpdateItemLabel(PLOT_CMD_AUTO_FIT_ALL, L"选区 Y 轴自适应（全局）",
-		                       m_plot.AllLanesAutoFitToSelection(), true);
-	}
-
-	void Application::DispatchMenuResult(const MenuResult& result)
-	{
-		if (!result.valid)
-		{
-			return;
-		}
-
-		switch (result.scope)
-		{
-		case MenuScope::SIGNAL_PANEL:
-		{
-			const bool needRelayout = m_panel.OnMenuCommand(result);
-			if (needRelayout)
-			{
-				Relayout();
-			}
-			InvalidateRect(m_hwnd, nullptr, FALSE);
-			break;
-		}
-		case MenuScope::PLOT_VIEW:
-		{
-			// 菜单内联输入框的提交：就地更新网格 Y 轴上下限，菜单保持打开，
-			// 并把夹取后的真实值回写到菜单上（输入值可能被合法区间修正）。
-			if (result.editCommit)
-			{
-				const int laneIndex = m_plotMenuLane;
-				if (laneIndex >= 0)
-				{
-					m_plot.ApplyLaneValueText(laneIndex, result.id == PLOT_CMD_LANE_Y_MAX, result.editText);
-					RefreshPlotMenuValues(laneIndex);
-				}
-				SetFocus(m_hwnd);
-				InvalidateRect(m_hwnd, nullptr, FALSE);
-				break;
-			}
-
-			const int laneIndex = m_plotMenuLane;
-			m_plotMenuLane = -1;
-			switch (result.id)
-			{
-			case PLOT_CMD_LANE_AUTO_VIEW:
-				// 切换本网格的「选区 Y 轴自适应」。
-				m_plot.ToggleLaneAutoFitToSelection(laneIndex);
-				break;
-			case PLOT_CMD_AUTO_FIT_ALL:
-			{
-				// 全局切换：一次打开/关闭全部网格各自的开关；打开时立即生效一次。
-				const bool enable = !m_plot.AllLanesAutoFitToSelection();
-				m_plot.SetAllLanesAutoFitToSelection(enable, true);
-				break;
-			}
-			case PLOT_CMD_LANE_FIT_TIME:
-				// 「按网格时间轴展开」：展开时间轴后同时把该网格的 Y 轴自适应一次。
-				m_plot.FitTimeToLane(laneIndex);
-				break;
-			case PLOT_CMD_LANE_EDGE_COUNT:
-				// 「实验性功能 → 边沿计数」：切换本网格的横向光标与统计面板。
-				m_plot.ToggleLaneEdgeCount(laneIndex);
-				break;
-			case PLOT_CMD_LANE_EDGE_CENTER:
-				// 「实验性功能 → 边沿计数（中心轴）」：切换中心平均值曲线与统计面板。
-				m_plot.ToggleLaneEdgeCenterCount(laneIndex);
-				break;
-			case PLOT_CMD_LANE_MEAN_FILTER:
-				// 「实验性功能 → 均值滤波」：切换均值滤波曲线与参数面板。
-				m_plot.ToggleLaneMeanFilter(laneIndex);
-				break;
-			case PLOT_CMD_LANE_WEAK_PEAK:
-				// 「实验性功能 → 弱峰调整」：切换弱峰调整曲线与参数面板。
-				m_plot.ToggleLaneWeakPeak(laneIndex);
-				break;
-			case PLOT_CMD_LANE_SPLIT:
-				// 「拆分当前网格」：信号按个拆成独立网格，新网格顺次插入其下方。
-				m_plot.SplitLane(laneIndex);
-				break;
-			case PLOT_CMD_FIT_ALL:
-				m_plot.FitAll();
-				break;
-			default:
-				break;
-			}
-			SetFocus(m_hwnd);
-			InvalidateRect(m_hwnd, nullptr, TRUE);
-			break;
-		}
-		case MenuScope::TAB_BAR:
-		{
-			const int index = m_tabMenuIndex;
-			if (result.id == kMenuTabNew)
-			{
-				NewTab(true);
-			}
-			else if (result.id == kMenuTabClose)
-			{
-				CloseTab(index);
-			}
-			else if (result.id == kMenuTabCloseOthers)
-			{
-				if (index >= 0 && index < static_cast<int>(m_tabs.size()) && m_tabs.size() > 1)
-				{
-					const TabConfig keep = m_tabs[static_cast<std::size_t>(index)];
-					m_tabs.clear();
-					m_tabs.push_back(keep);
-					SetActiveTab(0);
-				}
-			}
-			m_tabMenuIndex = -1;
-			InvalidateRect(m_hwnd, nullptr, TRUE);
-			break;
-		}
-		case MenuScope::NONE:
-		default:
-			break;
-		}
-	}
-
 	LRESULT Application::HandleMessage(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 	{
 		// 除鼠标移动与鼠标移出（由下面的分支按“是否只影响绘图区”精确判断）之外，
@@ -3133,3 +1424,4 @@ namespace jdi
 	}
 
 } // namespace jdi
+
diff --git a/Components/Application/Src/ApplicationCommands.cpp b/Components/Application/Src/ApplicationCommands.cpp
new file mode 100644
index 0000000..bb9bf01
--- /dev/null
+++ b/Components/Application/Src/ApplicationCommands.cpp
@@ -0,0 +1,1184 @@
+// Application 实现分片 —— 本文件只包含 Application 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 ApplicationInternal.hpp（命名空间 `appdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "ApplicationInternal.hpp"
+
+namespace jdi
+{
+
+	void Application::NewTab(bool collapseGroups)
+	{
+		TabConfig tab;
+		tab.SetName(NextTabName());
+		// 用户新建的标签页：信号分组**默认折起**（用户明确要求：列表默认紧凑；
+		// 之后在该标签页里新加载的分组也沿用这个默认值）。
+		tab.SetGroupsCollapsedByDefault(collapseGroups);
+		tab.SyncToDataSet(m_dataSet);
+		if (collapseGroups)
+		{
+			tab.SetAllCollapsed(true);
+		}
+
+		m_tabs.push_back(std::move(tab));
+		SetActiveTab(static_cast<int>(m_tabs.size()) - 1);
+	}
+
+	void Application::CloseTab(int index)
+	{
+		if (index < 0 || index >= static_cast<int>(m_tabs.size()))
+		{
+			return;
+		}
+		if (m_tabs.size() <= 1)
+		{
+			SetStatusMessage(L"至少需要保留一个标签页。", true);
+			return;
+		}
+
+		m_tabs.erase(m_tabs.begin() + index);
+
+		int next = index;
+		if (next >= static_cast<int>(m_tabs.size()))
+		{
+			next = static_cast<int>(m_tabs.size()) - 1;
+		}
+		SetActiveTab(next);
+	}
+
+	void Application::SetActiveTab(int index)
+	{
+		if (index < 0 || index >= static_cast<int>(m_tabs.size()))
+		{
+			return;
+		}
+
+		m_activeTab = index;
+
+		// 重新绑定上下文：面板与绘图区均指向同一数据层与当前标签页配置。
+		m_panel.SetContext(&m_dataSet, &m_tabs[static_cast<std::size_t>(m_activeTab)]);
+		m_plot.SetContext(&m_dataSet, &m_tabs[static_cast<std::size_t>(m_activeTab)]);
+
+		RefreshTabBar();
+		Relayout();
+
+		// 切换标签页后把该页已选中的信号滚动到可见位置。
+		// 切换标签页后把共享的选中信号滚动到可见位置（选中状态跨页保持一致）。
+		m_panel.ScrollToSignal(m_dataSet.Selected());
+
+		SynchronizeView(true);
+		UpdateWindowTitle();
+		InvalidateRect(m_hwnd, nullptr, TRUE);
+	}
+
+	void Application::RefreshTabBar()
+	{
+		std::vector<std::wstring> names;
+		names.reserve(m_tabs.size());
+		for (const TabConfig& tab : m_tabs)
+		{
+			names.push_back(tab.Name());
+		}
+		m_tabBar.SetTabs(names);
+		m_tabBar.SetActiveIndex(m_activeTab);
+	}
+
+	void Application::SynchronizeView(bool force)
+	{
+		if (m_tabs.empty() || m_activeTab < 0)
+		{
+			return;
+		}
+
+		TabConfig& tab = m_tabs[static_cast<std::size_t>(m_activeTab)];
+
+		const int visibleCount = tab.VisibleCount();
+		const bool anyVisible = tab.AnyVisible();
+		const std::size_t laneCount = tab.Lanes().size();
+
+		const bool changed = (visibleCount != m_cachedVisibleCount) || (anyVisible != m_cachedAnyVisible) ||
+		                     (laneCount != m_cachedLaneCount);
+		if (!changed && !force)
+		{
+			return;
+		}
+
+		const std::size_t previousLaneCount = m_cachedLaneCount;
+		m_cachedVisibleCount = visibleCount;
+		m_cachedAnyVisible = anyVisible;
+		m_cachedLaneCount = laneCount;
+
+		// 标签页首次出现可见信号时，把时间轴对齐到可见数据的范围。
+		// 没有任何可见信号时（未勾选 / 全部取消勾选 / 清空网格）主动复位自适应标记，
+		// 这样用户下一次勾选信号时会重新做一次自适应，而不是停留在上次的视图范围。
+		if (!anyVisible)
+		{
+			tab.ViewInitialized() = false;
+		}
+		else if (!tab.ViewInitialized())
+		{
+			// 首次出现可见信号时做一次自适应。单点信号（时间/幅值范围退化成 0）由
+			// `FitAll` 内部按"单值散点"的规则处理（居中 + 一大格 1s），这里不再分开判断。
+			m_plot.FitAll();
+		}
+
+		const bool laneCountChanged = (laneCount != previousLaneCount);
+		if (laneCountChanged || force)
+		{
+			// 网格数量变化会影响滚动条与绘图区宽度，必须重新布局。
+			Relayout();
+		}
+		else
+		{
+			m_plot.RefreshLanes();
+		}
+	}
+
+	void Application::SyncTabsToDataSet()
+	{
+		for (TabConfig& tab : m_tabs)
+		{
+			tab.SyncToDataSet(m_dataSet);
+		}
+
+		// 选中状态由数据层共享维护，数据变动后需校验其是否仍指向存在的信号。
+		m_dataSet.ValidateSelection();
+		m_panel.InvalidateRows();
+
+		// 分组/信号结构变化会让信号引用与分组地址改变，派生缓存必须整体作废。
+		m_plot.InvalidateDerivedCaches();
+
+		// 强制下一次同步重新计算视图状态。
+		m_cachedVisibleCount = -1;
+		m_cachedAnyVisible = false;
+		m_cachedLaneCount = 0;
+
+		if (m_hwnd != nullptr)
+		{
+			InvalidateRect(m_hwnd, nullptr, TRUE);
+		}
+	}
+
+	void Application::RemoveGroup(int groupIndex)
+	{
+		const SignalGroup* group = m_dataSet.GroupAt(groupIndex);
+		if (group == nullptr)
+		{
+			return;
+		}
+		const std::wstring name = group->name;
+
+		// 移除分组会释放大量采样内存：先暂停后台派生曲线计算，避免其读取已释放内存。
+		m_plot.PauseDerivedAsync();
+		// 先按旧下标修正各标签页配置与共享选中项，再从数据层移除，最后统一对齐。
+		for (TabConfig& tab : m_tabs)
+		{
+			tab.RemapAfterGroupRemoval(groupIndex);
+		}
+		m_dataSet.RemapSelectionAfterGroupRemoval(groupIndex);
+		m_dataSet.RemoveGroup(groupIndex);
+		SyncTabsToDataSet();
+
+		SetStatusMessage(L"已从工作区移除：" + name, false);
+		UpdateWindowTitle();
+	}
+
+	void Application::RemoveSignal(int groupIndex, int signalIndex)
+	{
+		SignalRef target;
+		target.groupIndex = groupIndex;
+		target.signalIndex = signalIndex;
+
+		const SignalData* signal = m_dataSet.Resolve(target);
+		const SignalGroup* group = m_dataSet.GroupAt(groupIndex);
+		if (signal == nullptr || group == nullptr)
+		{
+			return;
+		}
+		const std::wstring name = signal->name;
+
+		if (group->signals.size() <= 1)
+		{
+			// 组内只剩这一条信号：直接移除整个分组，避免在列表里留下一个空分组。
+			RemoveGroup(groupIndex);
+			return;
+		}
+
+		// 移除信号会释放采样内存：先暂停后台派生曲线计算，避免其读取已释放内存。
+		m_plot.PauseDerivedAsync();
+		// 先按旧下标修正各标签页配置与共享选中项，再从数据层移除（释放采样内存），最后对齐。
+		for (TabConfig& tab : m_tabs)
+		{
+			tab.RemapAfterSignalRemoval(groupIndex, signalIndex);
+		}
+		m_dataSet.RemapSelectionAfterSignalRemoval(groupIndex, signalIndex);
+		m_dataSet.RemoveSignal(groupIndex, signalIndex);
+		SyncTabsToDataSet();
+
+		SetStatusMessage(L"已从工作区移除信号：" + name, false);
+	}
+
+	void Application::UpdateWindowTitle()
+	{
+		// 标题栏 = 应用名称 + 分隔竖线 + 内存占用（单位在 KB/MB/GB 间自适应，保留两位小数）。
+		// 除内存占用外不再附带标签页、文件数量等无关信息。
+		// ⚠️ 内存口径 = **私有工作集**（与任务管理器"内存"列一致），不是总工作集。
+		std::wstring title = kWindowTitle;
+		title += kTitleSeparator;
+		title += kRamTitlePrefix;
+		title += FormatByteSize(ProcessPrivateWorkingSetBytes());
+		// 数值未变化时不调用 SetWindowTextW，避免无谓地重绘标题栏。
+		if (title == m_windowTitleText)
+		{
+			return;
+		}
+		m_windowTitleText = title;
+		SetWindowTextW(m_hwnd, m_windowTitleText.c_str());
+	}
+
+	void Application::OpenFileDialog()
+	{
+		// 允许一次选择多个文件，便于跨文件对比信号。
+		std::vector<wchar_t> buffer(static_cast<std::size_t>(MAX_PATH) * 16, L'\0');
+
+		OPENFILENAMEW dialog = {};
+		dialog.lStructSize = sizeof(dialog);
+		dialog.hwndOwner = m_hwnd;
+		dialog.lpstrFilter = SignalFileDialogFilter();
+		dialog.lpstrFile = buffer.data();
+		dialog.nMaxFile = static_cast<DWORD>(buffer.size());
+		dialog.lpstrTitle = L"打开测量数据文件（可多选）";
+		dialog.lpstrDefExt = L"csv";
+		dialog.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_NOCHANGEDIR |
+		               OFN_ALLOWMULTISELECT;
+
+		if (GetOpenFileNameW(&dialog) == FALSE)
+		{
+			return;
+		}
+
+		// 多选时首段为目录，其余为文件名；单选时整段即为完整路径。
+		const std::wstring first(buffer.data());
+		const wchar_t* cursor = buffer.data() + first.size() + 1;
+
+		int loaded = 0;
+		if (*cursor == L'\0')
+		{
+			if (LoadFile(first))
+			{
+				++loaded;
+			}
+		}
+		else
+		{
+			while (*cursor != L'\0')
+			{
+				const std::wstring name(cursor);
+				if (LoadFile(first + L"\\" + name))
+				{
+					++loaded;
+				}
+				cursor += name.size() + 1;
+			}
+		}
+
+		if (loaded > 0)
+		{
+			SetStatusMessage(L"已加载 " + std::to_wstring(loaded) +
+			                     L" 个文件，请在左侧勾选需要查看的信号。",
+			                 false);
+		}
+	}
+
+	void Application::ExecuteToolbarAction(ToolbarAction action)
+	{
+		switch (action)
+		{
+		case ToolbarAction::OPEN_FILE:
+			OpenFileDialog();
+			break;
+		case ToolbarAction::FIT_ALL:
+			// 自适应同时回到初始状态：退出缩放模式并显示全部信号范围。
+			m_plot.FitAll();
+			SetStatusMessage(L"已恢复自适应视图。", false);
+			break;
+		case ToolbarAction::AUTO_FIT_Y:
+		{
+			// 与网格右键菜单中的「选区 Y 轴自适应（全局）」同一开关：
+			// 打开后立即按当前视图自适应一次，之后每次时间轴选区放大都会自动匹配。
+			const bool enable = !m_plot.AllLanesAutoFitToSelection();
+			m_plot.SetAllLanesAutoFitToSelection(enable, true);
+			SetStatusMessage(enable ? L"已开启选区 Y 轴自适应：时间轴选区放大后自动匹配各网格 Y 轴。"
+			                        : L"已关闭选区 Y 轴自适应。",
+			                false);
+			break;
+		}
+		case ToolbarAction::ZOOM_SELECT:
+			m_plot.ToggleZoomMode(PlotZoomMode::SELECT);
+			break;
+		case ToolbarAction::CURSOR:
+			m_plot.CycleCursorMode();
+			break;
+		case ToolbarAction::MERGE_LANES:
+			if (!m_dataSet.Empty())
+			{
+				ActiveTab().SetMode(LaneMode::MERGED);
+				SetStatusMessage(L"已将当前标签页的全部可见信号合并到同一网格。", false);
+			}
+			break;
+		case ToolbarAction::SPLIT_LANES:
+			if (!m_dataSet.Empty())
+			{
+				ActiveTab().SetMode(LaneMode::PER_SIGNAL);
+				SetStatusMessage(L"当前标签页已切换为「每信号一格」。", false);
+			}
+			break;
+		case ToolbarAction::CLEAR_ALL:
+			if (!m_dataSet.Empty())
+			{
+				ActiveTab().SetAllVisible(false);
+				m_panel.InvalidateRows();
+				SetStatusMessage(L"已清空当前标签页的全部网格。", false);
+			}
+			break;
+		case ToolbarAction::NONE:
+		default:
+			break;
+		}
+
+		if (m_hwnd != nullptr)
+		{
+			InvalidateRect(m_hwnd, nullptr, TRUE);
+		}
+	}
+
+	bool Application::HandleKeyDown(WPARAM key)
+	{
+		const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
+
+		if (control && key == L'O')
+		{
+			OpenFileDialog();
+			return true;
+		}
+		if (control && key == L'T')
+		{
+			NewTab(true);
+			return true;
+		}
+		if (control && key == L'W')
+		{
+			CloseTab(m_activeTab);
+			return true;
+		}
+		if (control && key == VK_TAB)
+		{
+			if (m_tabs.size() > 1)
+			{
+				const bool backward = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
+				const int count = static_cast<int>(m_tabs.size());
+				SetActiveTab((m_activeTab + (backward ? count - 1 : 1)) % count);
+			}
+			return true;
+		}
+
+		switch (key)
+		{
+		case VK_ESCAPE:
+		{
+			// Esc 的语义：
+			// 1) 放弃当前正在进行的拖拽（典型场景：缩放的框选选区还没松开左键）；
+			//    取消后不应用选区、视图范围保持不变；
+			// 2) 同时退出全部缩放模式，使工具栏「时间轴选区」「Y 轴选区」回到未选中态。
+			// Esc 不与时间光标关联：关闭光标请用工具栏「光标」按钮，避免误关指针。
+			bool changed = m_plot.CancelDrag();
+			changed = m_plot.ExitZoomModes() || changed;
+			return changed;
+		}
+		case VK_ADD:
+		case VK_OEM_PLUS:
+			m_plot.ZoomTimeStep(1.4);
+			return true;
+		case VK_SUBTRACT:
+		case VK_OEM_MINUS:
+			m_plot.ZoomTimeStep(1.0 / 1.4);
+			return true;
+		case VK_LEFT:
+			m_plot.PanTimeByFraction(-0.12);
+			return true;
+		case VK_RIGHT:
+			m_plot.PanTimeByFraction(0.12);
+			return true;
+		case VK_UP:
+			m_plot.ScrollLanesByFraction(-0.12);
+			return true;
+		case VK_DOWN:
+			m_plot.ScrollLanesByFraction(0.12);
+			return true;
+		default:
+			break;
+		}
+
+		if (key == L'F')
+		{
+			m_plot.FitAll();
+			return true;
+		}
+		return false;
+	}
+
+	void Application::UpdateDragCursor(int x, int y)
+	{
+		// 鼠标捕获期间不再有 WM_SETCURSOR，只能自己按当前状态设置光标。
+		HCURSOR cursor = nullptr;
+		if (m_activeTarget == Target::PLOT)
+		{
+			cursor = m_plot.QueryCursor(x, y);
+		}
+		SetCursor(cursor != nullptr ? cursor : LoadCursorW(nullptr, IDC_ARROW));
+	}
+
+	bool Application::HandleMouseMove(int x, int y, bool buttonDown)
+	{
+		if (buttonDown && m_activeTarget != Target::NONE)
+		{
+			switch (m_activeTarget)
+			{
+			case Target::SPLITTER:
+				if (m_draggingSplitter && m_scale > 0.0f)
+				{
+					const float desired = static_cast<float>(x - m_splitterGrabOffset) / m_scale;
+					const float maximum =
+					    std::min(kMaxPanelWidth, static_cast<float>(kMinClientWidth) / m_scale);
+					m_panelWidth = std::max(kMinPanelWidth, std::min(desired, maximum));
+					Relayout();
+					return true;
+				}
+				return false;
+			case Target::PLOT:
+				return m_plot.OnMouseMove(x, y);
+			case Target::PANEL:
+				return m_panel.OnMouseMove(x, y);
+			case Target::TOOLBAR:
+				return m_toolbar.OnMouseMove(x, y);
+			case Target::TAB_BAR:
+				return m_tabBar.OnMouseMove(x, y);
+			case Target::EDIT_FIELD:
+			{
+				// 输入框拖拽框选：按当前正在编辑的组件分发。
+				bool changed = m_tabBar.OnEditMouseMove(x);
+				changed = m_panel.OnEditMouseMove(x) || changed;
+				changed = m_plot.OnEditMouseMove(x) || changed;
+				changed = m_colorPicker.OnEditMouseMove(x) || changed;
+				return changed;
+			}
+			case Target::NONE:
+			default:
+				return false;
+			}
+		}
+
+		bool changed = false;
+		changed =
+		    (m_tabBar.HitTest(x, y) ? m_tabBar.OnMouseMove(x, y) : m_tabBar.OnMouseLeave()) || changed;
+		// ⚠️ 按住工具栏按钮期间**绝不能**走 `OnMouseLeave()`：它会清掉按下态（`m_pressedIndex`），
+		//    于是随后在按钮上松手时什么也不会发生 —— 这正是“快速点击工具栏按钮时状态没切换”
+		//    的另一个成因（鼠标带着按下态从按钮边缘移出时会命中这里）。
+		if (m_toolbar.HitTest(x, y))
+		{
+			changed = m_toolbar.OnMouseMove(x, y) || changed;
+		}
+		else if (m_activeTarget != Target::TOOLBAR)
+		{
+			changed = m_toolbar.OnMouseLeave() || changed;
+		}
+		changed = (m_panel.HitTest(x, y) ? m_panel.OnMouseMove(x, y) : m_panel.OnMouseLeave()) || changed;
+		changed = (m_plot.HitTest(x, y) ? m_plot.OnMouseMove(x, y) : m_plot.OnMouseLeave()) || changed;
+		return changed;
+	}
+
+	void Application::OnTabBarResult(const TabBarResult& result)
+	{
+		switch (result.type)
+		{
+		case TabBarResult::Type::ADD:
+			NewTab(true);
+			break;
+		case TabBarResult::Type::SELECT:
+			if (result.index != m_activeTab)
+			{
+				SetActiveTab(result.index);
+			}
+			break;
+		case TabBarResult::Type::CLOSE:
+			CloseTab(result.index);
+			break;
+		case TabBarResult::Type::CONTEXT:
+			ShowTabContextMenu(result);
+			break;
+		case TabBarResult::Type::REORDER:
+			MoveTab(result.index, result.targetIndex);
+			break;
+		case TabBarResult::Type::RENAME:
+			if (result.index >= 0 && result.index < static_cast<int>(m_tabs.size()) && !result.text.empty())
+			{
+				m_tabs[static_cast<std::size_t>(result.index)].SetName(result.text);
+				RefreshTabBar();
+				// SetTabs 会重置各标签的矩形，必须重新布局才能把它们算回来。
+				Relayout();
+				InvalidateRect(m_hwnd, nullptr, TRUE);
+			}
+			break;
+		case TabBarResult::Type::NONE:
+		default:
+			break;
+		}
+	}
+
+	void Application::MoveTab(int from, int target)
+	{
+		if (from < 0 || from >= static_cast<int>(m_tabs.size()))
+		{
+			return;
+		}
+		if (target < 0 || target > static_cast<int>(m_tabs.size()))
+		{
+			return;
+		}
+
+		// 拖拽语义：target 表示「插入到该下标之前」；向后拖时需扣除自身占位。
+		int destination = target;
+		if (destination > from)
+		{
+			--destination;
+		}
+		destination = std::max(0, std::min(destination, static_cast<int>(m_tabs.size()) - 1));
+		if (destination == from)
+		{
+			return;
+		}
+
+		// 保持当前激活的标签页在重排后仍处于激活状态。
+		TabConfig moved = m_tabs[static_cast<std::size_t>(from)];
+		const int activeIndex = m_activeTab;
+
+		m_tabs.erase(m_tabs.begin() + from);
+		m_tabs.insert(m_tabs.begin() + destination, std::move(moved));
+
+		int newActive = activeIndex;
+		if (activeIndex == from)
+		{
+			newActive = destination;
+		}
+		else if (from < activeIndex && destination >= activeIndex)
+		{
+			--newActive;
+		}
+		else if (from > activeIndex && destination <= activeIndex)
+		{
+			++newActive;
+		}
+
+		SetActiveTab(newActive);
+		InvalidateRect(m_hwnd, nullptr, TRUE);
+	}
+
+	bool Application::ApplyPendingRename()
+	{
+		SignalRef ref;
+		std::wstring name;
+		if (!m_plot.TakePendingRename(ref, name))
+		{
+			return false;
+		}
+
+		if (!m_dataSet.RenameSignal(ref.groupIndex, ref.signalIndex, name))
+		{
+			return false;
+		}
+
+		// 改名只影响显示，但需要刷新左侧列表与绘图区图例。
+		m_panel.InvalidateRows();
+		SetStatusMessage(L"信号已重命名为：" + name, false);
+		InvalidateRect(m_hwnd, nullptr, TRUE);
+		return true;
+	}
+
+	bool Application::BuildDerivedSignal(const DerivedSignalRequest& request, bool makeVisible)
+	{
+		const SignalGroup* group = m_dataSet.GroupAt(request.groupIndex);
+		if (group == nullptr || request.signalIndex < 0 ||
+		    request.signalIndex >= static_cast<int>(group->signals.size()))
+		{
+			return false;
+		}
+		const SignalData& source = group->signals[static_cast<std::size_t>(request.signalIndex)];
+		const TimeAxis& axis = group->AxisOf(source);
+		const std::wstring baseName = source.name;
+
+		// 0. 先把源信号的「调整」变换快照下来（下面 `InsertDerivedSignal` 会移动信号存储，
+		//    之后再取 `source` 会悬垂）。
+		//
+		// ⚠️ **变换要"烘进数据"，而不是让新信号继承这套指纹**（用户明确要求）：
+		// 网格里的预览曲线画的是 `变换(滤波结果)`。若新信号只存 `滤波结果` 再**继承变换**，
+		// 它的「调整」面板里就会莫名其妙带着一整套系数 / 镜像 / 偏移 —— 用户看到的是
+		// "新信号只是继承了原信号的指纹，数据本身没变"。现在改为：
+		//   * 数值域变换（系数 → 绝对值 → 垂直镜像 → Y 偏移）**与**水平镜像（数据反序）
+		//     全部作用在派生采样值上；
+		//   * 于是新信号**用默认外观**绘制出来就与预览曲线逐位一致。
+		//   * ⚠️ **时间轴偏移也一并烘进数据**（见 2c：按 `time[i] - offsetTime` 重采样）。
+		//     新信号与源信号共用同一个文件时间轴，因此时间平移只能写进采样值 —— 这样
+		//     新信号**不启用任何「调整」**就与预览逐点重合（用户明确要求）。
+		//     只有"无法烘值"的退化情形才退回把 `offsetTime` 带在样式上（见 3b）。
+		SignalStyle sourceTransform;
+		bool hasSourceStyle = false;
+		{
+			SignalRef sourceRef;
+			sourceRef.groupIndex = request.groupIndex;
+			sourceRef.signalIndex = request.signalIndex;
+			if (const SignalStyle* sourceStyle = m_dataSet.Style(sourceRef))
+			{
+				sourceTransform = *sourceStyle;
+				hasSourceStyle = true;
+			}
+		}
+
+		// 1. 计算派生采样值（与网格内的预览曲线共用同一实现，因此逐位一致）。
+		//    多次迭代均值滤波形如「<原信号名称> (N点均值 M次迭代)」，
+		//    弱峰调整形如「<原信号名称> (弱峰调整 M% N次迭代)」。
+		std::vector<float> derived_values;
+		SignalData derived;
+		if (request.weakPeak)
+		{
+			ComputeWeakPeakAdjust(source.values, static_cast<double>(request.amountPercent) / 100.0,
+			                     request.iterations, derived_values);
+			derived.name = baseName + L" (弱峰调整 " + std::to_wstring(request.amountPercent) + L"% " +
+			               std::to_wstring(request.iterations) + L"次迭代)";
+		}
+		else
+		{
+			ComputeMovingAverageIterated(source.values, request.points, request.iterations, derived_values);
+			derived.name = baseName + L" (" + std::to_wstring(request.points) + L"点均值 " +
+			               std::to_wstring(request.iterations) + L"次迭代)";
+		}
+
+		// 2. 组装新信号（外观一律用默认值：变换已经烘进采样数据，不再是"继承的指纹"）。
+		//    ⚠️ 新信号**沿用源信号的时间轴**（`axisIndex`）：派生只改采样值，不改时间基准。
+		derived.axisIndex = source.axisIndex;
+		derived.values.assign(derived_values.begin(), derived_values.end());
+
+		// 2b. 把源信号的「调整」变换**烘进派生采样值**：
+		//     * 数值域（系数 → 绝对值 → 垂直镜像 → Y 偏移）逐点套用 `ApplyDrawTransform`；
+		//     * 水平镜像 = 数据反序，等价于把采样数组整体反转。
+		//     ⚠️ `ApplyDrawTransform` 是逐点函数，因此"先变换再反转"与"先反转再变换"等价。
+		if (hasSourceStyle)
+		{
+			const bool valueTransform =
+			    (sourceTransform.gain != 1.0f || sourceTransform.absolute ||
+			     sourceTransform.mirrorVertical || sourceTransform.offsetY != 0.0f);
+			if (valueTransform)
+			{
+				for (double& value : derived.values)
+				{
+					value = ApplyDrawTransform(sourceTransform, value);
+				}
+			}
+			if (sourceTransform.mirrorHorizontal)
+			{
+				std::reverse(derived.values.begin(), derived.values.end());
+			}
+		}
+
+		// 2c. 时间轴偏移：把 `offsetTime` 也**重采样烘进采样值**。
+		//
+		// 预览曲线是按「源信号样式」绘制的，它的时间轴偏移会把曲线整体横向平移。
+		// 派生信号与源信号**共用同一个文件时间轴**，所以时间平移本无法写进"时间列"；
+		// 但用户明确要求：**新信号不启用任何「调整」也要与预览逐点重合**
+		//（新信号的「调整」面板必须是默认值，不允许靠"继承 offsetTime"来表达）。
+		// 因此这里把平移直接写进数据：
+		//   * 新信号第 i 个采样 = 预览曲线在 `time[i]` 时刻显示的值
+		//     = 已变换的曲线在 `time[i] - offsetTime` 处的取值（取最近的采样点）；
+		//   * 平移后落在数据范围之外的采样置 NaN —— 与预览"该处没有曲线"完全一致。
+		// ⚠️ 一次整段重采样需要一份等长的临时缓冲（千万级采样 ≈ 数十 MB），用完立即释放；
+		//    这是"构建为新信号"的一次性操作，不在交互路径上。
+		// ⚠️ 时间轴非单调时无法按下标单调推进取样（只能整表扫描），此时退回"继承
+		//    `offsetTime`"（见 3b）：两条路径的**显示效果相同**，只是偏移留在样式里。
+		bool timeShiftBaked = false;
+		if (hasSourceStyle && sourceTransform.offsetTime != 0.0 && axis.monotonic)
+		{
+			const std::vector<double>& times = axis.time;
+			const std::size_t total = derived.values.size();
+			if (total > 1 && times.size() >= total)
+			{
+				const double shift = sourceTransform.offsetTime;
+				std::vector<double> shifted(total, std::numeric_limits<double>::quiet_NaN());
+				// 目标时刻 `times[index] - shift` 随 index 单调不减 → 游标只前进，整体 O(n)。
+				std::size_t probe = 0;
+				for (std::size_t index = 0; index < total; ++index)
+				{
+					const double target = times[index] - shift;
+					if (!std::isfinite(target) || target < times[0] || target > times[total - 1])
+					{
+						continue;	// 平移后越界：该处没有曲线
+					}
+					while (probe + 1 < total && times[probe + 1] < target)
+					{
+						++probe;
+					}
+					std::size_t nearest = probe;
+					if (probe + 1 < total &&
+					    std::fabs(times[probe + 1] - target) < std::fabs(times[probe] - target))
+					{
+						nearest = probe + 1;
+					}
+					shifted[index] = derived.values[nearest];
+				}
+				derived.values.swap(shifted);
+				timeShiftBaked = true;
+			}
+		}
+
+		// 3. 插入到原信号的下方（数据层 + 各标签页引用重映射）。
+		int newIndex = -1;
+		// 插入派生信号会移动该分组的信号存储：先暂停后台计算，避免其读取已移动的数据。
+		m_plot.PauseDerivedAsync();
+		if (!m_dataSet.InsertDerivedSignal(request.groupIndex, request.signalIndex, std::move(derived),
+		                                   newIndex))
+		{
+			return false;
+		}
+		for (TabConfig& tab : m_tabs)
+		{
+			tab.RemapAfterSignalInsert(request.groupIndex, newIndex);
+		}
+
+		// 3b. 时间轴偏移正常情况下已烘进采样值（见 2c），新信号的「调整」全部保持默认。
+		//     ⚠️ 只有"无法烘值"的退化情形（时间轴非单调 / 时间列缺失）才退回到把
+		//     `offsetTime` 带在新信号样式上 —— 无论如何都要让**显示**与预览一致。
+		if (hasSourceStyle && sourceTransform.offsetTime != 0.0 && !timeShiftBaked)
+		{
+			if (SignalStyle* derivedStyle = m_dataSet.Style(SignalRef{request.groupIndex, newIndex}))
+			{
+				derivedStyle->offsetTime = sourceTransform.offsetTime;
+			}
+		}
+
+		// 4. 在当前标签页中勾选新信号，并把它所在的网格移到原信号网格的下方。
+		if (makeVisible && !m_tabs.empty())
+		{
+			SignalRef derivedRef;
+			derivedRef.groupIndex = request.groupIndex;
+			derivedRef.signalIndex = newIndex;
+			ActiveTab().SetVisible(derivedRef, true);
+
+			SignalRef sourceRef;
+			sourceRef.groupIndex = request.groupIndex;
+			sourceRef.signalIndex = request.signalIndex;
+			ActiveTab().MoveLaneOfSignalBelow(derivedRef, sourceRef);
+		}
+
+		// 5. 数据层结构变化：刷新列表、作废折线/派生缓存并重绘。
+		SyncTabsToDataSet();
+		return true;
+	}
+
+	bool Application::ApplyPendingPanelScroll()
+	{
+		SignalRef ref;
+		if (!m_plot.TakePanelScrollRequest(ref) || !ref.IsValid())
+		{
+			return false;
+		}
+		// 平滑滚动（带动画）：用户要求"是滚动的而不是立刻翻到目标信号位置"。
+		m_panel.ScrollToSignalAnimated(ref);
+		return true;
+	}
+
+	bool Application::ApplyPendingDerivedBuild()
+	{
+		// 两类「构建为新信号」请求（均值滤波 / 弱峰调整）机制完全一致，
+		// 统一整理成同一份构建清单后按下标降序处理。
+		std::vector<DerivedSignalRequest> requests;
+		{
+			int laneIndex = -1;
+			std::vector<PlotView::MeanFilterBuild> items;
+			if (m_plot.TakePendingMeanFilterBuild(laneIndex, items))
+			{
+				for (const PlotView::MeanFilterBuild& item : items)
+				{
+					DerivedSignalRequest request;
+					request.groupIndex = item.groupIndex;
+					request.signalIndex = item.signalIndex;
+					request.points = item.points;
+					request.iterations = item.iterations;
+					request.weakPeak = false;
+					requests.push_back(request);
+				}
+			}
+		}
+		{
+			int laneIndex = -1;
+			std::vector<PlotView::WeakPeakBuild> items;
+			if (m_plot.TakePendingWeakPeakBuild(laneIndex, items))
+			{
+				for (const PlotView::WeakPeakBuild& item : items)
+				{
+					DerivedSignalRequest request;
+					request.groupIndex = item.groupIndex;
+					request.signalIndex = item.signalIndex;
+					request.amountPercent = item.amountPercent;
+					request.iterations = item.iterations;
+					request.weakPeak = true;
+					requests.push_back(request);
+				}
+			}
+		}
+		if (requests.empty())
+		{
+			return false;
+		}
+		if (m_tabs.empty())
+		{
+			return false;
+		}
+
+		// **同一文件内必须按下标降序处理**：每次插入只让插入点之后的信号下标 +1，
+		// 降序处理可保证尚未处理的信号下标始终有效（升序会把新插入的信号当成原信号）。
+		std::sort(requests.begin(), requests.end(),
+		          [](const DerivedSignalRequest& a, const DerivedSignalRequest& b)
+		          {
+			          if (a.groupIndex != b.groupIndex)
+			          {
+				          return a.groupIndex < b.groupIndex;
+			          }
+			          return a.signalIndex > b.signalIndex;
+		          });
+
+		int built = 0;
+		DerivedSignalRequest last;
+		for (const DerivedSignalRequest& request : requests)
+		{
+			if (BuildDerivedSignal(request, true))
+			{
+				++built;
+				last = request;
+			}
+		}
+
+		if (built > 0)
+		{
+			std::wstring text = L"已构建 " + std::to_wstring(built) + L" 条 ";
+			if (last.weakPeak)
+			{
+				text += L"弱峰调整 " + std::to_wstring(last.amountPercent) + L"% " +
+				        std::to_wstring(last.iterations) + L"次迭代信号。";
+			}
+			else
+			{
+				text += std::to_wstring(last.points) + L"点均值 " +
+				        std::to_wstring(last.iterations) + L"次迭代滤波信号。";
+			}
+			SetStatusMessage(text, false);
+		}
+		return built > 0;
+	}
+
+	void Application::ShowTabContextMenu(const TabBarResult& result)
+	{
+		if (result.index < 0 || result.index >= static_cast<int>(m_tabs.size()))
+		{
+			return;
+		}
+
+		m_tabMenuIndex = result.index;
+
+		std::vector<MenuItem> items;
+
+		MenuItem header;
+		header.kind = MenuItemKind::HEADER;
+		header.label = m_tabs[static_cast<std::size_t>(result.index)].Name();
+		items.push_back(header);
+
+		MenuItem create;
+		create.label = L"新建标签页";
+		create.id = kMenuTabNew;
+		items.push_back(create);
+
+		MenuItem close;
+		close.label = L"关闭该标签页";
+		close.id = kMenuTabClose;
+		close.enabled = (m_tabs.size() > 1);
+		items.push_back(close);
+
+		MenuItem closeOthers;
+		closeOthers.label = L"关闭其它标签页";
+		closeOthers.id = kMenuTabCloseOthers;
+		closeOthers.enabled = (m_tabs.size() > 1);
+		items.push_back(closeOthers);
+
+		// 菜单绘制在客户区内，因此把屏幕坐标换算为客户区坐标。
+		POINT anchor = {result.screenX, result.screenY};
+		ScreenToClient(m_hwnd, &anchor);
+
+		RECT client = {};
+		GetClientRect(m_hwnd, &client);
+		const gd::RectF bounds(0.0f, 0.0f, static_cast<float>(client.right - client.left),
+		                       static_cast<float>(client.bottom - client.top));
+
+		m_menu.Open(MenuScope::TAB_BAR, bounds, anchor.x, anchor.y, items);
+	}
+
+	void Application::ShowPlotContextMenu(int laneIndex, int x, int y)
+	{
+		if (laneIndex < 0)
+		{
+			return;
+		}
+
+		m_plotMenuLane = laneIndex;
+
+		std::vector<MenuItem> items;
+
+		MenuItem header;
+		header.kind = MenuItemKind::HEADER;
+		header.label = L"网格 " + std::to_wstring(laneIndex + 1);
+		items.push_back(header);
+
+		// 当前网格的 Y 轴上下限值直接在菜单内的输入框里显示，单击即可就地编辑（菜单不关闭）。
+		double laneYMin = 0.0;
+		double laneYMax = 1.0;
+		m_plot.LaneRange(laneIndex, laneYMin, laneYMax);
+
+		MenuItem maxItem;
+		maxItem.kind = MenuItemKind::EDIT;
+		maxItem.label = L"Y 轴最大值";
+		maxItem.id = PLOT_CMD_LANE_Y_MAX;
+		maxItem.value = FormatValue(laneYMax);
+		maxItem.filter = EditFilter::NUMBER;
+		items.push_back(maxItem);
+
+		MenuItem minItem;
+		minItem.kind = MenuItemKind::EDIT;
+		minItem.label = L"Y 轴最小值";
+		minItem.id = PLOT_CMD_LANE_Y_MIN;
+		minItem.value = FormatValue(laneYMin);
+		minItem.filter = EditFilter::NUMBER;
+		items.push_back(minItem);
+
+		// 选区自适应（切换项）：勾选后每次本网格的时间轴选区放大都会自动匹配 Y 轴幅值。
+		MenuItem autoViewItem;
+		autoViewItem.label = L"选区 Y 轴自适应";
+		autoViewItem.id = PLOT_CMD_LANE_AUTO_VIEW;
+		autoViewItem.checked = m_plot.LaneAutoFitToSelection(laneIndex);
+		items.push_back(autoViewItem);
+
+		// 时间轴自适应到本网格信号范围（原先位于分隔线下方，现移到分隔线上方）。
+		MenuItem fitLaneTime;
+		fitLaneTime.label = L"按网格时间轴展开";
+		fitLaneTime.id = PLOT_CMD_LANE_FIT_TIME;
+		items.push_back(fitLaneTime);
+
+		// 「拆分当前网格」：把该网格内的信号按个拆成独立网格，插到其下方依次排列。
+		// 可点击时在后方追加「（N个信号）」说明将拆出的网格数；只有 1 条信号时置灰且不加尾缀。
+		MenuItem splitLane;
+		const std::size_t laneSignalCount = m_plot.LaneSignalCount(laneIndex);
+		splitLane.label = (laneSignalCount > 1)
+		                      ? (L"拆分当前网格（" + std::to_wstring(laneSignalCount) + L"个信号）")
+		                      : L"拆分当前网格";
+		splitLane.id = PLOT_CMD_LANE_SPLIT;
+		splitLane.enabled = laneSignalCount > 1;
+		items.push_back(splitLane);
+
+		// 实验性功能（二级菜单）：横线上方，鼠标悬停即向右展开。
+		MenuItem experimental;		experimental.kind = MenuItemKind::SUBMENU;
+		experimental.label = L"实验性功能";
+		{
+			MenuItem edgeCount;
+			edgeCount.label = L"边沿计数";
+			edgeCount.id = PLOT_CMD_LANE_EDGE_COUNT;
+			edgeCount.checked = m_plot.LaneEdgeCount(laneIndex);
+			experimental.submenu.push_back(edgeCount);
+
+			MenuItem edgeCenter;
+			edgeCenter.label = L"边沿计数（中心轴）";
+			edgeCenter.id = PLOT_CMD_LANE_EDGE_CENTER;
+			edgeCenter.checked = m_plot.LaneEdgeCenterCount(laneIndex);
+			experimental.submenu.push_back(edgeCenter);
+
+			MenuItem meanFilter;
+			meanFilter.label = L"均值滤波";
+			meanFilter.id = PLOT_CMD_LANE_MEAN_FILTER;
+			meanFilter.checked = m_plot.LaneMeanFilter(laneIndex);
+			experimental.submenu.push_back(meanFilter);
+
+			MenuItem weakPeak;
+			weakPeak.label = L"弱峰调整";
+			weakPeak.id = PLOT_CMD_LANE_WEAK_PEAK;
+			weakPeak.checked = m_plot.LaneWeakPeak(laneIndex);
+			experimental.submenu.push_back(weakPeak);
+		}
+		items.push_back(experimental);
+
+		MenuItem separator;
+		separator.kind = MenuItemKind::SEPARATOR;
+		items.push_back(separator);
+
+		// 全局开关：一次性打开/关闭全部网格各自的「选区 Y 轴自适应」。
+		MenuItem autoFitAllItem;
+		autoFitAllItem.label = L"选区 Y 轴自适应（全局）";
+		autoFitAllItem.id = PLOT_CMD_AUTO_FIT_ALL;
+		autoFitAllItem.checked = m_plot.AllLanesAutoFitToSelection();
+		items.push_back(autoFitAllItem);
+
+		MenuItem fitItem;
+		fitItem.label = L"全部自适应";
+		fitItem.id = PLOT_CMD_FIT_ALL;
+		items.push_back(fitItem);
+
+		RECT client = {};
+		GetClientRect(m_hwnd, &client);
+		const gd::RectF bounds(0.0f, 0.0f, static_cast<float>(client.right - client.left),
+		                       static_cast<float>(client.bottom - client.top));
+
+		m_menu.Open(MenuScope::PLOT_VIEW, bounds, x, y, items);
+	}
+
+	void Application::RefreshPlotMenuValues(int laneIndex)
+	{
+		if (laneIndex < 0)
+		{
+			return;
+		}
+
+		double laneYMin = 0.0;
+		double laneYMax = 1.0;
+		m_plot.LaneRange(laneIndex, laneYMin, laneYMax);
+		m_menu.UpdateItemValue(PLOT_CMD_LANE_Y_MAX, FormatValue(laneYMax));
+		m_menu.UpdateItemValue(PLOT_CMD_LANE_Y_MIN, FormatValue(laneYMin));
+
+		// 「选区 Y 轴自适应」（本网格）与「（全局）」都是切换项，实时反映各自的勾选状态。
+		m_menu.UpdateItemLabel(PLOT_CMD_LANE_AUTO_VIEW, L"选区 Y 轴自适应",
+		                       m_plot.LaneAutoFitToSelection(laneIndex), true);
+		m_menu.UpdateItemLabel(PLOT_CMD_AUTO_FIT_ALL, L"选区 Y 轴自适应（全局）",
+		                       m_plot.AllLanesAutoFitToSelection(), true);
+	}
+
+	void Application::DispatchMenuResult(const MenuResult& result)
+	{
+		if (!result.valid)
+		{
+			return;
+		}
+
+		switch (result.scope)
+		{
+		case MenuScope::SIGNAL_PANEL:
+		{
+			const bool needRelayout = m_panel.OnMenuCommand(result);
+			if (needRelayout)
+			{
+				Relayout();
+			}
+			InvalidateRect(m_hwnd, nullptr, FALSE);
+			break;
+		}
+		case MenuScope::PLOT_VIEW:
+		{
+			// 菜单内联输入框的提交：就地更新网格 Y 轴上下限，菜单保持打开，
+			// 并把夹取后的真实值回写到菜单上（输入值可能被合法区间修正）。
+			if (result.editCommit)
+			{
+				const int laneIndex = m_plotMenuLane;
+				if (laneIndex >= 0)
+				{
+					m_plot.ApplyLaneValueText(laneIndex, result.id == PLOT_CMD_LANE_Y_MAX, result.editText);
+					RefreshPlotMenuValues(laneIndex);
+				}
+				SetFocus(m_hwnd);
+				InvalidateRect(m_hwnd, nullptr, FALSE);
+				break;
+			}
+
+			const int laneIndex = m_plotMenuLane;
+			m_plotMenuLane = -1;
+			switch (result.id)
+			{
+			case PLOT_CMD_LANE_AUTO_VIEW:
+				// 切换本网格的「选区 Y 轴自适应」。
+				m_plot.ToggleLaneAutoFitToSelection(laneIndex);
+				break;
+			case PLOT_CMD_AUTO_FIT_ALL:
+			{
+				// 全局切换：一次打开/关闭全部网格各自的开关；打开时立即生效一次。
+				const bool enable = !m_plot.AllLanesAutoFitToSelection();
+				m_plot.SetAllLanesAutoFitToSelection(enable, true);
+				break;
+			}
+			case PLOT_CMD_LANE_FIT_TIME:
+				// 「按网格时间轴展开」：展开时间轴后同时把该网格的 Y 轴自适应一次。
+				m_plot.FitTimeToLane(laneIndex);
+				break;
+			case PLOT_CMD_LANE_EDGE_COUNT:
+				// 「实验性功能 → 边沿计数」：切换本网格的横向光标与统计面板。
+				m_plot.ToggleLaneEdgeCount(laneIndex);
+				break;
+			case PLOT_CMD_LANE_EDGE_CENTER:
+				// 「实验性功能 → 边沿计数（中心轴）」：切换中心平均值曲线与统计面板。
+				m_plot.ToggleLaneEdgeCenterCount(laneIndex);
+				break;
+			case PLOT_CMD_LANE_MEAN_FILTER:
+				// 「实验性功能 → 均值滤波」：切换均值滤波曲线与参数面板。
+				m_plot.ToggleLaneMeanFilter(laneIndex);
+				break;
+			case PLOT_CMD_LANE_WEAK_PEAK:
+				// 「实验性功能 → 弱峰调整」：切换弱峰调整曲线与参数面板。
+				m_plot.ToggleLaneWeakPeak(laneIndex);
+				break;
+			case PLOT_CMD_LANE_SPLIT:
+				// 「拆分当前网格」：信号按个拆成独立网格，新网格顺次插入其下方。
+				m_plot.SplitLane(laneIndex);
+				break;
+			case PLOT_CMD_FIT_ALL:
+				m_plot.FitAll();
+				break;
+			default:
+				break;
+			}
+			SetFocus(m_hwnd);
+			InvalidateRect(m_hwnd, nullptr, TRUE);
+			break;
+		}
+		case MenuScope::TAB_BAR:
+		{
+			const int index = m_tabMenuIndex;
+			if (result.id == kMenuTabNew)
+			{
+				NewTab(true);
+			}
+			else if (result.id == kMenuTabClose)
+			{
+				CloseTab(index);
+			}
+			else if (result.id == kMenuTabCloseOthers)
+			{
+				if (index >= 0 && index < static_cast<int>(m_tabs.size()) && m_tabs.size() > 1)
+				{
+					const TabConfig keep = m_tabs[static_cast<std::size_t>(index)];
+					m_tabs.clear();
+					m_tabs.push_back(keep);
+					SetActiveTab(0);
+				}
+			}
+			m_tabMenuIndex = -1;
+			InvalidateRect(m_hwnd, nullptr, TRUE);
+			break;
+		}
+		case MenuScope::NONE:
+		default:
+			break;
+		}
+	}
+
+
+} // namespace jdi
+
diff --git a/Components/Application/Src/ApplicationInternal.hpp b/Components/Application/Src/ApplicationInternal.hpp
new file mode 100644
index 0000000..ed6f182
--- /dev/null
+++ b/Components/Application/Src/ApplicationInternal.hpp
@@ -0,0 +1,312 @@
+#ifndef __APPLICATION_INTERNAL_HPP__
+#define __APPLICATION_INTERNAL_HPP__
+
+// Application 组件内部共享的常量与工具函数（私有头，仅本组件的 .cpp 使用）。
+//
+// 本组件的实现按功能拆成多个协作文件，它们共用这一份内部工具集。
+//
+// ⚠️ 为让多个翻译单元都能使用，原匿名命名空间改为**具名**命名空间 `appdetail`，
+//    并把其中每个函数与常量标为 `inline` —— 单一定义、单一副本，不会产生代码重复。
+//    各实现文件在包含本头之后用 `using namespace appdetail;` 引入这些工具，
+//    因此函数体里原有的非限定调用一行都不用改。
+
+#include <windows.h>
+#include <objidl.h>
+#include <gdiplus.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <cstdint>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include <commdlg.h>
+#include <psapi.h>
+#include <shellapi.h>
+#include <windowsx.h>
+
+#include "Application.hpp"
+#include "DataLoader.hpp"
+#include "ResourceIds.h"
+#include "Utf8Util.hpp"
+
+namespace jdi
+{
+
+	namespace appdetail
+	{
+	/**
+	 * @brief Application 内部工具集（常量与自由函数）。
+	 *
+	 * 全部符号都是 `inline` ⇒ 多个翻译单元共用同一个定义：既不重复符号，也不产生多份代码。
+	 * 不要把它们移回匿名命名空间（那样每个 .cpp 都会各自复制一份）。
+	 */
+		inline const wchar_t* kWindowClassName = L"JustDataInspectorMainWindow";	/**< 窗口类名。 */
+		inline const wchar_t* kWindowTitle = L"Just DataInspector";				/**< 窗口标题中的应用名称部分。 */
+		/**
+		 * @brief 应用名称与内存占用之间的分隔竖线。
+		 *
+		 * 与信号分组标题里「组X ｜ 组名」的分隔方式一致：竖线两侧各留出空隙
+		 *（`kGroupSeparatorGap` 是那个分隔线的左右间距，这里用两个空格达到同等观感）。
+		 */
+		inline const wchar_t* kTitleSeparator = L"  |  ";
+		/** @brief 内存占用的显示前缀（与具体数值之间保留一个空格）。 */
+		inline const wchar_t* kRamTitlePrefix = L"RAM ： ";
+		inline const float kSplitterWidth = 4.0f;									/**< 分隔条宽度（逻辑像素）。 */
+		inline const float kMinPanelWidth = 260.0f;								/**< 面板最小宽度（逻辑像素）。 */
+		inline const float kMaxPanelWidth = 400.0f;								/**< 面板最大宽度（逻辑像素）。 */
+		inline const int kMinClientWidth = 860;									/**< 窗口最小客户区宽度。 */
+		inline const int kMinClientHeight = 540;									/**< 窗口最小客户区高度。 */
+		inline const UINT kMessageRemoveGroup = WM_APP + 1;							/**< 面板请求移除分组的自定义消息。 */
+		inline const UINT kMessageRemoveSignal = WM_APP + 2;						/**< 面板请求移除单个信号的自定义消息。 */
+		inline const UINT_PTR kHintTimerId = 1;									/**< 提示浮层淡出用的定时器 ID。 */
+		inline const UINT kHintTimerPeriodMs = 33;									/**< 提示浮层淡出的重绘间隔（约 30fps）。 */
+		inline const UINT_PTR kRamTimerId = 2;									/**< 标题栏内存占用刷新的定时器 ID。 */
+		inline const UINT kRamTimerPeriodMs = 1000;								/**< 标题栏内存占用的刷新间隔（1 秒）。 */
+		/**
+		 * @brief 信号列表「滚动到目标信号」动画的定时器 ID。
+		 *
+		 * 用户 2026-10-15 要求：联动时列表要**平滑滚动**（不是立刻翻到目标位置），
+		 * 且"整个动画过程不要太久"。动画本身由 `SignalPanel::AdvanceScrollAnimation()`
+		 * 按经过时间推进，这里只负责按帧驱动它（约 60fps）。
+		 */
+		inline const UINT_PTR kScrollTimerId = 3;
+		inline const UINT kScrollTimerPeriodMs = 16;
+
+		/**
+		 * @brief 查询本进程当前占用的内存（**私有工作集**，与任务管理器"内存"列同口径）。
+		 *
+		 * ⚠️ 原先取的是 `PROCESS_MEMORY_COUNTERS::WorkingSetSize`（**总工作集**），它把映射进来的
+		 * DLL / 共享页面以及已经释放但尚未被系统回收的驻留页面都算进去 —— 加载一个大文件再
+		 * 关闭分组后，实际占用的私有内存已经回到几 MB，标题栏却还显示几十 MB，
+		 * 与任务管理器（资源管理器里看到的"内存"）对不上（用户报告）。
+		 * `PROCESS_MEMORY_COUNTERS_EX2::PrivateWorkingSetSize` 正是任务管理器"内存"列的口径：
+		 * 只统计**属于本进程的私有、且驻留在物理内存中**的页面。
+		 *
+		 * 结构体在这里就地声明（MinGW 的 psapi.h 未提供 `PROCESS_MEMORY_COUNTERS_EX2`），
+		 * 布局与 Win32 文档一致；EX2 查询失败（老系统）时退回 `PrivateUsage`（私有提交），
+		 * 再不行退回 `WorkingSetSize`，保证标题栏永远有值。
+		 *
+		 * @return 内存占用字节数；查询失败返回 0。
+		 */
+		inline unsigned long long ProcessPrivateWorkingSetBytes()
+		{
+			struct MemoryCountersEx2
+			{
+				DWORD cb;
+				DWORD PageFaultCount;
+				SIZE_T PeakWorkingSetSize;
+				SIZE_T WorkingSetSize;
+				SIZE_T QuotaPeakPagedPoolUsage;
+				SIZE_T QuotaPagedPoolUsage;
+				SIZE_T QuotaPeakNonPagedPoolUsage;
+				SIZE_T QuotaNonPagedPoolUsage;
+				SIZE_T PagefileUsage;
+				SIZE_T PeakPagefileUsage;
+				SIZE_T PrivateUsage;
+				SIZE_T PrivateWorkingSetSize;
+				SIZE_T SharedCommitUsage;
+			};
+
+			MemoryCountersEx2 ex2 = {};
+			ex2.cb = sizeof(ex2);
+			if (K32GetProcessMemoryInfo(GetCurrentProcess(),
+			                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&ex2),
+			                            sizeof(ex2)) != FALSE &&
+			    ex2.PrivateWorkingSetSize > 0)
+			{
+				return static_cast<unsigned long long>(ex2.PrivateWorkingSetSize);
+			}
+
+			PROCESS_MEMORY_COUNTERS_EX counters = {};
+			counters.cb = sizeof(counters);
+			if (K32GetProcessMemoryInfo(GetCurrentProcess(),
+			                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&counters),
+			                            sizeof(counters)) == FALSE)
+			{
+				return 0ull;
+			}
+			if (counters.PrivateUsage > 0)
+			{
+				return static_cast<unsigned long long>(counters.PrivateUsage);
+			}
+			return static_cast<unsigned long long>(counters.WorkingSetSize);
+		}
+
+		/**
+		 * @brief 只失效绘图区所在的矩形。
+		 *
+		 * 配合 WM_PAINT 中对更新区域的判断，可以走“只重绘、只回送绘图区”的快路径；
+		 * 绘图区矩形无效时退化为整窗失效，保证不会漏画。
+		 *
+		 * @param [IN] hwnd 窗口句柄。
+		 * @param [IN] plotRect 绘图区矩形（客户区坐标）。
+		 */
+		inline void InvalidatePlotRect(HWND hwnd, const gd::RectF& plotRect)
+		{
+			RECT invalid = {};
+			invalid.left = static_cast<LONG>(std::floor(plotRect.X));
+			invalid.top = static_cast<LONG>(std::floor(plotRect.Y));
+			invalid.right = static_cast<LONG>(std::ceil(plotRect.X + plotRect.Width));
+			invalid.bottom = static_cast<LONG>(std::ceil(plotRect.Y + plotRect.Height));
+			if (invalid.right > invalid.left && invalid.bottom > invalid.top)
+			{
+				InvalidateRect(hwnd, &invalid, FALSE);
+			}
+			else
+			{
+				InvalidateRect(hwnd, nullptr, FALSE);
+			}
+		}
+
+		/** @brief 标签页右键菜单命令 ID。 */
+		inline const int kMenuTabNew = 1;
+		inline const int kMenuTabClose = 2;
+		inline const int kMenuTabCloseOthers = 3;
+
+		/**
+		 * @brief 从应用资源中按指定尺寸加载图标。
+		 * @param [IN] cx 期望宽度（像素）。
+		 * @param [IN] cy 期望高度（像素）。
+		 * @return 图标句柄，加载失败返回 nullptr。
+		 */
+		inline HICON LoadAppIcon(int cx, int cy)
+		{
+			HINSTANCE module = GetModuleHandleW(nullptr);
+			// LR_DEFAULTSIZE 之外的显式尺寸请求会挑选 ICO 中最接近的一帧并由系统缩放，
+			// 因此 256/64/48/32/16 的多尺寸资源在任意 DPI 下都能取到合适的一帧。
+			HICON icon = static_cast<HICON>(LoadImageW(module, MAKEINTRESOURCEW(IDI_APP_ICON), IMAGE_ICON,
+			                                           cx, cy, LR_DEFAULTCOLOR));
+			if (icon == nullptr)
+			{
+				icon = static_cast<HICON>(LoadImageW(module, MAKEINTRESOURCEW(IDI_APP_ICON), IMAGE_ICON, 0, 0,
+				                                     LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
+			}
+			return icon;
+		}
+
+		/**
+		 * @brief 后台加载任务的共享状态。
+		 *
+		 * `done` 是唯一的同步点：工作线程写完其它字段后以 release 语义置位，
+		 * 主线程以 acquire 语义读取，因此无需额外锁。
+		 */
+		struct AsyncLoadState
+		{
+			std::atomic<bool> done{false};		/**< 工作线程是否已结束。 */
+			std::atomic<bool> cancelled{false};	/**< 是否请求取消。 */
+			std::atomic<float> progress{0.0f};	/**< 0-1 进度。 */
+			std::atomic<unsigned long long> bytesRead{0}; /**< 已读取字节数（解析阶段）。 */
+			std::atomic<unsigned long long> totalBytes{0}; /**< 文件总字节数（0 表示未知）。 */
+			bool ok = false;					/**< 加载是否成功。 */
+			std::wstring error;					/**< 失败原因。 */
+			SignalGroup group;						/**< 构建结果。 */
+		};
+
+		/**
+		 * @brief 工作线程主体：按扩展名选择加载器读入文件并构建信号分组（不接触 DataSet）。
+		 * @param [IN,OUT] state 共享状态。
+		 * @param [IN] path 文件路径。
+		 * @param [IN] paletteBase 调色板起始序号。
+		 */
+		inline void RunAsyncLoad(AsyncLoadState* state, std::wstring path, std::size_t paletteBase)
+		{
+			// 解析阶段占总进度的 0-75%，列重组与统计占 75-100%。
+			LoadProgress parseProgress = [state](const LoadProgressInfo& info)
+			{
+				state->progress.store(static_cast<float>(info.ratio * 0.75), std::memory_order_relaxed);
+				if (info.hasBytes)
+				{
+					state->bytesRead.store(info.bytesRead, std::memory_order_relaxed);
+					state->totalBytes.store(info.totalBytes, std::memory_order_relaxed);
+				}
+				return !state->cancelled.load(std::memory_order_relaxed);
+			};
+
+			LoadedSource source;
+			std::wstring error;
+			if (!LoadSignalSource(path, source, error, parseProgress))
+			{
+				state->error = error;
+				state->done.store(true, std::memory_order_release);
+				return;
+			}
+
+			LoadProgress buildProgress = [state](const LoadProgressInfo& info)
+			{
+				state->progress.store(static_cast<float>(0.75 + info.ratio * 0.25),
+				                      std::memory_order_relaxed);
+				return !state->cancelled.load(std::memory_order_relaxed);
+			};
+
+			SignalGroup group;
+			if (!BuildSignalGroup(std::move(source), paletteBase, group, error, buildProgress))
+			{
+				state->error = error;
+				state->done.store(true, std::memory_order_release);
+				return;
+			}
+
+			state->group = std::move(group);
+			state->ok = true;
+			state->progress.store(1.0f, std::memory_order_relaxed);
+			state->done.store(true, std::memory_order_release);
+		}
+
+		/**
+		 * @brief 开启进程级 DPI 感知（优先 Per-Monitor V2）。
+		 */
+		inline void EnableDpiAwareness()
+		{
+			HMODULE user32 = GetModuleHandleW(L"user32.dll");
+			if (user32 != nullptr)
+			{
+				typedef BOOL(WINAPI * SetProcessDpiAwarenessContextFn)(HANDLE);
+				SetProcessDpiAwarenessContextFn setContext =
+				    reinterpret_cast<SetProcessDpiAwarenessContextFn>(
+				        reinterpret_cast<void*>(GetProcAddress(user32, "SetProcessDpiAwarenessContext")));
+				if (setContext != nullptr && setContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) != FALSE)
+				{
+					return;
+				}
+			}
+			SetProcessDPIAware();
+		}
+
+		/**
+		 * @brief 查询屏幕 DPI。
+		 * @return DPI 数值，失败时返回 96。
+		 */
+		inline UINT QuerySystemDpi()
+		{
+			HDC hdc = GetDC(nullptr);
+			if (hdc == nullptr)
+			{
+				return 96u;
+			}
+			const int dpi = GetDeviceCaps(hdc, LOGPIXELSX);
+			ReleaseDC(nullptr, hdc);
+			return (dpi > 0) ? static_cast<UINT>(dpi) : 96u;
+		}
+
+		/**
+		 * @brief 依据 DPI 缩放逻辑像素。
+		 * @param [IN] value 逻辑像素值。
+		 * @param [IN] scale 缩放比例。
+		 * @return 物理像素值。
+		 */
+		inline float ScaleOf(float value, float scale)
+		{
+			return value * scale;
+		}
+	} // namespace appdetail
+
+	using namespace appdetail;
+
+} // namespace jdi
+
+#endif // __APPLICATION_INTERNAL_HPP__
+
diff --git a/Components/Application/Src/ApplicationLoading.cpp b/Components/Application/Src/ApplicationLoading.cpp
new file mode 100644
index 0000000..bc39071
--- /dev/null
+++ b/Components/Application/Src/ApplicationLoading.cpp
@@ -0,0 +1,270 @@
+// Application 实现分片 —— 本文件只包含 Application 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 ApplicationInternal.hpp（命名空间 `appdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "ApplicationInternal.hpp"
+
+namespace jdi
+{
+
+	bool Application::LoadFile(const std::wstring& path)
+	{
+		if (path.empty())
+		{
+			return false;
+		}
+
+		// 大文件在工作线程解析并构建，主线程播放加载过渡动画，界面不再整块卡住。
+		SignalGroup group;
+		std::wstring error;
+		if (!LoadFileAsync(path, group, error))
+		{
+			if (!error.empty())
+			{
+				SetStatusMessage(L"解析失败：" + error, true);
+			}
+			InvalidateRect(m_hwnd, nullptr, FALSE);
+			return false;
+		}
+
+		int groupIndex = -1;
+		// 插入新分组会移动 SignalGroup/SignalData 的存储位置，必须先暂停后台派生曲线计算，
+		// 否则后台线程可能正在读取即将被移动的采样数据。
+		m_plot.PauseDerivedAsync();
+		// 此处只做一次指针/缓冲移动，不拷贝任何采样数据，因此不会造成可见卡顿。
+		if (!m_dataSet.AddGroup(std::move(group), groupIndex))
+		{
+			SetStatusMessage(L"解析失败：数据为空。", true);
+			InvalidateRect(m_hwnd, nullptr, FALSE);
+			return false;
+		}
+
+		// 新分组的信号在全部标签页中默认均为未勾选状态，由用户自行决定查看内容。
+		SyncTabsToDataSet();
+		UpdateWindowTitle();
+
+		const SignalGroup* loaded = m_dataSet.GroupAt(groupIndex);
+		if (loaded != nullptr)
+		{
+			// 行数取各时间轴的**最大值**（多时间轴文件的各轴长度可能不同）。
+			std::size_t rowCount = 0;
+			bool anyNonMonotonic = false;
+			std::wstring timeNames;
+			for (const TimeAxis& axis : loaded->axes)
+			{
+				rowCount = std::max(rowCount, axis.Count());
+				anyNonMonotonic = anyNonMonotonic || !axis.monotonic;
+				if (!timeNames.empty())
+				{
+					timeNames += L"、";
+				}
+				timeNames += axis.name;
+			}
+			std::wstring message = L"已加载 组" + std::to_wstring(groupIndex + 1) + L"｜" + loaded->name +
+			                       L"（" + FormatCount(static_cast<unsigned long long>(rowCount)) +
+			                       L" 行采样，" + std::to_wstring(loaded->signals.size()) +
+				                       L" 条信号，" + std::to_wstring(loaded->axes.size()) + L" 条时间轴：" +
+				                       timeNames + L"）";
+			if (anyNonMonotonic)
+			{
+				message += L" 提示：时间列非单调递增，光标取值使用最近邻策略。";
+			}
+			SetStatusMessage(message, false);
+		}
+		return true;
+	}
+
+	bool Application::LoadFileAsync(const std::wstring& path, SignalGroup& group, std::wstring& error)
+	{
+		error.clear();
+
+		AsyncLoadState state;
+		const std::size_t paletteBase = m_dataSet.SignalCount();
+
+		m_loading = true;
+		m_loadingProgress = 0.0f;
+		m_loadingBytesRead = 0;
+		m_loadingTotalBytes = 0;
+		const std::size_t slashPos = path.find_last_of(L"\\/");
+		m_loadingText = (slashPos == std::wstring::npos) ? path : path.substr(slashPos + 1);
+
+		std::thread worker(RunAsyncLoad, &state, path, paletteBase);
+
+		// 主线程循环：抽送消息 + 刷新动画，直到后台完成或用户取消。
+		while (!state.done.load(std::memory_order_acquire))
+		{
+			MSG message = {};
+			while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE))
+			{
+				if (message.message == WM_QUIT)
+				{
+					// 退出请求：让后台停下并重新投递 WM_QUIT，由主循环正常收尾。
+					state.cancelled.store(true, std::memory_order_relaxed);
+					PostQuitMessage(static_cast<int>(message.wParam));
+					break;
+				}
+				// 加载期间屏蔽鼠标与其它按键，避免重入加载或误改数据；
+				// 保留 Esc 作为取消入口。
+				if (message.message >= WM_MOUSEFIRST && message.message <= WM_MOUSELAST)
+				{
+					continue;
+				}
+				if (message.message == WM_KEYDOWN && message.wParam == VK_ESCAPE)
+				{
+					state.cancelled.store(true, std::memory_order_relaxed);
+					continue;
+				}
+				if (message.message >= WM_KEYFIRST && message.message <= WM_KEYLAST)
+				{
+					continue;
+				}
+				TranslateMessage(&message);
+				DispatchMessageW(&message);
+			}
+
+			m_loadingProgress = state.progress.load(std::memory_order_relaxed);
+			m_loadingBytesRead = state.bytesRead.load(std::memory_order_relaxed);
+			m_loadingTotalBytes = state.totalBytes.load(std::memory_order_relaxed);
+			InvalidateRect(m_hwnd, nullptr, FALSE);
+			UpdateWindow(m_hwnd);
+			Sleep(15);
+		}
+
+		m_loadingProgress = 1.0f;
+		m_loadingBytesRead = m_loadingTotalBytes;
+		worker.join();
+		m_loading = false;
+
+		if (state.cancelled.load(std::memory_order_relaxed))
+		{
+			// 用户主动取消：不弹错误框（与 Esc 取消缩放选区的静默语义一致）。
+			InvalidateRect(m_hwnd, nullptr, TRUE);
+			return false;
+		}
+		if (!state.ok)
+		{
+			error = state.error;
+			return false;
+		}
+
+		group = std::move(state.group);
+		return true;
+	}
+
+	void Application::PaintLoadingOverlay(gd::Graphics& g, int width, int height)
+	{
+		if (!m_loading)
+		{
+			return;
+		}
+
+		// 半透明遮罩压暗整个界面，形成明确的"正在加载"状态。
+		UiFillRect(g, gd::RectF(0.0f, 0.0f, static_cast<float>(width), static_cast<float>(height)),
+		           0x66000000u);
+
+		const float cardWidth = std::min(420.0f * m_scale, static_cast<float>(width) - 40.0f * m_scale);
+		const float cardHeight = 132.0f * m_scale;
+		const gd::RectF card((static_cast<float>(width) - cardWidth) * 0.5f,
+		                     (static_cast<float>(height) - cardHeight) * 0.5f, cardWidth, cardHeight);
+
+		UiFillRoundRect(g, card, 8.0f * m_scale, m_theme.cardBg);
+		UiDrawRoundRect(g, card, 8.0f * m_scale, m_theme.borderStrong, 1.0f);
+
+		// 旋转弧线：用时间驱动的起始角度形成持续的加载动画。
+		const float spinnerRadius = 11.0f * m_scale;
+		const gd::RectF spinner(card.X + 26.0f * m_scale, card.Y + 30.0f * m_scale - spinnerRadius,
+		                        spinnerRadius * 2.0f, spinnerRadius * 2.0f);
+		m_loadingSpin += 12.0f;
+		if (m_loadingSpin >= 360.0f)
+		{
+			m_loadingSpin -= 360.0f;
+		}
+		gd::Pen trackPen(ToGdiColor(m_theme.border), 3.0f * m_scale);
+		gd::Pen spinPen(ToGdiColor(m_theme.accent), 3.0f * m_scale);
+		g.DrawArc(&trackPen, spinner, 0.0f, 359.0f);
+		g.DrawArc(&spinPen, spinner, m_loadingSpin, 110.0f);
+
+		const float textLeft = card.X + 52.0f * m_scale;
+		const float textWidth = cardWidth - 52.0f * m_scale - 20.0f * m_scale;
+
+		UiText(g, L"正在加载数据…", m_fonts.uiBold,
+		       gd::RectF(textLeft, card.Y + 18.0f * m_scale, textWidth, 22.0f * m_scale), m_theme.text,
+		       TextAlign::LEFT);
+
+		// 超长文件名用省略号截断，避免撑破卡片。
+		const std::wstring nameText =
+		    UiEllipsize(m_loadingText, m_fonts.uiSmall, textWidth);
+		UiText(g, nameText, m_fonts.uiSmall,
+		       gd::RectF(textLeft, card.Y + 42.0f * m_scale, textWidth, 20.0f * m_scale),
+		       m_theme.textMuted, TextAlign::LEFT);
+
+		// 进度条（复用样式区滑块以外的简单圆角矩形，填充宽度严格按比例）。
+		const gd::RectF track(card.X + 26.0f * m_scale, card.Y + 76.0f * m_scale,
+		                      cardWidth - 52.0f * m_scale, 8.0f * m_scale);
+		UiFillRoundRect(g, track, track.Height * 0.5f, m_theme.pressed);
+		float ratio = m_loadingProgress;
+		ratio = std::max(0.0f, std::min(ratio, 1.0f));
+		const float fillWidth = track.Width * ratio;
+		if (fillWidth > 1.0f)
+		{
+			UiFillRoundRect(g, gd::RectF(track.X, track.Y, fillWidth, track.Height), track.Height * 0.5f,
+			                m_theme.accent);
+		}
+
+		wchar_t buffer[64];
+		swprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), L"%.2f%%", ratio * 100.0);
+
+		// 已读取 / 总大小：两者都只显示数字与自适应单位（GB / MB / KB），均保留两位小数；
+		// 百分比同样是两位小数。总大小未知（如列重组阶段）时只显示百分比。
+		{
+			std::wstring statusText = buffer;
+			if (m_loadingTotalBytes > 0)
+			{
+				statusText = FormatByteSize(m_loadingBytesRead) + L" / " +
+				             FormatByteSize(m_loadingTotalBytes) + L"  " + buffer;
+			}
+			UiText(g, statusText, m_fonts.monoSmall,
+			       gd::RectF(track.X, card.Y + 92.0f * m_scale, track.Width, 20.0f * m_scale),
+			       m_theme.text, TextAlign::LEFT);
+		}
+
+		UiText(g, L"按 Esc 取消", m_fonts.uiSmall,
+		       gd::RectF(track.X, card.Y + 92.0f * m_scale, track.Width, 20.0f * m_scale),
+		       m_theme.textMuted, TextAlign::RIGHT);
+	}
+
+	void Application::LoadCommandLineFiles()
+	{
+		int argumentCount = 0;
+		LPWSTR* arguments = CommandLineToArgvW(GetCommandLineW(), &argumentCount);
+		if (arguments == nullptr)
+		{
+			return;
+		}
+
+		int loaded = 0;
+		for (int index = 1; index < argumentCount; ++index)
+		{
+			const std::wstring argument = arguments[index];
+			if (argument.empty() || argument[0] == L'-' || argument[0] == L'/')
+			{
+				continue;
+			}
+			if (LoadFile(argument))
+			{
+				++loaded;
+			}
+		}
+		LocalFree(arguments);
+
+		if (loaded > 0)
+		{
+			SetStatusMessage(L"已加载 " + std::to_wstring(loaded) +
+			                     L" 个文件，请在左侧勾选需要查看的信号。",
+			                 false);
+		}
+	}
+
+
+} // namespace jdi
+
diff --git a/Components/PlotView/Inc/PlotView.hpp b/Components/PlotView/Inc/PlotView.hpp
index bf57186..295b0ed 100644
--- a/Components/PlotView/Inc/PlotView.hpp
+++ b/Components/PlotView/Inc/PlotView.hpp
@@ -1019,7 +1019,7 @@ namespace jdi
 		 * @param [IN] laneIndex 网格下标。
 		 * @return 跨越多个分组返回 true。
 		 */
-		bool LaneSpansMultipleFiles(int laneIndex) const;
+		bool LaneSpansMultipleGroups(int laneIndex) const;
 
 		/**
 		 * @brief 获取当前选中信号（跨标签页共享，切换视图后选中项保持一致）。
@@ -2413,7 +2413,7 @@ namespace jdi
 			float areaW = 0.0f;				/**< 绘图区尺寸。 */
 			float areaH = 0.0f;
 			float scale = 1.0f;				/**< DPI 缩放。 */
-			int haloFile = -1;				/**< 已绘入缓存的拖拽光晕信号（无则 -1）。 */
+			int haloGroup = -1;				/**< 已绘入缓存的拖拽光晕信号（无则 -1）。 */
 			int haloSignal = -1;
 			std::uint64_t contentHash = 0;	/**< 信号集合/显示样式/网格幅值等内容指纹。 */
 		};
diff --git a/Components/PlotView/Src/PlotView.cpp b/Components/PlotView/Src/PlotView.cpp
index 3a8e1e6..64b836b 100644
--- a/Components/PlotView/Src/PlotView.cpp
+++ b/Components/PlotView/Src/PlotView.cpp
@@ -1,892 +1,19 @@
-#include "PlotView.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <cstring>
-#include <limits>
-
-#include "UiControls.hpp"
-#include "Utf8Util.hpp"
+// PlotView 实现分片 —— 本文件只包含 PlotView 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与工具函数在 PlotViewInternal.hpp（命名空间 `pvdetail`，全部 inline）。
+// 四个分片的职责划分（按功能）：
+//   core        视图核心：构造/析构、上下文绑定、布局、坐标映射、视界与平移、网格结构与归属、
+//               选区/网格划分、拖动取消
+//   paint       渲染与像素缓存：全部绘制（Paint*/Render*）、场景缓存、装饰缓存、每网格图层、
+//               宽基底与滚动补条、并行图层重建
+//   interaction 交互与编辑：命中测试、鼠标与键盘处理、光标形状、内联输入框、浮动面板层序与命中
+//   features    视图特性与派生数据：光标状态与读数、提示浮层、缩放模式、自适应、光标吸附、
+//               单点信号、派生曲线线程池、边沿统计、实验性功能（均值滤波 / 弱峰调整）参数
+#include "PlotViewInternal.hpp"
 
 namespace jdi
 {
 
-	namespace
-	{
-		const int kTimeTickTarget = 10;				/**< 时间轴期望刻度数。 */
-		const int kYTickTarget = 6;					/**< 幅值轴期望刻度数（网格较高时）。 */
-		const int kYTickTargetMin = 3;				/**< 幅值轴最少刻度数（网格很矮时也要保证可读数）。 */
-		const int kYTickTargetMax = 8;				/**< 幅值轴最多刻度数。 */
-		const float kYTickSpacing = 28.0f;			/**< 幅值刻度之间的理想间距（逻辑像素）。 */
-		const float kYLabelMinGap = 15.0f;			/**< 幅值标签的最小行距（逻辑像素）。 */
-		const int kMinorDivisions = 5;				/**< 相邻主刻度之间的等分数（用于估读）。 */
-		const unsigned int kMinorLineAlpha = 0x9Au;	/**< 辅助等分线的透明度（越高越清晰）。 */
-		const float kScrollBarThickness = 9.0f;		/**< 滚动条宽度（逻辑像素）。 */
-		const float kLanePadding = 8.0f;			/**< 网格内边距。 */
-		const size_t kMaxPolylinePoints = 20000;	/**< 单条折线最大顶点数（上限保护）。 */
-		const size_t kPolylinePointsPerPixel = 2;	/**< 每个像素列允许的折线顶点数（上/下包络两顶点）。 */
-		const size_t kMinPolylinePoints = 512;		/**< 折线最少顶点数（窗口很窄时仍保留细节）。 */
-		/**
-		 * @brief 图层**纵向滚动**的量化阈值（位图像素）。
-		 *
-		 * 幅值平移不足该值时**不滚动**图层，交给贴图时的纵向偏移（`srcY`）处理；
-		 * 超过才滚动一次并补画新暴露的一整条。这样画布映射在拖动过程中保持稳定 →
-		 * 折线缓存（键含幅值映射）能命中，避免"每帧滚 1 行 → 每帧重算折线"的性能陷阱。
-		 */
-		const int kLayerRollQuantum = 16;
-		const float kEnvelopeMinPixelSpan = 0.5f;	/**< 包络纵向跨度小于该像素值时合并为单个顶点。 */
-		const float kCursorHandleReserve = 9.0f;	/**< 光标顶部三角把手占用的高度（数据点贴边时需避让）。 */
-		const float kMarkerEdgeInset = 7.0f;		/**< 数据点越界贴边时距网格可见边界的间距。 */
-		const float kMarkerInsideMargin = 2.0f;	/**< 数据点在视界内时允许贴到边界的最小余量。 */
-		const float kMarkerTriangleArm = 5.0f;		/**< 越界方向三角"半宽/半高"（垂直于朝向的半边长）。 */
-		/** 越界方向三角沿朝向的深度（与光标把手同比例）。 */
-		const float kMarkerTriangleDepth = kMarkerTriangleArm * 1.4f;
-		/**
-		 * 越界方向三角与数值/时间标注之间的间隙（逻辑像素）。
-		 *
-		 * 三角与胶囊之间**必须留出这段空白**：贴在一起时三角看起来像胶囊上多出来的
-		 * 一个尖角（用户报告的"三角形与数值显示部分没有间隔"）。
-		 */
-		const float kMarkerTriangleGap = 4.0f;
-		const size_t kMaxScatterPoints = 2500;		/**< 单条散点最大绘制点数。 */
-		const size_t kPolylineCacheLimit = 64;		/**< 折线顶点缓存条目上限。 */
-		const float kMinScatterRadius = 1.6f;		/**< 散点最小半径（逻辑像素）。 */
-		const float kMaxScatterRadius = 12.0f;	/**< 散点最大半径（逻辑像素）。 */
-		const float kScatterRadiusScale = 1.5f;	/**< 散点半径相对线宽的增长系数。 */
-		const double kMinTimeSpan = 1.0e-12;		/**< 允许的最小时间跨度。 */
-		const float kPlotSidePadding = 8.0f;		/**< 绘图区左右留白（逻辑像素）。 */
-		const float kLaneDividerWidth = 2.0f;		/**< 网格之间分界线的宽度。 */
-		const float kSignalHitTolerance = 6.0f;	/**< 信号曲线命中容差（逻辑像素）。 */
-		/**
-		 * @brief 两个矩形的交集（空交集返回宽高为 0 的矩形）。
-		 *
-		 * 用于把 GDI 绘制（不受 GDI+ 裁剪约束）限制在"本次真正要重画的区域"内，
-		 * 见 `PaintLane` 里的 `laneClip`。
-		 */
-		gd::RectF IntersectRect(const gd::RectF& first, const gd::RectF& second)
-		{
-			const float left = std::max(first.X, second.X);
-			const float top = std::max(first.Y, second.Y);
-			const float right = std::min(first.X + first.Width, second.X + second.Width);
-			const float bottom = std::min(first.Y + first.Height, second.Y + second.Height);
-			if (right <= left || bottom <= top)
-			{
-				return gd::RectF(left, top, 0.0f, 0.0f);
-			}
-			return gd::RectF(left, top, right - left, bottom - top);
-		}
-
-		/**
-		 * @brief 绘制「还原/重置」图标（逆时针回环箭头）。
-		 *
-		 * 与 `PopupMenu` 里「系数 / 偏移」二级面板标题栏右侧的还原图标**同一套笔画**
-		 *（用户要求：“可以直接挪用信号『调整』功能中『系数/偏移』二级菜单内的复位控件”），
-		 * 因此弱峰调整面板的复位控件与它视觉完全一致。不依赖字体或资源，任意 DPI 都清晰。
-		 *
-		 * @param [IN,OUT] g 绘图上下文。
-		 * @param [IN] rect 图标外接矩形（正方形）。
-		 * @param [IN] color 笔画颜色（0xAARRGGBB）。
-		 * @param [IN] scale DPI 缩放比例。
-		 */
-		void PaintPanelResetIcon(gd::Graphics& g, const gd::RectF& rect, std::uint32_t color,
-		                         float scale)
-		{
-			const float inset = 2.5f * scale;
-			gd::RectF box(rect.X + inset, rect.Y + inset, rect.Width - inset * 2.0f,
-			              rect.Height - inset * 2.0f);
-			if (box.Width <= 1.0f || box.Height <= 1.0f)
-			{
-				return;
-			}
-			gd::Pen pen(gd::Color((color >> 24) & 0xFFu, (color >> 16) & 0xFFu, (color >> 8) & 0xFFu,
-			                      color & 0xFFu),
-			            std::max(1.0f, 1.5f * scale));
-			pen.SetStartCap(gd::LineCapRound);
-			pen.SetEndCap(gd::LineCapRound);
-			// 缺口留在右上角（从 300° 到 20° 处断开），与常见的"重置/刷新"图标一致。
-			g.DrawArc(&pen, box.X, box.Y, box.Width, box.Height, 300.0f, 300.0f);
-
-			// 箭头：位于缺口末端（约 300° 方向），指向前进方向。
-			const float cx = box.X + box.Width * 0.5f;
-			const float cy = box.Y + box.Height * 0.5f;
-			const float radius = box.Width * 0.5f;
-			const float angle = 300.0f * 3.14159265f / 180.0f;
-			const float tipX = cx + std::cos(angle) * radius;
-			const float tipY = cy + std::sin(angle) * radius;
-			const float size = std::max(2.5f, 3.2f * scale);
-			gd::PointF arrow[3];
-			arrow[0] = gd::PointF(tipX, tipY);
-			arrow[1] = gd::PointF(tipX - size, tipY - size * 0.25f);
-			arrow[2] = gd::PointF(tipX - size * 0.25f, tipY - size);
-			gd::SolidBrush brush(gd::Color((color >> 24) & 0xFFu, (color >> 16) & 0xFFu,
-			                               (color >> 8) & 0xFFu, color & 0xFFu));
-			g.FillPolygon(&brush, arrow, 3);
-		}
-
-		/**
-		 * @brief 光标吸附的**判定系数**：一屏内的数据点少于 `网格小格数 × 该系数` 时才开启吸附。
-		 *
-		 * 用户 2026-10-15 明确定义：网格底衬一横排有 N 个小格（见 `GridMinorCellCount`），
-		 * **当且仅当**某信号在当前视界内的数据点个数 `< N × 4` 时为它开启光标吸附。
-		 * 该判据随视界实时重算 ⇒ 疏密变化的信号在稀疏区自动吸附、稠密区自动自由移动。
-		 */
-		const int kSnapVisibleCellsPerPoint = 4;
-
-		/**
-		 * @brief 吸附半径（以**网格小格**为单位）：一个数据点只用其**一个小格宽**内的移动来吸。
-		 *
-		 * 吸附半径 = 一个网格小格的宽度（与判定用同一套网格定义），且**不超过半个采样间距**
-		 * ——后者保证点很稀疏时（例如一屏只有一两个点）光标在点与点之间仍可自由移动，
-		 * 而不是被“死死吸住”（用户明确要求：吸附只是提示性响应）。
-		 */
-		const double kSnapRadiusCells = 1.0;
-
-		/**
-		 * @brief 一般信号查找“离光标最近的有效采样点”时向两侧探测的最大步数。
-		 *
-		 * 采样值里的 NaN 只出现在缺少数据的区段（例如多时间轴 CSV 的较短轴的尾部），
-		 * 因此从最近下标向外少量探测即可找到有效点；探测失败就不吸附（宁可自由移动）。
-		 */
-		const int kSnapSampleProbeSteps = 64;
-
-		/**
-		 * @brief 判定“可见数据点是否足够少”时允许扫描的最大样本数（相对阈值的倍数）。
-		 *
-		 * 判定只需知道“有效点是否少于阈值”，因此扫到阈值个有效点就早退；
-		 * 但连续 NaN 不会被计入，因此再给一个**有界**的扫描窗口防止极端情况下的长循环。
-		 */
-		const std::size_t kSnapScanWindowFactor = 64;
-
-		/**
-		 * @brief 「所有可见数据点都是单值信号、且时刻完全相同」时，时间轴**一个大格**对应的秒数。
-		 *
-		 * 用户 2026-10-15 明确要求：这种最极端情况下时间轴以该时刻居中、并缩放到
-		 * **一大格 = 1s** 的级别。视界跨度取 `kTimeTickTarget` 个大格 ⇒
-		 * 跨度 = 10s、`NiceStep(10, kTimeTickTarget)` = **1.0 秒**，正好是"一大格 1s"。
-		 */
-		const double kSinglePointClusterSecondsPerCell = 1.0;
-
-		/**
-		 * @brief 让边界处的单值散点"完整显示"时，在半径之外额外多留的像素（设备像素）。
-		 *
-		 * 只让出**正好等于半径**的量会让圆点边缘贴着网格边框（抗锯齿边缘看起来被切了一刀），
-		 * 因此再多留 1 个像素。
-		 */
-		const float kSinglePointBoundaryPadPixels = 1.0f;
-
-		/**
-		 * @brief 判定"多个单值数据点处于同一时刻"的相对误差。
-		 *
-		 * 同一列里读出的时刻是完全相同的 double；但不同来源（例如 MF4 的整数刻度 ×
-		 * 通道组的标定系数）可能差 1ulp，因此用相对误差而不是精确相等。
-		 */
-		const double kSinglePointSameTimeEpsilon = 1.0e-9;
-
-		const float kLaneLabelPad = 6.0f;		/**< 网格内侧标尺带的内边距。 */
-		const float kLegendHeight = 19.0f;		/**< 图例条目高度（逻辑像素）。 */
-		const float kLegendPad = 5.0f;			/**< 图例相对网格左上角的内缩。 */
-		const float kLegendSwatchSize = 8.0f;	/**< 图例色块尺寸。 */
-		const float kLegendItemGap = 14.0f;		/**< 图例条目之间的间距。 */
-		const float kLegendMaxTextWidth = 200.0f;	/**< 图例条目的文本宽度上限（超出则省略）。 */
-		const float kLaneBadgeWidth = 30.0f;		/**< 网格编号徽标宽度（与信号面板保持一致）。 */
-		const float kLaneBadgeHeight = 17.0f;		/**< 网格编号徽标高度。 */
-		const float kLaneBadgeGap = 8.0f;		/**< 编号徽标与图例条目之间的间距。 */
-		const float kEdgePanelWidth = 230.0f;		/**< 边沿统计浮动面板宽度。 */
-		const float kEdgePanelTitleHeight = 26.0f;	/**< 面板标题栏高度。 */
-		const float kEdgePanelRowHeight = 18.0f;	/**< 面板内单行文本高度。 */
-		const float kEdgePanelPad = 7.0f;		/**< 面板内边距。 */
-		const float kEdgePanelNameMaxWidth = 150.0f;	/**< 面板内信号名的宽度上限（超过则省略；避免超长信号名把面板顶得很长）。 */
-		const float kEdgePanelStatColumnGap = 14.0f;	/**< 「上升沿 / 下降沿」两列之间的间距（保证多信号的文字垂直对齐）。 */
-		const float kEdgePanelEditFieldWidth = 64.0f;	/**< 数值框的最小宽度。 */
-		const float kEdgePanelButtonHeight = 30.0f;	/**< 均值滤波面板底部按钮行高度。 */
-		const float kEdgePanelMeanRowHeight = 22.0f;	/**< 逐条目面板中每条信号的名称行高度。 */
-		const float kEdgePanelMeanEditHeight = 24.0f;	/**< 逐条目面板中每条信号的参数行高度。 */
-		const float kEdgePanelMeanRowGap = 2.0f;		/**< 名称行与参数行之间的间距。 */
-		const float kEdgePanelMeanCheckSize = 15.0f;	/**< 逐条目面板中条目复选框尺寸。 */
-		const float kWeakPeakSliderRowHeight = 26.0f;	/**< 弱峰调整面板中每个滑块行的高度。 */
-		const float kWeakPeakTrackHeight = 6.0f;		/**< 弱峰调整滑块的轨道高度。 */
-		const float kWeakPeakTrackMinWidth = 120.0f;	/**< 弱峰调整滑块轨道的最小宽度。 */
-		/**
-		 * @brief 「弱峰调整」滑块行右侧**复位控件**的边长（逻辑像素）。
-		 *
-		 * 每行滑块都有一个复位按钮（与「系数/偏移」二级面板里的「还原」图标同一套绘制），
-		 * 点击把该行的参数恢复为默认值（幅度 0 / 迭代次数 1 且上限回到初始上限）。
-		 */
-		const float kWeakPeakResetButtonSize = 16.0f;
-		/** 复位控件与其左侧数值列之间的间距（逻辑像素）。 */
-		const float kWeakPeakResetGap = 4.0f;
-		const int kWeakPeakIterationsMin = 1;				/**< 迭代次数 N 的下限。 */
-		/** 迭代次数滑块「自定义上限」的允许范围（与算法内部的阶数夹取保持一致）。 */
-		const int kWeakPeakIterationsMaxLimit = 1000;
-		/** 迭代次数滑块上限的默认值（与 `Lane::WeakPeakItem::maxIterations` 一致）。 */
-		const int kWeakPeakIterationsDefaultMax = 10;
-		/**
-		 * @brief 「弱峰调整」滑动条的量程（±400%）。
-		 *
-		 * 滑动条同时驱动三组识别规则（见 `ComputeWeakPeakAdjust`）：0–100% 只有第一类规则在动，
-		 * 之后每 100% 加入下一类、而前一类继续走完自己的 0–200%。因此量程是算法内部
-		 * 「单组 ±200%」的两倍。
-		 */
-		const double kWeakPeakSliderScale = 4.0;
-		/** 弱峰调整幅度百分比上限（滑动条右端，用于构建新信号 / 曲线缓存键）。 */
-		const int kWeakPeakAmountMax = 400;
-		/** 弱峰调整幅度百分比下限（滑动条左端，负值 = 削弱）。 */
-		const int kWeakPeakAmountMin = -400;
-		/**
-		 * @brief 派生曲线「区间窗口」缓存的保护带上限（采样点数）。
-		 *
-		 * 窗口只覆盖可见区间 ± 保护带，可见区间内的取值与整条曲线一致（见 `CurveSpanFor`）。
-		 * 上限避免在完全缩小时把保护带放大到整条信号（那就退化成重算整条曲线）。
-		 */
-		const std::size_t kDerivedCurveGuardMax = 65536;
-		/** 派生曲线缓存条目上限（超出时按「最旧优先」淘汰；它只是加速与内存控制手段）。 */
-		const std::size_t kCurveSpanCacheLimit = 32;
-		/** 派生曲线缓存允许占用的总字节数（约 768MB）：超出时按「最旧优先」淘汰。
-		 *  取足够大是为了让「完全放大时 5 个网格各缓存一条整段曲线」可以同时驻留。 */
-		const std::size_t kCurveSpanCacheMaxBytes = 768ull * 1024ull * 1024ull;
-		/**
-		 * @brief 派生（预览）曲线走「后台异步计算」的窗口采样数门槛。
-		 *
-		 * 拖动滑块 / 移动视界 / 缩放每帧都会请求预览曲线。窗口不超过本门槛时同步重算足够快
-		 * （弱峰调整 ≈0.9ms/6.5 万采样），预览曲线能**实时跟随控件**；一旦窗口超过门槛
-		 * （大时间跨度、整条信号），同步重算会阻塞交互（弱峰调整整条信号单条 ≈368ms），
-		 * 此时改为交后台线程计算、本帧先用旧曲线顶替（双缓冲），保证控件反馈始终跟手。
-		 */
-		const std::size_t kDerivedAsyncWindowThreshold = 65536;
-		/**
-		 * @brief 「超大信号」门槛：信号采样数超过它时，**拖拽参数期间不再反复排队**"整条信号"的
-		 *        预览曲线重算（见 `CurveSpanFor`）。
-		 *
-		 * 预览曲线按整条信号计算（`[0, count]`，与「构建为新信号」逐位一致）。信号极大时每条
-		 * 曲线要扫描上亿个采样，后台线程被持续占满会**反过来拖慢前台绘制**（实测前台 14ms/帧，
-		 * 而绘制本身仅 0.4ms）。此时拖动期间沿用旧曲线、松手后再算一次最新的即可 ——
-		 * 整条信号的重算本来就追不上滑块速度，"冻结"与"每帧重排"观感相同，但后者拖慢前台。
-		 */
-		const std::size_t kHugeSignalPreviewSamples = 4000000ull;
-		const wchar_t* const kWeakPeakLevelLabel = L"调整幅度";	/**< 逐条目面板里「幅度」滑块行的标签（用户要求：滑动条前不再单独显示 `%`）。 */
-		const wchar_t* const kWeakPeakIterationsLabel = L"迭代次数 N";		/**< MEAN / CENTER 面板里「迭代次数」输入框的标签。 */
-		/** 「弱峰调整」迭代次数滑块行的标签（用户要求：滑动条前不再单独显示 `N`）。 */
-		const wchar_t* const kWeakPeakIterationsSliderLabel = L"迭代次数";
-		const wchar_t* const kWeakPeakTitle = L"弱峰调整";			/**< 弱峰调整面板标题。 */
-		const wchar_t* const kBuildSignalLabel = L"构建为新信号";	/**< 逐条目面板底部按钮文案（均值滤波 / 弱峰调整共用）。 */
-		/**
-		 * @brief 边沿统计累积状态上限。
-		 *
-		 * ⚠️ 必须足够大：`普通 + 中心轴` × 一个网格里的信号数（都勾选时）会被全部使用。
-		 * 上限太小会**淘汰其它信号的已扫完状态** → 它们从头重扫（表现为“改一个参数、
-		 * 其它几个信号也重新统计”）。一个状态仅占「块数组 ≈ (采样数/8192)×16B」+ 几十 KB
-		 * 本地曲线，64 个状态对内存无压力。
-		 * 真的超限时**优先淘汰「已扫完」的最旧状态**（它重新扫完很快），绝不淘汰正在推进的。
-		 */
-		const std::size_t kEdgeScanStateLimit = 64;
-		/**
-		 * @brief 「边沿计数」累积统计的分块大小（采样点数）。
-		 *
-		 * 每块各存上升/下降沿数：查询某个时间区间时，内部整块用存储值相加、只有两端边界块
-		 * 需要就地精确扫描（≤ 2 块），因此拖动时间光标的单帧代价与区间长度无关。
-		 * 取小一点 ⇒ 边界块扫描更便宜；取大一点 ⇒ 块数组更省内存。
-		 */
-		const std::size_t kEdgeBlockSamples = 8192;
-		/**
-		 * @brief 每一帧允许「边沿计数」扫描的采样对总数（跨全部累积状态共享）。
-		 *
-		 * 千万级信号整段扫描一次 ≈115ms（用户报告：5 条信号同一网格时单帧 ≈575ms，
-		 * 界面完全失去响应）。改成预算推进后，单帧最多只花 ≈5ms 在统计上，
-		 * 剩下的部分在后续帧里接着扫（未扫完时界面显示上一个完整结果 + “…”）。
-		 *
-		 * ⚠️ **必须按帧重置**（在 `Paint` 开头）：旧实现按 `GetTickCount64()` 分桶，
-		 * 而系统时钟粒度约 15.6ms —— 当帧率高于它时（`PostMessage` 自持重绘会把帧率拉高），
-		 * 同一 tick 内的多帧**完全不推进**（用户报告：“按住横向光标不动时统计卡在统计中”，
-		 * “回车确认参数后不移动鼠标就一直停在部分值”）。
-		 */
-		const std::size_t kEdgeScanPairsPerFrame = 1200000;
-		/**
-		 * @brief 每个累积状态每帧的扫描配额下限（防止多个状态时前面的把预算吃光）。
-		 *
-		 * 过去所有状态共享一个“本 tick 总预算”，而推进总是从列表中的第一个状态开始
-		 * —— 5 条信号时只有第一条有进展，其余 4 条长期显示“统计中…”（用户报告
-		 * “很多项都停在了统计中不更新”）。现在每个状态各自持有每帧配额，互不饿死。
-		 */
-		const std::size_t kEdgeScanPairsPerStateMin = 60000;
-		/**
-		 * @brief 计算每状态配额时假定的“最小并发状态数”。
-		 *
-		 * ⚠️ 不能直接用 `m_edgeScans.size()`：状态是在**同一帧内逐个创建**的，第一个状态的
-		 * 那一刻 `size() == 1`，会拿走整额预算 → 同帧后面新建的状态全部被截断为 0 配额
-		 *（首帧只有第一条信号推进）。按一个典型并发量（普通 + 中心轴 × 网格内信号数）
-		 * 下限分摊，可保证同一帧里所有状态都得到推进。
-		 */
-		const std::size_t kEdgeScanFairShare = 6;
-		/**
-		 * @brief 「边沿计数」结果里的**上升沿**部分文本。
-		 * @param [IN] rising 上升沿数量。 @param [IN] complete 是否为完整精确值。
-		 * @return 形如 "上升沿 123"（未算完时追加 " …"）的文本。
-		 */
-		std::wstring EdgeRisingText(std::size_t rising, bool complete)
-		{
-			std::wstring text = L"上升沿 " + std::to_wstring(rising);
-			if (!complete)
-			{
-				text += L" …";
-			}
-			return text;
-		}
-
-		/**
-		 * @brief 「边沿计数」结果里的**下降沿**部分文本。
-		 * @param [IN] falling 下降沿数量。 @param [IN] complete 是否为完整精确值。
-		 * @return 形如 "下降沿 456"（未算完时追加 " …"）的文本。
-		 */
-		std::wstring EdgeFallingText(std::size_t falling, bool complete)
-		{
-			std::wstring text = L"下降沿 " + std::to_wstring(falling);
-			if (!complete)
-			{
-				text += L" …";
-			}
-			return text;
-		}
-
-		/**
-		 * @brief 「边沿计数」是否处于“完全未算出”状态（用于显示“统计中…”）。
-		 */
-		bool EdgeCountsPending(std::size_t rising, std::size_t falling, bool complete)
-		{
-			return (!complete && rising == 0 && falling == 0);
-		}
-
-		/**
-		 * @brief 「边沿计数」结果的显示文本（合并成一行，用于宽度测量与兼容旧调用）。
-		 *
-		 * ⚠️ 未完成时**两个数字后面都要带 `…`**（旧实现只在整行末尾追加一个 `…`，
-		 * 视觉上只跟在“下降沿”的数字后面，用户明确要求“为上升沿也加上这个尾缀”）。
-		 * @param [IN] rising 上升沿数量。 @param [IN] falling 下降沿数量。
-		 * @param [IN] complete 是否为该阈值的完整精确值。
-		 * @return 面板/宽度测量共用的文本。
-		 */
-		[[maybe_unused]] std::wstring EdgeCountsText(std::size_t rising, std::size_t falling,
-		                                            bool complete)
-		{
-			if (EdgeCountsPending(rising, falling, complete))
-			{
-				return L"统计中…";
-			}
-			return EdgeRisingText(rising, complete) + L"    " + EdgeFallingText(falling, complete);
-		}
-
-		/**
-		 * @brief 判断坐标是否命中「弱峰调整」的某条滑块轨道。
-		 *
-		 * 轨道本身只有几个像素高，直接按轨道矩形命中很难抓住，因此把命中区在纵向上下各放宽
-		 * （至少一个轨道高度），与样式区滑块的交互一致。
-		 *
-		 * @param [IN] track 滑块轨道矩形（宽度为 0 表示当前没有滑块）。
-		 * @param [IN] scale DPI 缩放比例。
-		 * @param [IN] x 客户区横坐标。
-		 * @param [IN] y 客户区纵坐标。
-		 * @return 命中返回 true。
-		 */
-		bool WeakPeakSliderHit(const gd::RectF& track, float scale, float x, float y)
-		{
-			if (track.Width <= 0.0f)
-			{
-				return false;
-			}
-			gd::RectF hit = track;
-			const float pad = std::max(8.0f * scale, track.Height);
-			hit.Y -= pad;
-			hit.Height += pad * 2.0f;
-			return UiPointInRect(hit, x, y);
-		}
-
-		/**
-		 * @brief 「弱峰调整」滑块行右侧**数值列**的宽度（布局与面板宽度共用同一算式）。
-		 *
-		 * 取「+400%」与「10000」两者较宽者：前者是幅度滑块的最大显示文本
-		 *（**正负号始终显示**，且量程已扩到 ±400%），
-		 * 后者为迭代次数上限留出足够位宽（上限可被用户改大）。
-		 */
-		float WeakPeakValueColumnWidth(HFONT monoSmall)
-		{
-			return std::max(UiMeasureTextWidth(monoSmall, L"+400%"),
-			                UiMeasureTextWidth(monoSmall, L"10000"));
-		}
-
-		/** @brief 「弱峰调整」滑块行左侧**标签列**的宽度（两条标签取较宽者，保证轨道左对齐）。 */
-		float WeakPeakLabelColumnWidth(HFONT uiSmall)
-		{
-			return std::max(UiMeasureTextWidth(uiSmall, kWeakPeakLevelLabel),
-			                UiMeasureTextWidth(uiSmall, kWeakPeakIterationsSliderLabel));
-		}
-
-		/**
-		 * @brief 取折线（相邻采样点之间线性连接）在给定时刻的取值。
-		 *
-		 * 包络是按像素列聚合的，因此某一段折线可能**跨越列边界**：跨越边界的那一小段
-		 * 在两个列里都不属于"落在本列内的采样点"，只看列内采样点就会把它整段丢掉。
-		 * 该函数用于在列边界处取回这段折线的取值，使相邻两列的包络严丝合缝。
-		 *
-		 * @param [IN] time 时间轴。
-		 * @param [IN] values 采样值。
-		 * @param [IN] count 可用采样点数量。
-		 * @param [IN] style 显示外观（水平镜像时按**源下标反序**取值）。
-		 * @param [IN] firstIndex 第一个时间不小于查询时刻的采样下标（相交线段为 firstIndex-1 → firstIndex）。
-		 * @param [IN] t 查询时刻。
-		 * @param [OUT] out 输出取值。
-		 * @return 折线覆盖该时刻且取到有效值返回 true。
-		 */
-		bool PolylineValueAt(const std::vector<double>& time, const std::vector<double>& values,
-		                     std::size_t count, const SignalStyle& style, std::size_t firstIndex,
-		                     double t, double& out)
-		{
-			if (firstIndex == 0 || firstIndex >= count)
-			{
-				// 该时刻之前（或之后）没有采样点，折线并未延伸到这里。
-				return false;
-			}
-			const double t0 = time[firstIndex - 1];
-			const double t1 = time[firstIndex];
-			// 水平镜像时画面上的相邻两点取源数组中头尾对调后的两个采样。
-			const double v0 = values[SourceIndexFor(style, count, firstIndex - 1)];
-			const double v1 = values[SourceIndexFor(style, count, firstIndex)];
-			if (!std::isfinite(t0) || !std::isfinite(t1) || !std::isfinite(v0) || !std::isfinite(v1) ||
-			    !(t1 > t0))
-			{
-				return false;
-			}
-			double ratio = (t - t0) / (t1 - t0);
-			if (ratio < 0.0)
-			{
-				ratio = 0.0;
-			}
-			else if (ratio > 1.0)
-			{
-				ratio = 1.0;
-			}
-			out = v0 + (v1 - v0) * ratio;
-			return true;
-		}
-
-		/**
-		 * @brief 统计相邻采样对 (k-1, k) 中穿越判定基准的边沿数量。
-		 *
-		 * `deltaAt(k)` 返回第 k 个采样相对判定基准的偏差；返回非有限值（NaN）表示该采样
-		 * 不参与判定，并**打断连续性**（与前一点之间不计边沿）——这正好覆盖
-		 * 「采样缺失」与「采样落在统计时间区间之外」两种情况。
-		 *
-		 * 统计的是采样对 `k ∈ [pairFirst, pairLast]`（闭区间），每对的「前一点」为 `k-1`，
-		 * 因此起点对的连续性由 `deltaAt(pairFirst - 1)` 决定（它无效时从下一个有效点重新起算）。
-		 *
-		 * 该函数是增量统计的基本单位：只要把区间切成互不相交的若干段分别累加（或从总量中减去），
-		 * 结果与一次性扫描整段完全一致，因此拖动光标时可以只扫描两端差集。
-		 *
-		 * @param [IN] pairFirst 起始采样对的下标 k（含），必须 ≥ 1。
-		 * @param [IN] pairLast 结束采样对的下标 k（含）；小于起点时不做任何事。
-		 * @param [IN] deltaAt 偏差取值仿函数。
-		 * @param [IN,OUT] rising 累加的上升沿数量。
-		 * @param [IN,OUT] falling 累加的下降沿数量。
-		 */
-		template <typename DeltaAt>
-		void AccumulateEdgeCrossings(std::size_t pairFirst, std::size_t pairLast, DeltaAt deltaAt,
-		                             std::size_t& rising, std::size_t& falling)
-		{
-			if (pairFirst == 0 || pairFirst > pairLast)
-			{
-				return;
-			}
-			double previousDelta = deltaAt(pairFirst - 1);
-			bool hasPrevious = std::isfinite(previousDelta);
-			for (std::size_t index = pairFirst; index <= pairLast; ++index)
-			{
-				const double current = deltaAt(index);
-				if (!std::isfinite(current))
-				{
-					hasPrevious = false;
-					continue;
-				}
-				if (hasPrevious)
-				{
-					if (previousDelta < 0.0 && current >= 0.0)
-					{
-						++rising;
-					}
-					else if (previousDelta > 0.0 && current <= 0.0)
-					{
-						++falling;
-					}
-				}
-				previousDelta = current;
-				hasPrevious = true;
-			}
-		}
-
-		/**
-		 * @brief 「调整」变换 + 水平镜像的指纹（用于边沿统计缓存键）。
-		 *
-		 * 边沿判定基于**画出来的曲线**，因此任何一个变换项改变都可能改变计数结果；
-		 * 把这些项折叠成一个指纹后，样式一变就能立刻失效缓存项（否则会沿用变换前的旧计数）。
-		 *
-		 * @param [IN] style 信号外观。
-		 * @return 指纹值。
-		 */
-		std::uint64_t EdgeStyleKey(const SignalStyle& style)
-		{
-			std::uint64_t key = 1469598103934665603ull;
-			const auto mix = [&key](std::uint64_t value)
-			{
-				key ^= value;
-				key *= 1099511628211ull;
-			};
-			mix(static_cast<std::uint64_t>(
-			    std::llround(static_cast<double>(style.gain) * 1.0e6)));
-			mix(static_cast<std::uint64_t>(
-			    std::llround(static_cast<double>(style.offsetY) * 1.0e6)));
-			mix(style.absolute ? 1u : 0u);
-			mix(style.mirrorVertical ? 2u : 0u);
-			mix(style.mirrorHorizontal ? 4u : 0u);
-			return key;
-		}
-
-		/**
-		 * @brief 计算统计区间对应的采样下标区间 [begin, end)。
-		 *
-		 * 时间轴单调时用二分定位。⚠️ 区间**之外**的采样一律不参与计数，
-		 * 因此这里**不做任何外扩**：只有两端都落在 `[begin, end)` 内的采样对才会被累计
-		 *（调用方从 `begin + 1` 开始枚举采样对）。
-		 *
-		 * @param [IN] group 所属数据分组。
-		 * @param [IN] count 采样点数量。
-		 * @param [IN] hasRange 是否限定时间区间。
-		 * @param [IN] rangeMin 区间左端点时间。
-		 * @param [IN] rangeMax 区间右端点时间。
-		 * @param [OUT] begin 输出区间起点（含）。
-		 * @param [OUT] end 输出区间终点（不含）。
-		 * @return 计数是否完全由该下标区间决定（时间轴单调时为真）。
-		 */
-		bool EdgeIndexRange(const TimeAxis& axis, std::size_t count, bool hasRange, double rangeMin,
-		                    double rangeMax, std::size_t& begin, std::size_t& end)
-		{
-			begin = 0;
-			end = count;
-			if (!hasRange)
-			{
-				return true;
-			}
-			if (!axis.monotonic)
-			{
-				// 时间轴非单调时无法用下标区间表达统计范围（需逐点按时间过滤）。
-				return false;
-			}
-
-			const std::vector<double>& times = axis.time;
-			const std::size_t timeCount = std::min(times.size(), count);
-			begin = static_cast<std::size_t>(
-			    std::lower_bound(times.begin(), times.begin() + static_cast<std::ptrdiff_t>(timeCount),
-			                     rangeMin) -
-			    times.begin());
-			// ⚠️ **不要**在左端多取一个采样点：那会让“跨越区间边界的边沿”也算进来，
-			//    而用户明确要求“在光标选区外的点不要算入计数规则”。
-			//    （例：光标恰好落在越过阈值的第一个采样点 B 上时，A→B 这一段处于选区之外，
-			//      不计入；旧实现在左端多取一个点，于是 B 被错认成上升沿。）
-			end = static_cast<std::size_t>(
-			    std::upper_bound(times.begin(), times.begin() + static_cast<std::ptrdiff_t>(timeCount),
-			                     rangeMax) -
-			    times.begin());
-			end = std::min(end, timeCount);
-			begin = std::min(begin, end);
-			return true;
-		}
-
-		const std::uint64_t kHintHoldMs = 1300;	/**< 提示浮层完全显示的停留时长（毫秒）。 */
-		const std::uint64_t kHintFadeMs = 500;	/**< 提示浮层的淡出时长（毫秒）。 */
-
-		/**
-		 * @brief 实验性功能浮动面板的遍历顺序（命中测试与绘制共用，保证层序一致）。
-		 *
-		 * 顺序即绘制层序：先绘制的在下方，最后绘制的在最上方。
-		 */
-		const EdgePanelKind kEdgePanelKinds[] = {EdgePanelKind::COUNT, EdgePanelKind::CENTER,
-		                                        EdgePanelKind::MEAN, EdgePanelKind::PEAK};
-
-		/** 实验性功能浮动面板的种类数（遍历与命中测试统一用它，避免新增功能时漏改）。 */
-		const int kEdgePanelKindCount = static_cast<int>(sizeof(kEdgePanelKinds) / sizeof(kEdgePanelKinds[0]));
-
-		/**
-		 * @brief 计算一条派生曲线在给定采样窗口内的取值（同步路径与后台线程共用）。
-		 *
-		 * 只拷贝所需的窗口，再调用与「构建为新信号」完全相同的自由函数，因此
-		 * 预览曲线与构建出的采样值逐位一致。本函数**只读**入参、不接触任何成员状态，
-		 * 因此可以安全地在后台线程调用。
-		 *
-		 * @param [IN] signal 目标信号（数据只读）。
-		 * @param [IN] windowBegin 窗口起点（采样下标）。
-		 * @param [IN] windowEnd 窗口终点（不含）。
-		 * @param [IN] kind `DerivedCurveKind` 的整型值。
-		 * @param [IN] points 均值点数 X。
-		 * @param [IN] iterations 迭代次数 N。
-		 * @param [IN] amountPercent 弱峰调整幅度（-400–400）。
-		 * @param [IN] cancel 可选的取消标志（透传给算法，使过时任务尽快退出）。
-		 * @param [IN] throttle 是否在阶与阶之间让出 CPU（低内存设备的“少量多次”模式）。
-		 * @return 曲线数值（长度 = 有效窗口长度）。
-		 */
-		std::vector<float> ComputeDerivedWindow(const SignalData& signal, std::size_t windowBegin,
-		                                        std::size_t windowEnd, int kind, int points,
-		                                        int iterations, int amountPercent,
-		                                        const std::atomic<bool>* cancel, bool throttle)
-		{
-			std::vector<float> out;
-			const std::vector<double>& values = signal.values;
-			const std::size_t hi = std::min(windowEnd, values.size());
-			const std::size_t lo = std::min(windowBegin, hi);
-			if (hi <= lo)
-			{
-				return out;
-			}
-			// ⚠️ **整段窗口不要复制**：`VERY_BIG_DATA` 一条曲线要 8 B/采样 × 2580 万 ≈ 206 MB，
-			//    而“预览曲线一律按整条信号计算”正是最常见的情形。
-			//    采样在本函数执行期间不会被修改（结构变化前宿主会先 `PauseDerivedAsync`），
-			//    因此整段时直接引用原向量；只有子窗口才切片复制。
-			const bool wholeSignal = (lo == 0) && (hi == values.size());
-			const std::vector<double> window = wholeSignal
-			                                      ? std::vector<double>()
-			                                      : std::vector<double>(
-			                                            values.begin() + static_cast<std::ptrdiff_t>(lo),
-			                                            values.begin() + static_cast<std::ptrdiff_t>(hi));
-			const std::vector<double>& input = wholeSignal ? values : window;
-			if (kind == static_cast<int>(DerivedCurveKind::WEAK_PEAK))
-			{
-				ComputeWeakPeakAdjust(input, static_cast<double>(amountPercent) / 100.0, iterations, out,
-				                      cancel, throttle);
-			}
-			else
-			{
-				ComputeMovingAverageIterated(input, points, iterations, out, cancel, throttle);
-			}
-			return out;
-		}
-
-		/**
-		 * @brief 包络带的单个像素列（已映射到屏幕坐标）。
-		 */
-		struct BandColumn
-		{
-			float x = 0.0f;			/**< 列中心横坐标。 */
-			float top = 0.0f;		/**< 本列的**上**包络（较小的纵坐标）。 */
-			float bottom = 0.0f;	/**< 本列的**下**包络（较大的纵坐标）。 */
-		};
-
-		/**
-		 * @brief 把逐列极值拼成闭合的包络带多边形。
-		 *
-		 * 输出格式为「上包络正向 + 下包络反向」，调用方（`PaintLane`）依赖这个顺序把
-		 * 它拆成上下两条折线画成一个闭合环。
-		 *
-		 * ⚠️ **几何必须是精确的**：这里**不做任何**列窗口加宽。曾经为了让填充更快而做过
-		 * ±1 列的极值扩展，结果把"梳状"振荡糊成了实心块，波形细节整体丢失
-		 * （用户反馈"显示效果没有之前好了"）。性能问题改由**绘制侧**解决：把梳状带
-		 * 交给无抗锯齿填充（见 `spiky` 输出与 `PlotView::m_fastFrame`）。
-		 *
-		 * @param [IN] columns 逐列极值（同一段内按列顺序排列）。
-		 * @param [OUT] band 追加写入的包络顶点（上包络正向 + 下包络反向）。
-		 * @param [OUT] bandBreaks 追加写入的各段起点（相对 band 的下标）。
-		 * @param [OUT] spiky 该段是否为「梳状 / 密集满幅」（建议关闭抗锯齿）。
-		 * @param [IN] laneHeight 网格的可见像素高度（用于「覆盖率」判据；≤0 时跳过）。
-		 */
-		void EmitEnvelopeBand(const std::vector<BandColumn>& columns, std::vector<gd::PointF>& band,
-		                      std::vector<std::size_t>& bandBreaks, bool& spiky, float laneHeight)
-		{
-			if (columns.size() < 2)
-			{
-				return;
-			}
-			const std::size_t count = columns.size();
-			bandBreaks.push_back(band.size());
-
-			// 「梳状」判定：相邻列的上下包络几乎不相交（振荡周期与像素列宽相当时出现）。
-			// 这种形状下抗锯齿填充的扫描线代价暴涨，而抗锯齿对它的平滑作用几乎看不出来。
-			std::size_t inverted = 0;
-			const float slack = kEnvelopeMinPixelSpan;
-			for (std::size_t index = 1; index < count; ++index)
-			{
-				if (columns[index].top > columns[index - 1].bottom + slack ||
-				    columns[index].bottom < columns[index - 1].top - slack)
-				{
-					++inverted;
-				}
-			}
-			if (inverted * 8 > count)
-			{
-				spiky = true;
-			}
-
-			// 「密集满幅」判定：包络带在**每一列内部**都横跨了网格的大部分高度
-			//（编码器方波在 1~2 采样/像素时，多数像素列里都含一次整幅跳变）。
-			// GDI+ **抗锯齿**的代价与这些近竖直、满幅的边成正比：实测同一 4832 顶点的几何
-			// **抗锯齿 694ms、关抗锯齿 29ms（23 倍）**，而这么密的色块上抗锯齿的平滑作用肉眼不可辨。
-			// ⚠️ 只影响「本段是否关抗锯齿」，几何（逐列 min/max）完全不变。
-			if (laneHeight > 0.0f)
-			{
-				std::size_t tallColumns = 0;
-				double covered = 0.0;
-				for (const BandColumn& column : columns)
-				{
-					const float span = column.bottom - column.top;
-					covered += static_cast<double>(span);
-					if (span > 0.5f * laneHeight)
-					{
-						++tallColumns;
-					}
-				}
-				// 「锯齿」判定（最能代表 GDI+ 抗锯齿代价）：相邻列的上下包络**整幅跳变**。
-				std::size_t jumps = 0;
-				const float jumpThreshold = 0.25f * laneHeight;
-				for (std::size_t index = 1; index < count; ++index)
-				{
-					const float dTop = std::fabs(columns[index].top - columns[index - 1].top);
-					const float dBottom = std::fabs(columns[index].bottom - columns[index - 1].bottom);
-					if (dTop > jumpThreshold || dBottom > jumpThreshold)
-					{
-						++jumps;
-					}
-				}
-				if (tallColumns * 4 > count || jumps * 4 > count ||
-				    covered > 0.45 * static_cast<double>(count) * static_cast<double>(laneHeight))
-				{
-					spiky = true;
-				}
-			}
-
-			for (std::size_t index = 0; index < count; ++index)
-			{
-				band.push_back(gd::PointF(columns[index].x, columns[index].top));
-			}
-			for (std::size_t index = count; index-- > 0;)
-			{
-				band.push_back(gd::PointF(columns[index].x, columns[index].bottom));
-			}
-		}
-
-		/**
-		 * @brief 双光标差值的完整显示文本（"Δt：" + 复合单位间隔）。
-		 * @param [IN] seconds 时间间隔（秒）。
-		 * @return 形如 "Δt：1h 1min 2s" 的文本。
-		 */
-		std::wstring FormatSpanText(double seconds)
-		{
-			return L"Δt：" + FormatDurationCompound(seconds);
-		}
-
-		/**
-		 * @brief 时间光标的读数文本（"数值 + s 后缀"）。
-		 *
-		 * 时间轴本身就是秒，但与幅值读数放在一起时没有单位容易误读，
-		 * 因此读数恒带 "s" 后缀；内联编辑仍使用不带单位的纯数值（见 BeginEdit 调用处）。
-		 *
-		 * @param [IN] seconds 光标所在时刻（秒）。
-		 * @return 形如 "1.25s" 的文本。
-		 */
-		std::wstring FormatCursorTime(double seconds)
-		{
-			return FormatValue(seconds) + L"s";
-		}
-
-		/**
-		 * @brief 按比例缩放颜色的 alpha 通道（用于提示浮层淡出）。
-		 * @param [IN] argb 原始 0xAARRGGBB 颜色。
-		 * @param [IN] alpha 新的 alpha（0-255）。
-		 * @return 缩放后的颜色。
-		 */
-		std::uint32_t ScaleAlpha(std::uint32_t argb, unsigned int alpha)
-		{
-			const unsigned int a = std::min(255u, alpha);
-			return (argb & 0x00FFFFFFu) | (a << 24);
-		}
-
-		/**
-		 * @brief 将数值限制到合法区间。
-		 * @param [IN] value 输入值。
-		 * @param [IN] low 下限。
-		 * @param [IN] high 上限。
-		 * @return 限制后的数值。
-		 */
-		double ClampDouble(double value, double low, double high)
-		{
-			if (value < low)
-			{
-				return low;
-			}
-			if (value > high)
-			{
-				return high;
-			}
-			return value;
-		}
-
-		/**
-		 * @brief 组装图例文本：使用信号当前显示名（用户重命名后立即生效）。
-		 * @param [IN] data 信号数据。
-		 * @return 图例文本。
-		 */
-		std::wstring BuildLegendText(const SignalData& data)
-		{
-			return data.name;
-		}
-
-		/**
-		 * @brief 将信号样式颜色按不透明度换算为实际绘制颜色。
-		 * @param [IN] style 信号样式。
-		 * @return 叠加不透明度后的 0xAARRGGBB 颜色值。
-		 */
-		std::uint32_t StyleColor(const SignalStyle& style)
-		{
-			double opacity = static_cast<double>(style.opacity);
-			if (opacity < 0.0)
-			{
-				opacity = 0.0;
-			}
-			if (opacity > 1.0)
-			{
-				opacity = 1.0;
-			}
-			return WithAlpha(style.color, static_cast<unsigned int>(opacity * 255.0 + 0.5));
-		}
-
-		/**
-		 * @brief 由信号色派生一个「高对比度」颜色：保持色相、大幅拉开明度。
-		 *
-		 * 用途：「边沿计数（中心轴）」的平均值曲线叠加在原始波形之上，
-		 * 若直接用信号色会被波形淹没。这里把信号色向黑或白方向大幅偏移，
-		 * 并**同时考虑与原始波形色以及与绘图区底色的距离**，取对比更强的一侧，
-		 * 保证曲线既能与波形区分、又能压在底图上看得清。
-		 *
-		 * 结果是从信号色派生的，因此原信号改颜色时曲线颜色会自动跟着变。
-		 *
-		 * @param [IN] color 原始信号色（0xAARRGGBB）。
-		 * @param [IN] background 绘图区底色，用于评估可见度。
-		 * @return 派生出的高对比度颜色（alpha 与输入一致，由调用方再覆盖）。
-		 */
-		std::uint32_t HighContrastDerived(std::uint32_t color, std::uint32_t background = 0xFFFDF6E3u)
-		{
-			const auto squaredDistance = [](std::uint32_t a, std::uint32_t b)
-			{
-				const double dr =
-				    static_cast<double>((a >> 16) & 0xFFu) - static_cast<double>((b >> 16) & 0xFFu);
-				const double dg =
-				    static_cast<double>((a >> 8) & 0xFFu) - static_cast<double>((b >> 8) & 0xFFu);
-				const double db = static_cast<double>(a & 0xFFu) - static_cast<double>(b & 0xFFu);
-				return dr * dr + dg * dg + db * db;
-			};
-
-			const std::uint32_t darker = MixColor(color, 0xFF000000u, 0.72);
-			const std::uint32_t lighter = MixColor(color, 0xFFFFFFFFu, 0.72);
-			// 评分：与原始波形色的区分度为主（权重 1.0），与底色的可见度为辅（权重 0.6）。
-			const double scoreDarker =
-			    squaredDistance(darker, color) + 0.6 * squaredDistance(darker, background);
-			const double scoreLighter =
-			    squaredDistance(lighter, color) + 0.6 * squaredDistance(lighter, background);
-			return (scoreDarker >= scoreLighter) ? darker : lighter;
-		}
-	}
 	PlotView::PlotView() = default;
 
 	PlotView::~PlotView()
@@ -927,21 +54,6 @@ namespace jdi
 		InvalidateWideBuffer();
 	}
 
-	bool PlotView::CursorEnabled() const
-	{
-		return Tab().CursorEnabled();
-	}
-
-	double PlotView::CursorTime() const
-	{
-		return Tab().CursorTime();
-	}
-
-	PlotCursorMode PlotView::CursorMode() const
-	{
-		return Tab().CursorMode();
-	}
-
 	bool PlotView::HasDrawableContent() const
 	{
 		return (m_dataSet != nullptr) && !m_dataSet->Empty() && (m_tab != nullptr) && m_tab->AnyVisible();
@@ -1050,27 +162,6 @@ namespace jdi
 		}
 	}
 
-	const SignalRef& PlotView::SelectedRef() const
-	{
-		static const SignalRef fallback;
-		return (m_dataSet != nullptr) ? m_dataSet->Selected() : fallback;
-	}
-
-	void PlotView::SelectSignal(const SignalRef& ref)
-	{
-		if (m_dataSetWritable != nullptr)
-		{
-			m_dataSetWritable->SetSelected(ref);
-		}
-		// 联动（用户 2026-10-15 要求）：绘图区内把某条信号选为当前目标时，
-		// 请求宿主把信号列表**平滑滚动**到它，保证在长列表里也能看到它。
-		if (ref.IsValid())
-		{
-			m_pendingPanelScroll = ref;
-			m_pendingPanelScrollFlag = true;
-		}
-	}
-
 	bool PlotView::TakePanelScrollRequest(SignalRef& ref)
 	{
 		if (!m_pendingPanelScrollFlag)
@@ -1083,43 +174,20 @@ namespace jdi
 		return ref.IsValid();
 	}
 
-	void PlotView::SetExternalHoverSignal(const SignalRef& ref)
-	{
-		if (m_externalHoverSignal == ref)
-		{
-			return;
-		}
-		m_externalHoverSignal = ref;
-	}
-
-	int PlotView::EffectiveHoverLane() const
-	{
-		if (m_hoverLane >= 0)
-		{
-			return m_hoverLane;
-		}
-		// 外部悬停信号（信号列表 / 样式区「目标」行）：只在该信号确实绘制到某个网格时生效。
-		if (m_tab != nullptr && m_externalHoverSignal.IsValid())
-		{
-			return m_tab->LaneOfSignal(m_externalHoverSignal);
-		}
-		return -1;
-	}
-
 	void PlotView::ClampLaneScroll()
 	{
 		const float maxOffset = std::max(0.0f, m_laneContentHeight - m_plotRect.Height);
 		Tab().LaneScroll() = static_cast<float>(ClampDouble(Tab().LaneScroll(), 0.0, maxOffset));
 	}
 
-	bool PlotView::LaneSpansMultipleFiles(int laneIndex) const
+	bool PlotView::LaneSpansMultipleGroups(int laneIndex) const
 	{
 		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
 		{
 			return false;
 		}
 
-		int firstFile = -1;
+		int firstGroup = -1;
 		for (const SignalRef& ref : m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals)
 		{
 			const SignalStyle* style = m_dataSet->Style(ref);
@@ -1127,11 +195,11 @@ namespace jdi
 			{
 				continue;
 			}
-			if (firstFile < 0)
+			if (firstGroup < 0)
 			{
-				firstFile = ref.groupIndex;
+				firstGroup = ref.groupIndex;
 			}
-			else if (ref.groupIndex != firstFile)
+			else if (ref.groupIndex != firstGroup)
 			{
 				return true;
 			}
@@ -1232,20 +300,6 @@ namespace jdi
 		return lane.yMin + ratio * (lane.yMax - lane.yMin);
 	}
 
-	int PlotView::LaneAtY(int y) const
-	{
-		const float fy = static_cast<float>(y);
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			const gd::RectF& rect = m_lanes[index].rect;
-			if (fy >= rect.Y && fy <= rect.Y + rect.Height)
-			{
-				return static_cast<int>(index);
-			}
-		}
-		return -1;
-	}
-
 	void PlotView::ClampTimeView()
 	{
 		if (m_dataSet == nullptr || m_dataSet->Empty())
@@ -1336,39 +390,6 @@ namespace jdi
 		}
 	}
 
-	void PlotView::ZoomTimeAt(double factor, double anchorTime)
-	{
-		if (m_dataSet == nullptr || m_dataSet->Empty() || !(factor > 0.0) || !std::isfinite(anchorTime))
-		{
-			return;
-		}
-
-		double dataMin = 0.0;
-		double dataMax = 1.0;
-		TimeBounds(dataMin, dataMax);
-		const double dataSpan = std::max(dataMax - dataMin, kMinTimeSpan);
-
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(span > 0.0))
-		{
-			return;
-		}
-		// 下限与选区放大共用同一个来源（见 `MinimumTimeSpan`），
-		// 否则“滚轮缩放有限制、选区放大没有”会让视界退化到不可用。
-		const double minimum = MinimumTimeSpan(Tab().ViewMin(), Tab().ViewMax());
-		const double newSpan = ClampDouble(span / factor, minimum, dataSpan * 100.0);
-
-		const double ratio = (anchorTime - Tab().ViewMin()) / span;
-		const double low = anchorTime - ratio * newSpan;
-		SetTimeView(low, low + newSpan);
-	}
-
-	void PlotView::ZoomTimeStep(double factor)
-	{
-		const double anchor = (Tab().ViewMin() + Tab().ViewMax()) * 0.5;
-		ZoomTimeAt(factor, anchor);
-	}
-
 	void PlotView::PanTimeByFraction(double fraction)
 	{
 		const double span = Tab().ViewMax() - Tab().ViewMin();
@@ -1397,678 +418,6 @@ namespace jdi
 	 *    居中并缩放到"一大格 = 1s"（`kSinglePointClusterSecondsPerCell`），
 	 *    每个网格的幅值区间保证该网格内的数据点都能完整画出。
 	 */
-	void PlotView::FitAll()
-	{
-		if (m_dataSet == nullptr || m_dataSet->Empty())
-		{
-			SetTimeView(0.0, 1.0);
-			return;
-		}
-		if (m_tab == nullptr)
-		{
-			return;
-		}
-
-		// 全部可见信号的"边界贡献"（时刻范围 / 绘制取值 / 是否单点 / 散点半径）。
-		std::vector<std::vector<FitContribution>> perLane;
-		const std::size_t visibleCount = CollectFitContributions(perLane);
-
-		// ---- 特例：所有可见数据点都是单值信号、且时刻完全相同 ----
-		bool allSingle = true;
-		bool sameTime = true;
-		double sharedTime = 0.0;
-		bool haveTime = false;
-		for (const std::vector<FitContribution>& items : perLane)
-		{
-			for (const FitContribution& item : items)
-			{
-				if (!item.singlePoint)
-				{
-					allSingle = false;
-					continue;
-				}
-				if (!haveTime)
-				{
-					sharedTime = item.pointTime;
-					haveTime = true;
-				}
-				else if (std::fabs(item.pointTime - sharedTime) >
-				         kSinglePointSameTimeEpsilon * std::max(1.0, std::fabs(sharedTime)))
-				{
-					sameTime = false;
-				}
-			}
-		}
-		if (visibleCount > 0 && allSingle && sameTime)
-		{
-			FitSinglePointCluster(perLane, sharedTime);
-			return;
-		}
-
-		// ---- 常规的整段适应 ----
-		double low = 0.0;
-		double high = 1.0;
-		TimeBounds(low, high);
-		if (!(high > low))
-		{
-			const double padding = std::max(1.0e-6, std::fabs(low) * 0.01);
-			low -= padding;
-			high += padding;
-		}
-
-		// 时间边界处的单值散点不能被裁切：**被裁切的那一侧**向外让出散点半径。
-		// ⚠️ 迭代两遍：让出余量会改变跨度，而"半径换算成多少时间"又依赖跨度。
-		const double plotWidth = std::max(1.0, static_cast<double>(m_plotRect.Width));
-		for (int pass = 0; pass < 2; ++pass)
-		{
-			const double span = high - low;
-			if (!(span > 0.0))
-			{
-				break;
-			}
-			for (const std::vector<FitContribution>& items : perLane)
-			{
-				for (const FitContribution& item : items)
-				{
-					if (!item.singlePoint || !(item.dotRadius > 0.0f))
-					{
-						continue;
-					}
-					const double radius =
-					    (static_cast<double>(item.dotRadius) + kSinglePointBoundaryPadPixels) * span /
-					    plotWidth;
-					if (item.pointTime - radius < low)
-					{
-						low = item.pointTime - radius;
-					}
-					if (item.pointTime + radius > high)
-					{
-						high = item.pointTime + radius;
-					}
-				}
-			}
-		}
-
-		SetTimeView(low, high);
-		// ⚠️ **只有真的存在可见信号时才置位 `ViewInitialized()`**：没有任何信号被勾选时
-		//（用户先连点几次「适应视图」）必须保持"未初始化"，否则随后勾选第一个信号时
-		// `Application::SynchronizeView` 会**跳过初次自适应** —— 数据点既不居中，
-		// 还可能有一半被裁在网格外（用户 2026-10-15 报告）。
-		if (visibleCount > 0)
-		{
-			Tab().ViewInitialized() = true;
-		}
-		Tab().LaneScroll() = 0.0f;
-		// 只放下进行中的选区与拖拽，**不改变「选区放大」等缩放模式的启用状态**
-		// （用户明确要求：点适应视图后仍保持已启用的缩放模式）。
-		m_rubberRect = gd::RectF();
-		m_dragMode = PlotDragMode::NONE;
-		m_dragSignal = SignalRef();
-		m_dragTargetLane = -1;
-		m_hoverSignal = SignalRef();
-		SetHint(Tab().ZoomMode() == PlotZoomMode::NONE
-		            ? std::wstring()
-		            : L"横向或纵向拖动以放大选择区域，ESC退出选区模式");
-
-		// ---- 逐网格的幅值轴 ----
-		// 保留既有语义：开启了「选区 Y 轴自适应」的网格按新的（整段）时间视图重新匹配，
-		// 其余网格回到整段自适应；随后再为"被单值散点顶住的边界"让出余量。
-		const float laneHeight = FitLaneHeight();
-		for (std::size_t index = 0; index < m_tab->Lanes().size(); ++index)
-		{
-			const int laneIndex = static_cast<int>(index);
-			if (m_tab->Lanes()[index].fitYToSelection)
-			{
-				AutoRangeLaneToView(laneIndex);
-			}
-			else
-			{
-				m_tab->Lanes()[index].autoRange = true;
-			}
-			ApplySinglePointValueMargins(laneIndex, perLane[index], laneHeight);
-		}
-		// 适应视图已回到初始状态，这里不再移动光标（光标允许停留在可视区外）。
-		BuildLaneVisuals();
-	}
-
-	std::size_t PlotView::CollectFitContributions(std::vector<std::vector<FitContribution>>& perLane) const
-	{
-		perLane.clear();
-		if (m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return 0;
-		}
-		perLane.assign(m_tab->Lanes().size(), std::vector<FitContribution>());
-
-		std::size_t total = 0;
-		for (std::size_t laneIndex = 0; laneIndex < m_tab->Lanes().size(); ++laneIndex)
-		{
-			for (const SignalRef& ref : m_tab->Lanes()[laneIndex].signals)
-			{
-				if (!m_tab->IsVisible(ref))
-				{
-					continue;
-				}
-				const SignalData* data = m_dataSet->Resolve(ref);
-				const TimeAxis* axis = m_dataSet->Axis(ref);
-				if (data == nullptr || axis == nullptr || data->finiteCount == 0)
-				{
-					continue;
-				}
-
-				FitContribution item;
-				item.ref = ref;
-				// 与 `ComputeVisibleTimeBounds` 同源：时间边界用**时间轴**的范围
-				//（一个分组的多条信号可能共用一条轴，轴范围才是"这一段数据"的边界）。
-				item.minTime = axis->minTime;
-				item.maxTime = axis->maxTime;
-				item.singlePoint = (data->finiteCount == 1);
-				if (item.singlePoint)
-				{
-					double time = 0.0;
-					double value = 0.0;
-					if (!SinglePointOfSignal(*data, *axis, time, value))
-					{
-						item.singlePoint = false;
-					}
-					else
-					{
-						const SignalStyle* style = m_dataSet->Style(ref);
-						item.pointTime = time;
-						item.pointValue =
-						    (style != nullptr) ? ApplyDrawTransform(*style, value) : value;
-						item.dotRadius = SinglePointDotRadius(ResolveSignal(ref));
-					}
-				}
-				perLane[laneIndex].push_back(item);
-				++total;
-			}
-		}
-		return total;
-	}
-
-	float PlotView::FitLaneHeight() const
-	{
-		// 与 `BuildLaneVisuals()` **完全同源**：网格高度 = 绘图区高 / 网格数（不低于最小高度）。
-		// 直接复用它（而不是读 `m_lanes[i].rect.Height`）：`FitAll` 可能在网格数量刚变化、
-		// 布局尚未重建时被调用，用公式能拿到**将要生效**的高度。
-		const std::size_t count = (m_tab != nullptr) ? m_tab->Lanes().size() : 0;
-		if (count == 0 || !(m_plotRect.Height > 0.0f))
-		{
-			return 0.0f;
-		}
-		float height = m_plotRect.Height / static_cast<float>(count);
-		if (height < m_minLaneHeight * m_scale)
-		{
-			height = m_minLaneHeight * m_scale;
-		}
-		return height;
-	}
-
-	void PlotView::ApplySinglePointValueMargins(int laneIndex, const std::vector<FitContribution>& items,
-	                                           float laneHeight)
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr || laneHeight <= 1.0f)
-		{
-			return;
-		}
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return;
-		}
-
-		bool anySingle = false;
-		for (const FitContribution& item : items)
-		{
-			if (item.singlePoint && item.dotRadius > 0.0f)
-			{
-				anySingle = true;
-				break;
-			}
-		}
-		if (!anySingle)
-		{
-			return;			// 该网格的边界不是单值散点顶住的：保持现有（自动）区间
-		}
-
-		// 该网格当前**生效**的幅值区间（自动自适应时即 `ComputeLaneRange` 的结果）。
-		double low = 0.0;
-		double high = 0.0;
-		m_tab->ComputeLaneRange(*m_dataSet, laneIndex, low, high);
-		if (!(high > low))
-		{
-			return;
-		}
-
-		double newLow = low;
-		double newHigh = high;
-		// 迭代两遍：让出余量会改变跨度，而"半径换算成多少数值"又依赖跨度。
-		for (int pass = 0; pass < 2; ++pass)
-		{
-			const double span = newHigh - newLow;
-			if (!(span > 0.0))
-			{
-				break;
-			}
-			for (const FitContribution& item : items)
-			{
-				if (!item.singlePoint || !(item.dotRadius > 0.0f))
-				{
-					continue;
-				}
-				const double radius =
-				    (static_cast<double>(item.dotRadius) + kSinglePointBoundaryPadPixels) * span /
-				    static_cast<double>(laneHeight);
-				if (item.pointValue - radius < newLow)
-				{
-					newLow = item.pointValue - radius;
-				}
-				if (item.pointValue + radius > newHigh)
-				{
-					newHigh = item.pointValue + radius;
-				}
-			}
-		}
-		if (newLow == low && newHigh == high)
-		{
-			return;			// 散点本来就完整可见：不改动区间（保持自动自适应的语义）
-		}
-
-		// ⚠️ 必须**同时**关掉 `autoRange`：否则 `ComputeLaneRange` 会忽略下面写入的区间。
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		lane.autoRange = false;
-		lane.yMin = newLow;
-		lane.yMax = newHigh;
-	}
-
-	void PlotView::FitSinglePointCluster(const std::vector<std::vector<FitContribution>>& perLane,
-	                                     double sharedTime)
-	{
-		// 时间轴：该时刻居中、**一大格 = 1s**（视界 = 大格数 × 1s）。
-		//
-		// 幅值轴与其余场景**共用同一段逻辑**（见函数末尾）：`fitYToSelection` 的网格走
-		// `AutoRangeLaneToView`、其余走整段自适应（`ComputeLaneRange`），两者都只由
-		// `PadValueRange` 提供留白。这样「适应视图」与「Y 轴自适应」互为幂等 ——
-		// 同一视界下反复切换两者不会改变区间，也不会关掉 Y 轴自适应开关（用户 2026-10-16）。
-		const double span =
-		    static_cast<double>(kTimeTickTarget) * kSinglePointClusterSecondsPerCell;
-		SetTimeView(sharedTime - span * 0.5, sharedTime + span * 0.5);
-		Tab().ViewInitialized() = true;
-		Tab().LaneScroll() = 0.0f;
-		// ⚠️ **不要**在这里复位 `ZoomMode()`：用户明确要求"点适应视图后仍保持已启用的
-		//    缩放模式"（`FitAll` 的常规路径同样只更新提示、不动缩放模式）。
-		m_rubberRect = gd::RectF();
-		m_dragMode = PlotDragMode::NONE;
-		m_dragSignal = SignalRef();
-		m_dragTargetLane = -1;
-		m_hoverSignal = SignalRef();
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-		SetHint(Tab().ZoomMode() == PlotZoomMode::NONE
-		            ? std::wstring()
-		            : L"横向或纵向拖动以放大选择区域，ESC退出选区模式");
-
-		// ---- 逐网格的幅值轴 ----
-		// ⚠️ **必须与 `FitAll()` 的常规路径、以及「Y 轴自适应」（`AutoRangeLaneToView`）同源**：
-		// 旧实现在这条特例里按“散点半径留白 + 跨度 1”另算一套区间，而 Y 轴自适应走
-		// `PadValueRange`，于是对**同一个视界**两者会算出不同的幅值范围
-		//（用户 2026-10-16 报告：单数据点信号上「适应视图」与「Y 轴自适应」的范围不一致）；
-		// 并且旧实现还把 `fitYToSelection` 置回 false —— 原本开着「Y 轴自适应」时点一下
-		// 「适应视图」会把这个开关**悄悄关掉**。
-		// 现在两者共用同一段逻辑：留白只来自 `PadValueRange`，且**不改动** Y 轴自适应开关。
-		const float laneHeight = FitLaneHeight();
-		for (std::size_t index = 0; index < perLane.size() && index < m_tab->Lanes().size(); ++index)
-		{
-			const int laneIndex = static_cast<int>(index);
-			if (m_tab->Lanes()[index].fitYToSelection)
-			{
-				// 已开启「选区 Y 轴自适应」的网格按当前（刚设好的）时间视图重新匹配 ——
-				// 与工具栏开关打开时的算法完全一致，因此两种操作互为幂等。
-				AutoRangeLaneToView(laneIndex);
-			}
-			else
-			{
-				m_tab->Lanes()[index].autoRange = true;
-			}
-			// 补齐“被单值散点顶住的边界”（散点本来就完整可见时保持不变）。
-			ApplySinglePointValueMargins(laneIndex, perLane[index], laneHeight);
-		}
-
-		InvalidateSceneCache();
-		BuildLaneVisuals();
-	}
-
-	bool PlotView::SinglePointOfSignal(const SignalData& signal, const TimeAxis& axis, double& time,
-	                                   double& value) const
-	{
-		time = std::numeric_limits<double>::quiet_NaN();
-		value = std::numeric_limits<double>::quiet_NaN();
-
-		// 正常路径：加载/插入信号时已把“有效点很少”的信号的全部有效点缓存下来。
-		if (!signal.sparseTimes.empty() && signal.sparseTimes.size() == signal.sparseValues.size())
-		{
-			time = signal.sparseTimes.front();
-			value = signal.sparseValues.front();
-			return std::isfinite(time) && std::isfinite(value);
-		}
-
-		// 兜底：逐个采样找那个有效点（单点信号的采样数组必然很短）。
-		const std::size_t count = std::min(axis.time.size(), signal.values.size());
-		for (std::size_t index = 0; index < count; ++index)
-		{
-			if (std::isfinite(signal.values[index]) && std::isfinite(axis.time[index]))
-			{
-				time = axis.time[index];
-				value = signal.values[index];
-				return true;
-			}
-		}
-		return false;
-	}
-
-	void PlotView::DisableCursor()
-	{
-		Tab().CursorMode() = PlotCursorMode::NONE;
-		m_cursorHover = false;
-		m_hoverCursor = 0;
-		if (m_editTarget == PlotEditTarget::CURSOR_TIME || m_editTarget == PlotEditTarget::CURSOR_SPAN)
-		{
-			EndEdit(false);
-		}
-		if (m_dragMode == PlotDragMode::CURSOR_MOVE || m_dragMode == PlotDragMode::CURSOR_SPAN_MOVE)
-		{
-			m_dragMode = PlotDragMode::NONE;
-		}
-	}
-
-	bool PlotView::CycleCursorMode()
-	{
-		// 三态循环：无 → 单光标 → 双光标 → 无。光标模式本身不显示提示。
-		switch (Tab().CursorMode())
-		{
-		case PlotCursorMode::NONE:
-		{
-			Tab().CursorMode() = PlotCursorMode::SINGLE;
-			// 首次启用时置于视图中心，随后可用鼠标靠近拖拽或双击指定精确时间。
-			const double center = (Tab().ViewMin() + Tab().ViewMax()) * 0.5;
-			Tab().CursorTime() = center;
-			Tab().CursorTimeAlt() = center;
-			m_cursorHover = true;
-			m_hoverCursor = 1;
-			m_activeCursor = 1;
-			break;
-		}
-		case PlotCursorMode::SINGLE:
-		{
-			Tab().CursorMode() = PlotCursorMode::DOUBLE;
-			// 光标 2 首次出现：紧邻光标 1 且必须落在当前可见时间范围内，
-			// 这样无需额外操作就能立即看到两个光标的对比读数。
-			const double low = Tab().ViewMin();
-			const double high = Tab().ViewMax();
-			const double span = (high > low) ? (high - low) : 1.0;
-			const double offset = span * 0.12;
-			double second = Tab().CursorTime() + offset;
-			if (second > high - span * 0.02)
-			{
-				second = Tab().CursorTime() - offset;
-			}
-			if (second < low + span * 0.02 || second > high - span * 0.02)
-			{
-				second = low + span * 0.5;
-			}
-			Tab().CursorTimeAlt() = second;
-			ClampCursorToView(2);
-			m_cursorHover = true;
-			m_hoverCursor = 2;
-			m_activeCursor = 2;
-			break;
-		}
-		case PlotCursorMode::DOUBLE:
-		default:
-			DisableCursor();
-			break;
-		}
-		return true;
-	}
-
-	void PlotView::SetHint(const std::wstring& text)
-	{
-		m_hintText = text;
-		m_hintSticky = false;
-		m_hintShownAt = (text.empty()) ? 0 : GetTickCount64();
-	}
-
-	void PlotView::SetHintSticky(const std::wstring& text)
-	{
-		m_hintText = text;
-		m_hintSticky = !text.empty();
-		m_hintShownAt = (text.empty()) ? 0 : GetTickCount64();
-	}
-
-	void PlotView::ReleaseHint()
-	{
-		// 粘滞结束：从这里开始重新计时（先停留再淡出）。
-		m_hintSticky = false;
-		if (!m_hintText.empty())
-		{
-			m_hintShownAt = GetTickCount64();
-		}
-	}
-
-	bool PlotView::HintNeedsAnimation() const
-	{
-		if (m_hintText.empty() || m_hintShownAt == 0)
-		{
-			return false;
-		}
-		if (m_hintSticky)
-		{
-			return true;
-		}
-		const std::uint64_t elapsed = GetTickCount64() - m_hintShownAt;
-		return elapsed < (kHintHoldMs + kHintFadeMs);
-	}
-
-	double PlotView::CursorSpan() const
-	{
-		if (m_tab == nullptr || Tab().CursorMode() != PlotCursorMode::DOUBLE)
-		{
-			return 0.0;
-		}
-		return std::fabs(Tab().CursorTimeAlt() - Tab().CursorTime());
-	}
-
-	void PlotView::ClampCursorToView(int which)
-	{
-		if (m_tab == nullptr || m_plotRect.Width <= 0.0f)
-		{
-			return;
-		}
-		const double low = Tab().ViewMin();
-		const double high = Tab().ViewMax();
-		if (!(high > low))
-		{
-			return;
-		}
-		// 只在拖拽时夹取；留一点内缩，保证光标线及把手完整可见。
-		// ⚠️ 视图变化（平移 / 缩放 / 自适应 / 滚轮 / 方向键）**不**调用本函数：光标是一个固定的
-		// **时间位置**，视界移动时它必须留在原处（可以滑出可视区，此时读数贴在网格边缘显示）。
-		const double inset = (high - low) * 0.002;
-		if (which == 2)
-		{
-			Tab().CursorTimeAlt() = ClampDouble(Tab().CursorTimeAlt(), low + inset, high - inset);
-		}
-		else
-		{
-			Tab().CursorTime() = ClampDouble(Tab().CursorTime(), low + inset, high - inset);
-		}
-	}
-
-	std::uint32_t PlotView::CursorColor() const
-	{
-		// 两条光标统一使用同一样式与颜色，不按序号区分配色。
-		if (m_theme == nullptr)
-		{
-			return 0xFF000000u;
-		}
-		return m_theme->cursor;
-	}
-
-	bool PlotView::CancelDrag(bool showHint)
-	{
-		if (m_dragMode == PlotDragMode::NONE)
-		{
-			return false;
-		}
-
-		// 放弃当前拖拽：清空拖拽状态与尚未生效的缩放选区，不改动任何视图范围。
-		// 调用方仍持有鼠标捕获，松开左键时会走 OnLButtonUp，
-		// 此时拖拽模式已是 NONE，选区不会被应用到时间轴/幅值轴上。
-		const bool wasRubber = (m_dragMode == PlotDragMode::RUBBER_SELECT);
-		m_dragMode = PlotDragMode::NONE;
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-		m_dragLane = -1;
-		m_dragMoved = false;
-		m_rubberRect = gd::RectF();
-		m_dragSignal = SignalRef();
-		m_dragTargetLane = -1;
-		if (showHint && wasRubber)
-		{
-			SetHint(L"已放弃当前选区（右键放弃选区，Esc 退出选区放大）");
-		}
-		return true;
-	}
-
-	bool PlotView::ExitZoomModes()
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-
-		// 退出缩放模式：工具栏的「选区放大」按钮会在 Application::Render 中同步为未选中态。
-		if (Tab().ZoomMode() == PlotZoomMode::NONE)
-		{
-			return false;
-		}
-		Tab().ZoomMode() = PlotZoomMode::NONE;
-		SetHint(std::wstring());
-		return true;
-	}
-
-	void PlotView::InvalidateDerivedCaches()
-	{
-		// 后台线程可能在读取采样数据：先暂停并作废异步结果，再清同步缓存。
-		PauseDerivedAsync();
-		m_polylineCache.clear();
-		// 数据层结构变化后边沿统计与均值滤波曲线的派生结果都会失效。
-		m_edgeScans.clear();
-		m_edgeScanBudget = 0;
-		m_meanCurveCache.clear();
-		m_weakPeakCurveCache.clear();
-		// 信号下标可能已经整体位移：清掉按引用缓存的悬停/拖拽目标，避免指向错误的信号。
-		m_hoverSignal = SignalRef();
-		m_hoverLegend = SignalRef();
-		m_dragSignal = SignalRef();
-		m_dragTargetLane = -1;
-		InvalidateSceneCache();
-	}
-
-	void PlotView::PauseDerivedAsync()
-	{
-		// 等待在算任务结束（先发取消），然后清空队列与缓存，并自增代次使任何迟到结果作废。
-		StopCurveWorker();
-		std::lock_guard<std::mutex> lock(m_curveMutex);
-		++m_curveGeneration;
-		m_curveJobs.clear();
-		m_curveEntries.clear();
-		m_curvePins.clear();
-		m_curveLatest.clear();
-		m_curveHugeActive = 0;
-		m_curveSceneDirty.store(false, std::memory_order_relaxed);
-		m_curveCancelAll.store(false, std::memory_order_relaxed);	// 恢复：下次需要时可以重新开始
-	}
-
-	bool PlotView::AnyDerivedPreviewEnabled() const
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		for (const Lane& lane : m_tab->Lanes())
-		{
-			if (lane.weakPeak || lane.meanFilter || lane.edgeCenter)
-			{
-				return true;
-			}
-		}
-		return false;
-	}
-
-	void PlotView::TrimDerivedCurveDataIfIdle()
-	{
-		if (AnyDerivedPreviewEnabled())
-		{
-			return;		// 还有网格在用预览曲线：缓存仍然有用，不能清
-		}
-		// 停掉后台线程池：这会让各线程的 `thread_local` 工作缓冲**析构并归还内存** ——
-		// 这是"关掉预览后内存不下降"的根因（thread_local 只在线程退出时释放）。
-		PauseDerivedAsync();
-		m_meanCurveCache.clear();
-		m_weakPeakCurveCache.clear();
-	}
-
-	bool PlotView::FitTimeToLane(int laneIndex)
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-
-		const std::vector<Lane>& lanes = m_tab->Lanes();
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(lanes.size()))
-		{
-			return false;
-		}
-
-		double low = std::numeric_limits<double>::infinity();
-		double high = -std::numeric_limits<double>::infinity();
-		for (const SignalRef& ref : lanes[static_cast<std::size_t>(laneIndex)].signals)
-		{
-			const TimeAxis* axis = m_dataSet->Axis(ref);
-			if (axis == nullptr || axis->finiteCount == 0)
-			{
-				continue;
-			}
-			low = std::min(low, axis->minTime);
-			high = std::max(high, axis->maxTime);
-		}
-
-		if (!std::isfinite(low) || !std::isfinite(high) || !(high > low))
-		{
-			return false;
-		}
-
-		SetTimeView(low, high);
-		Tab().ViewInitialized() = true;
-		// 与“适应视图”保持一致：退出选区放大模式，避免模式按钮与实际状态不符。
-		Tab().ZoomMode() = PlotZoomMode::NONE;
-		m_rubberRect = gd::RectF();
-		m_dragMode = PlotDragMode::NONE;
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-
-		// 针对本网格信号范围展开时间轴后，同时把该网格的 Y 轴自适应一次，
-		// 否则展开后会看到“时间对了但幅值区间不合适”的波形。
-		AutoRangeLaneToView(laneIndex);
-
-		// 其它开启了「选区 Y 轴自适应」的网格同样要跟新的时间视图重新匹配：
-		// 时间视图变了，只让被展开的那个网格合适、其余网格停留在旧幅值区间并不符合预期。
-		ApplySelectionAutoFit();
-
-		// 注意：不在这里移动光标——光标允许滞留在网格可视区域之外。
-		BuildLaneVisuals();
-		return true;
-	}
-
 	bool PlotView::SplitLane(int laneIndex)
 	{
 		if (m_tab == nullptr)
@@ -2131,74 +480,6 @@ namespace jdi
 		return std::max(1, static_cast<int>(std::llround(cells)));
 	}
 
-	bool PlotView::SignalSnapEnabled(const TimeAxis& axis, const SignalData& signal,
-	                                 double timeShift) const
-	{
-		const int cells = GridMinorCellCount();
-		if (cells <= 0 || signal.finiteCount == 0)
-		{
-			return false;
-		}
-		const std::size_t threshold =
-		    static_cast<std::size_t>(cells) * static_cast<std::size_t>(kSnapVisibleCellsPerPoint);
-		if (threshold == 0)
-		{
-			return false;
-		}
-
-		const std::size_t count = std::min(axis.time.size(), signal.values.size());
-		if (count == 0)
-		{
-			return false;
-		}
-		std::size_t begin = 0;
-		std::size_t end = 0;
-		VisibleIndexRange(axis, count, begin, end, timeShift);
-		if (end <= begin)
-		{
-			return false;
-		}
-
-		// ⚠️ 视界内**至少要有一个可见数据点**：一个数据点都不在屏幕上的信号既没有可吸附的
-		//    对象、也没有可提示的内容。少了这一条，“数据点全都落在视界之外”的信号会被判成
-		//    “稀疏”（0 < N×4）而被自动切成「点线」，属于无意义的状态抖动。
-		if (signal.finiteCount < threshold)
-		{
-			// 有效点总数本来就不足阈值 ⇒ 只需确认视界内确实有点（稀疏点已缓存时二分判定）。
-			return HasVisibleSample(axis, signal, begin, end, timeShift);
-		}
-
-		// 一般信号：统计**当前视界内**的有效点数量（攒够阈值立刻早退，代价有界）。
-		// 连续 NaN 不计入有效点，因此再给一个**有界**的扫描窗口，防止极端情况下长循环。
-		const std::size_t window =
-		    std::min(std::min(end, signal.values.size()), begin + threshold * kSnapScanWindowFactor + 8u);
-		std::size_t seen = 0;
-		for (std::size_t index = begin; index < window; ++index)
-		{
-			if (!std::isfinite(signal.values[index]))
-			{
-				continue;
-			}
-			// ⚠️ 必须按**绘制时刻**判断可见性（`t + offsetTime`），否则存在时间轴偏移时
-			//    会把“已经移出视界”的采样点算进来（用户报告吸附到历史位置）。
-			const double time = axis.time[index];
-			if (!std::isfinite(time))
-			{
-				continue;
-			}
-			const double displayTime = time + timeShift;
-			if (displayTime < Tab().ViewMin() || displayTime > Tab().ViewMax())
-			{
-				continue;
-			}
-			if (++seen >= threshold)
-			{
-				return false;		// 一屏内的数据点已经足够密：保持自由移动
-			}
-		}
-		return seen > 0;
-	}
-
 	bool PlotView::HasVisibleSample(const TimeAxis& axis, const SignalData& signal, std::size_t begin,
 	                                std::size_t end, double timeShift) const
 	{
@@ -2227,96 +508,6 @@ namespace jdi
 		return false;
 	}
 
-	bool PlotView::NearestSnapSample(const TimeAxis& axis, const SignalData& signal, double time,
-	                                 double timeShift, double& candidate) const
-	{
-		// ⚠️ `time` / `candidate` 都是**显示时间**（画面上的时刻）：采样点 k 画在 `time[k] + timeShift`
-		//    处，而光标存的也是显示时间，因此查找与可见性判定都要整体平移（否则存在
-		//    「调整 → 时间轴偏移」时吸附会落在历史位置上，用户 2026-10-15 报告）。
-		const double viewMin = Tab().ViewMin() - timeShift;
-		const double viewMax = Tab().ViewMax() - timeShift;
-
-		// 稀疏信号：有效点已在加载时缓存（按时间升序）⇒ 二分取最近的一个。
-		if (!signal.sparseTimes.empty())
-		{
-			const std::vector<double>& times = signal.sparseTimes;
-			const double target = time - timeShift;
-			const std::vector<double>::const_iterator it = std::lower_bound(times.begin(), times.end(), target);
-			bool found = false;
-			double bestDistance = std::numeric_limits<double>::infinity();
-			for (int side = 0; side < 2; ++side)
-			{
-				// side 0 = 第一个 >= target 的点；side 1 = 它前面的那个点。
-				if (side == 1 && it == times.begin())
-				{
-					continue;
-				}
-				const std::vector<double>::const_iterator pick = (side == 0) ? it : (it - 1);
-				if (pick == times.end())
-				{
-					continue;
-				}
-				const double value = *pick;
-				if (!std::isfinite(value) || value < viewMin || value > viewMax)
-				{
-					continue;
-				}
-				const double distance = std::fabs((value + timeShift) - time);
-				if (distance < bestDistance)
-				{
-					bestDistance = distance;
-					candidate = value + timeShift;
-					found = true;
-				}
-			}
-			return found;
-		}
-
-		// 一般信号：取下标最近的采样点；它若无效（NaN）则向两侧**有界**探测
-		//（NaN 只出现在缺少数据的区段，通常几步内就能找到有效点；找不到就不吸附）。
-		const std::size_t count = std::min(axis.time.size(), signal.values.size());
-		if (count == 0)
-		{
-			return false;
-		}
-		const int center = FindNearestSample(axis, time - timeShift);
-		if (center < 0)
-		{
-			return false;
-		}
-		const int lastIndex = static_cast<int>(count) - 1;
-		for (int step = 0; step <= kSnapSampleProbeSteps; ++step)
-		{
-			for (int direction = 0; direction < 2; ++direction)
-			{
-				if (step == 0 && direction == 1)
-				{
-					continue;		// 中心点只查一次
-				}
-				const int probe = (direction == 0) ? (center - step) : (center + step);
-				if (probe < 0 || probe > lastIndex)
-				{
-					continue;
-				}
-				const double value = signal.values[static_cast<std::size_t>(probe)];
-				const double sampleTime = axis.time[static_cast<std::size_t>(probe)];
-				if (!std::isfinite(value) || !std::isfinite(sampleTime))
-				{
-					continue;
-				}
-				// 只接受**可见区间内**的采样点（按绘制时刻判断）：视界之外的采样点不是合法落点
-				//（否则吸附会把光标一把甩到视界边缘并钉住）。
-				if (sampleTime < viewMin || sampleTime > viewMax)
-				{
-					continue;
-				}
-				candidate = sampleTime + timeShift;
-				return true;
-			}
-		}
-		return false;
-	}
-
 	void PlotView::LocalSampleSpacing(const TimeAxis& axis, const SignalData& signal, double time,
 	                                  double timeShift, double& spacing) const
 	{
@@ -2379,278 +570,6 @@ namespace jdi
 		}
 	}
 
-	bool PlotView::SnapTimeToSample(double time, double& snapped) const
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-
-		// 吸附判定**只针对鼠标所在的网格**（用户明确要求）：
-		// 一个网格内的数据已达“稀疏”标准、另一个没有时，光标只在前者上吸附，
-		// 在后者上仍然完全自由移动。
-		const int laneIndex = LaneAtY(m_mouseY);
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-
-		const int cells = GridMinorCellCount();
-		const double plotWidth = static_cast<double>(m_plotRect.Width);
-		const double viewSpan = Tab().ViewMax() - Tab().ViewMin();
-		if (cells <= 0 || plotWidth <= 1.0 || !(viewSpan > 0.0))
-		{
-			return false;
-		}
-		// 吸附半径 = **一个网格小格的宽度**（与判定用同一套网格定义推出），
-		// 且**不超过半个采样间距** —— 后者保证数据点很稀疏时（一屏只有一两个点）
-		// 光标在点与点之间仍可自由移动，而不是被“死死吸住”
-		//（用户明确要求：吸附只是提示性响应）。
-		const double radiusPixels = kSnapRadiusCells * plotWidth / static_cast<double>(cells);
-		const double radiusTime = radiusPixels / plotWidth * viewSpan;
-
-		bool found = false;
-		double bestDistance = std::numeric_limits<double>::infinity();
-		double bestTime = 0.0;
-
-		// 同一个网格内可能存在多条信号：**所有**符合吸附判定的数据点都参与吸附。
-		for (const SignalRef& ref : m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals)
-		{
-			if (!m_tab->IsVisible(ref))
-			{
-				continue;
-			}
-			const SignalData* signal = m_dataSet->Resolve(ref);
-			const TimeAxis* axis = m_dataSet->Axis(ref);
-			const SignalStyle* style = m_dataSet->Style(ref);
-			if (signal == nullptr || axis == nullptr)
-			{
-				continue;
-			}
-			// ⚠️ 一切吸附判定与查找都在**显示时间**空间进行：采样点 k 画在
-			//    `time[k] + offsetTime` 处，而光标存的也是显示时间。
-			//    少了这一步，信号一旦设置过「调整 → 时间轴偏移」，吸附就会落在**历史位置**
-			//    （用户 2026-10-15 报告“存在时间轴偏移调整时无法吸附到正确位置”）。
-			const double timeShift = (style != nullptr) ? style->offsetTime : 0.0;
-			// 只有“一屏内数据点少于 N×4”的信号参与吸附；判据随视界实时重算，
-			// 因此疏密变化的信号在稀疏区自动吸附、移到稠密区自动恢复自由移动。
-			if (!SignalSnapEnabled(*axis, *signal, timeShift))
-			{
-				continue;
-			}
-			double candidate = 0.0;
-			if (!NearestSnapSample(*axis, *signal, time, timeShift, candidate))
-			{
-				continue;
-			}
-
-			// 吸附半径再受“半个局部采样间距”限制（点很稀疏时不被吸死）。
-			double limitTime = radiusTime;
-			double spacingTime = 0.0;
-			LocalSampleSpacing(*axis, *signal, candidate, timeShift, spacingTime);
-			if (spacingTime > 0.0)
-			{
-				limitTime = std::min(limitTime, spacingTime * 0.5);
-			}
-
-			const double distance = std::fabs(candidate - time);
-			if (distance <= limitTime && distance < bestDistance)
-			{
-				bestDistance = distance;
-				bestTime = candidate;
-				found = true;
-			}
-		}
-
-		if (found)
-		{
-			snapped = bestTime;
-		}
-		return found;
-	}
-
-	void PlotView::PlaceCursorTime(int which, double time)
-	{
-		if (!std::isfinite(time))
-		{
-			// NaN/Inf 会让后面所有比较都失效（`ClampDouble` 也拦不住 NaN），
-			// 光标会被画到画布之外：直接丢弃这次位置更新。
-			return;
-		}
-
-		double snapped = 0.0;
-		if (SnapTimeToSample(time, snapped))
-		{
-			time = snapped;
-		}
-
-		if (which == 2)
-		{
-			Tab().CursorTimeAlt() = time;
-		}
-		else
-		{
-			Tab().CursorTime() = time;
-		}
-		ClampCursorToView(which);
-	}
-
-	PlotZoomMode PlotView::CurrentZoomMode() const
-	{
-		return Tab().ZoomMode();
-	}
-
-	bool PlotView::ToggleZoomMode(PlotZoomMode mode)
-	{
-		const PlotZoomMode current = Tab().ZoomMode();
-		Tab().ZoomMode() = (current == mode) ? PlotZoomMode::NONE : mode;
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-		m_rubberRect = gd::RectF();
-		SetHint(Tab().ZoomMode() == PlotZoomMode::NONE
-		            ? std::wstring()
-		            : L"横向或纵向拖动以放大选择区域，ESC退出选区模式");
-		return true;
-	}
-
-	float PlotView::CursorX(int which) const
-	{
-		const double time = (which == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
-		return TimeToX(time);
-	}
-
-	float PlotView::CursorDisplayX(int which) const
-	{
-		// 光标允许滞留在可视区之外：此时把它"钉"在最近的网格边缘上显示，
-		// 保证它的取值与时间读数始终可见。
-		const float raw = CursorX(which);
-		return std::max(m_plotRect.X + 1.0f * m_scale,
-		                std::min(raw, m_plotRect.X + m_plotRect.Width - 1.0f * m_scale));
-	}
-
-	gd::RectF PlotView::CursorLabelRect(int which) const
-	{
-		if (m_fonts == nullptr || m_fonts->monoSmall == nullptr)
-		{
-			return gd::RectF();
-		}
-
-		// 未经叠放处理的"原始"位置：单条标签独占底部一行。
-		const auto rawRect = [this](int index) -> gd::RectF
-		{
-			const double time = (index == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
-			const std::wstring text = FormatCursorTime(time);
-			const float width =
-			    std::max(64.0f * m_scale, UiMeasureTextWidth(m_fonts->monoSmall, text) + 16.0f * m_scale);
-			const float height = 20.0f * m_scale;
-
-			// 时间读数改到绘图区**底部**：顶部留给网格图例与幅值标尺，避免互相遮挡。
-			float left = CursorDisplayX(index) - width * 0.5f;
-			left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
-
-			// 光标滞留在视界之外时，胶囊外侧还要放一个方向三角（与网格内数据点越界同一套画法）：
-			// 把胶囊整体**向内**让出三角 + 间隙的宽度，否则贴边时三角没有落脚之处、
-			// 只能压在胶囊上（用户报告的"没有间隔、样式不统一"）。
-			bool offRight = false;
-			if (CursorOffViewSide(index, offRight))
-			{
-				const float reserved = (kMarkerTriangleDepth + kMarkerTriangleGap) * m_scale;
-				left = offRight ? (left - reserved) : (left + reserved);
-				left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
-			}
-
-			const float top = m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale;
-
-			return gd::RectF(left, top, width, height);
-		};
-
-		gd::RectF rect = rawRect(which);
-
-		// 双光标靠得很近时，两条时间读数标签会互相覆盖：把它们分两行叠放。
-		// **小值在上、大值在下**（用户明确要求）——按时间值决定行序，
-		// 而不是固定让光标 2 上移。左/右光标被拖动交换后排序依然正确。
-		if (Tab().CursorMode() == PlotCursorMode::DOUBLE)
-		{
-			const gd::RectF first = rawRect(1);
-			const gd::RectF second = rawRect(2);
-			// 方向三角已移到胶囊**外侧**，胶囊之间不再需要额外留白。
-			const float gap = 2.0f * m_scale;
-			const bool overlapX = (first.X < second.X + second.Width + gap) &&
-			                      (second.X < first.X + first.Width + gap);
-			if (overlapX)
-			{
-				const bool firstIsSmaller = (Tab().CursorTime() <= Tab().CursorTimeAlt());
-				// which == 1 是否属于"小值"。
-				const bool whichIsSmaller = (which == 1) ? firstIsSmaller : !firstIsSmaller;
-				const float bottomRow = rawRect(1).Y;
-				const float topRow = std::max(m_plotRect.Y + 2.0f * m_scale,
-				                              bottomRow - rect.Height - gap);
-				rect.Y = whichIsSmaller ? topRow : bottomRow;
-			}
-		}
-
-		return rect;
-	}
-
-	bool PlotView::IsOnCursorLine(int x, int& which) const
-	{
-		which = 0;
-		if (!Tab().CursorEnabled() || m_plotRect.Width <= 0.0f)
-		{
-			return false;
-		}
-
-		const float tolerance = 6.0f * m_scale;
-		const float fx = static_cast<float>(x);
-
-		// 双光标重叠时优先命中光标 1，避免出现“抓不起来第二条”的情况。
-		// 使用"显示横坐标"：滞留在可视区外的光标被钉在边缘，也应该可以被抓住拖回来。
-		if (std::fabs(fx - CursorDisplayX(1)) <= tolerance)
-		{
-			which = 1;
-			return true;
-		}
-		if (Tab().CursorMode() == PlotCursorMode::DOUBLE && std::fabs(fx - CursorDisplayX(2)) <= tolerance)
-		{
-			which = 2;
-			return true;
-		}
-		return false;
-	}
-
-	bool PlotView::IsOnCursorTimeLabel(int x, int y, int& which) const
-	{
-		which = 0;
-		if (!Tab().CursorEnabled())
-		{
-			return false;
-		}
-
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-
-		// 双光标重叠时优先命中光标 1（与光标线的命中顺序一致）。
-		const int count = (Tab().CursorMode() == PlotCursorMode::DOUBLE) ? 2 : 1;
-		for (int index = 1; index <= count; ++index)
-		{
-			const gd::RectF rect = CursorLabelRect(index);
-			if (rect.Width > 0.0f && UiPointInRect(rect, fx, fy))
-			{
-				which = index;
-				return true;
-			}
-		}
-		return false;
-	}
-
-	bool PlotView::IsOnCursorSpanLabel(int x, int y) const
-	{
-		if (Tab().CursorMode() != PlotCursorMode::DOUBLE || m_cursorSpanRect.Width <= 0.0f)
-		{
-			return false;
-		}
-		return UiPointInRect(m_cursorSpanRect, static_cast<float>(x), static_cast<float>(y));
-	}
-
 	bool PlotView::ApplyTimeSelection(float x0, float x1)
 	{
 		if (m_plotRect.Width <= 0.0f)
@@ -2728,655 +647,6 @@ namespace jdi
 		return true;
 	}
 
-	int PlotView::LaneIndexAt(int x, int y) const
-	{
-		if (!UiPointInRect(m_plotRect, static_cast<float>(x), static_cast<float>(y)))
-		{
-			return -1;
-		}
-		return LaneAtY(y);
-	}
-
-	bool PlotView::LaneAutoFitToSelection(int laneIndex) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].fitYToSelection;
-	}
-
-	bool PlotView::AllLanesAutoFitToSelection() const
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		const std::vector<Lane>& lanes = m_tab->Lanes();
-		if (lanes.empty())
-		{
-			return false;
-		}
-		for (const Lane& lane : lanes)
-		{
-			if (!lane.fitYToSelection)
-			{
-				// 任一网格未开启 → 全局项就不是勾选状态。
-				return false;
-			}
-		}
-		return true;
-	}
-
-	bool PlotView::LaneEdgeCount(int laneIndex) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].edgeCount;
-	}
-
-	bool PlotView::SetLaneEdgeCount(int laneIndex, bool enabled)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.edgeCount == enabled)
-		{
-			return false;
-		}
-		lane.edgeCount = enabled;
-		if (enabled)
-		{
-			// 首次开启：把横向光标放到可见幅值范围的中点，并让面板重新展开。
-			if (!lane.edgeValueValid)
-			{
-				double yMin = 0.0;
-				double yMax = 1.0;
-				LaneRange(laneIndex, yMin, yMax);
-				lane.edgeValue = (yMin + yMax) * 0.5;
-				lane.edgeValueValid = true;
-			}
-			lane.edgePanelOpen = true;
-		}
-		else
-		{
-			lane.edgePanelOpen = false;
-		}
-		return true;
-	}
-
-	bool PlotView::ToggleLaneEdgeCount(int laneIndex)
-	{
-		const bool enabled = !LaneEdgeCount(laneIndex);
-		SetLaneEdgeCount(laneIndex, enabled);
-		return enabled;
-	}
-
-	bool PlotView::LaneEdgeCenterCount(int laneIndex) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].edgeCenter;
-	}
-
-	bool PlotView::SetLaneEdgeCenterCount(int laneIndex, bool enabled)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.edgeCenter == enabled)
-		{
-			return false;
-		}
-		lane.edgeCenter = enabled;
-		if (enabled)
-		{
-			// 与「均值滤波」完全一致：默认只勾选网格内**第一个可见信号**。
-			if (lane.edgeCenterItems.empty())
-			{
-				for (const SignalRef& ref : lane.signals)
-				{
-					const ResolvedSignal resolved = ResolveSignal(ref);
-					if (resolved.data != nullptr && resolved.visible)
-					{
-						lane.EnsureEdgeCenterItem(ref);
-						break;
-					}
-				}
-			}
-			lane.edgeCenterPanelOpen = true;
-		}
-		else
-		{
-			lane.edgeCenterPanelOpen = false;
-		}
-		// 关闭后若本标签页**已无任何预览曲线功能**，立即释放派生曲线数据（缓存 + 后台线程的
-		// thread_local 工作缓冲）—— 否则关掉面板后内存不会下降（用户报告）。
-		if (!enabled)
-		{
-			TrimDerivedCurveDataIfIdle();
-		}
-		// 预建「宽缓冲基底」，避免首次拖动参数滑块时的一次性重建尖峰。
-		RebuildWideBuffer();
-		return true;
-	}
-
-	bool PlotView::ToggleLaneEdgeCenterCount(int laneIndex)
-	{
-		const bool enabled = !LaneEdgeCenterCount(laneIndex);
-		SetLaneEdgeCenterCount(laneIndex, enabled);
-		return enabled;
-	}
-
-	bool PlotView::ToggleLaneEdgeCenterSignal(int laneIndex, const SignalRef& ref)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.EdgeCenterEnabled(ref))
-		{
-			lane.RemoveEdgeCenterItem(ref);
-			return false;
-		}
-		lane.EnsureEdgeCenterItem(ref);
-		return true;
-	}
-
-	bool PlotView::LaneEdgeCenterSignalEnabled(int laneIndex, const SignalRef& ref) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].EdgeCenterEnabled(ref);
-	}
-
-	bool PlotView::LaneMeanFilter(int laneIndex) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].meanFilter;
-	}
-
-	bool PlotView::LaneWeakPeak(int laneIndex) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].weakPeak;
-	}
-
-	bool PlotView::SetLaneWeakPeak(int laneIndex, bool enabled)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.weakPeak == enabled)
-		{
-			return false;
-		}
-		lane.weakPeak = enabled;
-		if (enabled)
-		{
-			// 与「均值滤波」完全一致：默认只勾选网格内**第一个可见信号**。
-			if (lane.weakPeakItems.empty())
-			{
-				for (const SignalRef& ref : lane.signals)
-				{
-					const ResolvedSignal resolved = ResolveSignal(ref);
-					if (resolved.data != nullptr && resolved.visible)
-					{
-						lane.EnsureWeakPeakItem(ref);
-						break;
-					}
-				}
-			}
-			lane.weakPeakPanelOpen = true;
-		}
-		else
-		{
-			lane.weakPeakPanelOpen = false;
-		}
-		// 关闭后若本标签页**已无任何预览曲线功能**，立即释放派生曲线数据（缓存 + 后台线程的
-		// thread_local 工作缓冲）—— 否则关掉面板后内存不会下降（用户报告）。
-		if (!enabled)
-		{
-			TrimDerivedCurveDataIfIdle();
-		}
-		// 预建「宽缓冲基底」（不含派生曲线），使用户首次拖动该滑块时无需从零重建（避免一次性尖峰）。
-		RebuildWideBuffer();
-		return true;
-	}
-
-	bool PlotView::ToggleLaneWeakPeak(int laneIndex)
-	{
-		const bool enabled = !LaneWeakPeak(laneIndex);
-		SetLaneWeakPeak(laneIndex, enabled);
-		return enabled;
-	}
-
-	bool PlotView::ToggleLaneWeakPeakSignal(int laneIndex, const SignalRef& ref)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.WeakPeakEnabled(ref))
-		{
-			lane.RemoveWeakPeakItem(ref);
-			return false;
-		}
-		lane.EnsureWeakPeakItem(ref);
-		return true;
-	}
-
-	bool PlotView::LaneWeakPeakSignalEnabled(int laneIndex, const SignalRef& ref) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].WeakPeakEnabled(ref);
-	}
-
-	bool PlotView::TakePendingWeakPeakBuild(int& laneIndex, std::vector<WeakPeakBuild>& items)
-	{
-		if (m_pendingWeakPeakLane < 0)
-		{
-			return false;
-		}
-		laneIndex = m_pendingWeakPeakLane;
-		items = m_pendingWeakPeakItems;
-		m_pendingWeakPeakLane = -1;
-		m_pendingWeakPeakItems.clear();
-		return true;
-	}
-
-	bool PlotView::SetLaneMeanFilter(int laneIndex, bool enabled)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.meanFilter == enabled)
-		{
-			return false;
-		}
-		lane.meanFilter = enabled;
-		if (enabled)
-		{
-			// 默认只勾选网格内**第一个可见信号**（用户明确要求），其余保持未勾选。
-			if (lane.meanFilterItems.empty())
-			{
-				for (const SignalRef& ref : lane.signals)
-				{
-					const ResolvedSignal resolved = ResolveSignal(ref);
-					if (resolved.data != nullptr && resolved.visible)
-					{
-						lane.EnsureMeanFilterItem(ref);
-						break;
-					}
-				}
-			}
-			lane.meanFilterPanelOpen = true;
-		}
-		else
-		{
-			lane.meanFilterPanelOpen = false;
-		}
-		// 关闭后若本标签页**已无任何预览曲线功能**，立即释放派生曲线数据（缓存 + 后台线程的
-		// thread_local 工作缓冲）—— 否则关掉面板后内存不会下降（用户报告）。
-		if (!enabled)
-		{
-			TrimDerivedCurveDataIfIdle();
-		}
-		// 预建「宽缓冲基底」，避免首次拖动参数滑块时的一次性重建尖峰。
-		RebuildWideBuffer();
-		return true;
-	}
-
-	bool PlotView::ToggleLaneMeanFilterSignal(int laneIndex, const SignalRef& ref)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		if (lane.MeanFilterEnabled(ref))
-		{
-			lane.RemoveMeanFilterItem(ref);
-			return false;
-		}
-		lane.EnsureMeanFilterItem(ref);
-		return true;
-	}
-
-	bool PlotView::LaneMeanFilterSignalEnabled(int laneIndex, const SignalRef& ref) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].MeanFilterEnabled(ref);
-	}
-
-	bool PlotView::ToggleLaneMeanFilter(int laneIndex)
-	{
-		const bool enabled = !LaneMeanFilter(laneIndex);
-		SetLaneMeanFilter(laneIndex, enabled);
-		return enabled;
-	}
-
-	bool PlotView::TakePendingMeanFilterBuild(int& laneIndex, std::vector<MeanFilterBuild>& items)
-	{
-		if (m_pendingMeanFilterLane < 0)
-		{
-			return false;
-		}
-		laneIndex = m_pendingMeanFilterLane;
-		items = m_pendingMeanFilterItems;
-		m_pendingMeanFilterLane = -1;
-		m_pendingMeanFilterItems.clear();
-		return true;
-	}
-
-	bool PlotView::MeanFilterValueAt(const TimeAxis& axis, const SignalData& signal, int points, int iterations,
-	                                 double time, double& value) const
-	{
-		const int index = FindNearestSample(axis, time);
-		if (index < 0)
-		{
-			return false;
-		}
-		// ⚠️ **绝不能调用整条同步的 `MeanFilterCurveFor`**：光标读数在绘制路径上被调用，
-		//    整条曲线（千万级采样）同步计算会让界面停顿数秒（用户报告"程序被卡住很久"）。
-		//    这里只取「需要的那一个下标 ± 保护带」的窗口，并在窗口很大时走后台异步计算
-		//    （本帧取不到就返回 false，读数暂时不显示该曲线的取值）。
-		std::size_t spanBegin = 0;
-		const std::vector<float>* curve = CurveSpanFor(
-		    DerivedCurveKind::MEAN_FILTER, signal, points, iterations, 0,
-		    static_cast<std::size_t>(index), static_cast<std::size_t>(index) + 1, spanBegin, true);
-		if (curve == nullptr || static_cast<std::size_t>(index) < spanBegin ||
-		    (static_cast<std::size_t>(index) - spanBegin) >= curve->size())
-		{
-			return false;
-		}
-		const float sampled = (*curve)[static_cast<std::size_t>(index) - spanBegin];
-		if (!std::isfinite(sampled))
-		{
-			return false;
-		}
-		value = static_cast<double>(sampled);
-		return true;
-	}
-
-	void PlotView::VisibleIndexRange(const TimeAxis& axis, std::size_t count, std::size_t& begin,
-	                                 std::size_t& end, double timeShift) const
-	{
-		begin = 0;
-		end = count;
-		if (!axis.monotonic || count == 0)
-		{
-			return;
-		}
-		// 时间偏移：采样画在 `t + timeShift` 处，因此落在当前视界内的采样其源时刻区间要整体左移。
-		const std::vector<double>& time = axis.time;
-		begin = static_cast<std::size_t>(
-		    std::lower_bound(time.begin(), time.end(), Tab().ViewMin() - timeShift) - time.begin());
-		if (begin > 0)
-		{
-			--begin;
-		}
-		end = static_cast<std::size_t>(
-		    std::lower_bound(time.begin(), time.end(), Tab().ViewMax() - timeShift) - time.begin());
-		if (end < count)
-		{
-			++end;
-		}
-		end = std::max(end, begin);
-		begin = std::min(begin, count);
-		end = std::min(end, count);
-	}
-
-	const std::vector<float>* PlotView::CurveSpanFor(DerivedCurveKind kind, const SignalData& signal,
-	                                                 int points, int iterations, int amountPercent,
-	                                                 std::size_t begin, std::size_t end,
-	                                                 std::size_t& spanBegin,
-	                                                 bool allowAsyncCompute) const
-	{
-		spanBegin = 0;
-		const std::size_t count = signal.values.size();
-		if (count == 0)
-		{
-			return nullptr;
-		}
-		begin = std::min(begin, count);
-		end = std::min(std::max(end, begin), count);
-		if (end <= begin)
-		{
-			return nullptr;
-		}
-
-		const int kindValue = static_cast<int>(kind);
-		const int safePoints = std::max(0, std::min(points, 1000000));
-		const int safeIterations = std::max(1, std::min(iterations, 1000));
-		const int safeLevel = std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, amountPercent));
-
-		// 对齐到粗网格：轻微平移/缩放时可直接复用同一条窗口，避免每帧重算。
-		const std::size_t grid = std::max<std::size_t>(4096, (end - begin) / 4);
-		const std::size_t alignedBegin = (begin / grid) * grid;
-		const std::size_t alignedEnd = std::min(count, ((end + grid - 1) / grid) * grid);
-
-		CurveKey key;
-		key.signal = &signal;
-		key.kind = kindValue;
-		key.points = safePoints;
-		key.iterations = safeIterations;
-		key.amountPercent = safeLevel;
-
-		// 1) 已有覆盖请求区间的最新条目 → 直接复用（钉住，防止本帧被回收）。
-		if (const CurveEntry* hit = AcquireCoveringCurve(key, begin, end, spanBegin))
-		{
-			return &hit->values;
-		}
-
-		// 2) 代价较大时交后台计算，本帧先用最新旧曲线顶替（双缓冲）。
-		//    这样绘制线程永远不做重计算，拖动滑块/光标/视界/缩放的反馈因此始终跟手。
-		//
-		// ⚠️ **超大信号 + 正在拖动参数：不要每帧都排一次"整条信号"的重算**。
-		//    预览曲线一律按整条信号计算（`[0, count]`，与「构建为新信号」逐位一致）；
-		//    当信号极大（`VERY_BIG_DATA` 有 2576 万采样）时，每条曲线都要扫描上亿个采样，
-		//    后台线程会被**持续占满**（实测把可用内存带宽吃光），反过来把前台绘制拖慢
-		//    （用户报告的"深放大下拖预览滑块非常非常卡"——实测前台每帧 14ms，而绘制本身只要 0.4ms）。
-		//    此时沿用旧曲线，等松手（不再处于拖拽）后再算一次最新的即可：反正整条信号的重算
-		//    本来也追不上滑块速度，拖动期间"冻结"与"每帧重排"在观感上没有区别，但后者会拖慢前台。
-		//    小信号（< `kHugeSignalPreviewSamples`）不受影响，仍保留"边拖边算"的实时预览。
-		if (count > kHugeSignalPreviewSamples && m_dragMode != PlotDragMode::NONE)
-		{
-			if (const CurveEntry* stale = AcquireNewestCurve(key, begin, end, spanBegin))
-			{
-				return &stale->values;
-			}
-			return nullptr;
-		}
-
-		// 计算窗口（含保护带）：既用于同步计算，也用于判断是否值得交后台。
-		std::size_t computedBegin = 0;
-		std::size_t computedEnd = 0;
-		DerivedGuardWindow(kind, alignedBegin, alignedEnd, safePoints, safeIterations, count,
-		                   computedBegin, computedEnd);
-		if (computedEnd <= computedBegin)
-		{
-			return nullptr;
-		}
-		const std::size_t computeSamples = computedEnd - computedBegin;
-		if (allowAsyncCompute && computeSamples > kDerivedAsyncWindowThreshold)
-		{
-			ScheduleCurveJob(key, alignedBegin, alignedEnd, count);
-			if (const CurveEntry* stale = AcquireNewestCurve(key, begin, end, spanBegin))
-			{
-				return &stale->values;
-			}
-			return nullptr;	// 尚无任何可显示曲线：本帧跳过该预览曲线（不阻塞绘制）
-		}
-
-		// 3) 代价很小或需要精确取值 → 同步计算并发布（代价可接受，且保证取值精确）。
-		//    ⚠️ 同步路径也要先做内存判断：窗口虽小，但低内存设备上仍可能失败 ——
-		//    宁可这次不画预览，也不能抛 `bad_alloc` 把进程带走。
-		{
-			bool throttle = false;		// 窗口 ≤ 门槛（65536 采样）→ 无需节流
-			if (!DerivedMemoryAllows(computeSamples, throttle))
-			{
-				return nullptr;
-			}
-		}
-		std::vector<float> values = ComputeDerivedWindow(signal, computedBegin, computedEnd, kindValue,
-		                                                 safePoints, safeIterations, safeLevel, nullptr,
-		                                                 false);
-		const CurveEntry* published =
-		    PublishCurve(key, computedBegin, computedEnd, std::move(values), spanBegin);
-		return (published != nullptr) ? &published->values : nullptr;
-	}
-
-	void PlotView::DerivedGuardWindow(DerivedCurveKind kind, std::size_t alignedBegin,
-	                                  std::size_t alignedEnd, int points, int iterations,
-	                                  std::size_t count, std::size_t& begin, std::size_t& end) const
-	{
-		// 保护带取窗口长度的 1/8（夹在 4096~65536）：弱峰调整的修正沿相邻极值向内传播，
-		// 1/8 个可见宽度足以覆盖真实信号的极值间距。
-		// 均值滤波必须额外**覆盖滤波半径**：N 阶共向外传播 X*N 个采样，否则窗口边界取值
-		// 会与「整条曲线」不同（边界上可用采样数更少）。
-		std::size_t guard =
-		    std::clamp((alignedEnd - alignedBegin) / 8, std::size_t(4096), kDerivedCurveGuardMax);
-		if (kind == DerivedCurveKind::MEAN_FILTER)
-		{
-			const std::size_t reach =
-			    static_cast<std::size_t>(points + 1) * static_cast<std::size_t>(iterations) + 64u;
-			guard = std::clamp(std::max(guard, reach), std::size_t(4096), kDerivedCurveGuardMax);
-		}
-		begin = (alignedBegin > guard) ? (alignedBegin - guard) : 0;
-		end = std::min(count, alignedEnd + guard);
-	}
-
-	const PlotView::CurveEntry* PlotView::AcquireCoveringCurve(const CurveKey& key, std::size_t begin,
-	                                                           std::size_t end,
-	                                                           std::size_t& spanBegin) const
-	{
-		std::lock_guard<std::mutex> lock(m_curveMutex);
-		const CurveEntryPtr* best = nullptr;
-		for (const CurveEntryPtr& entry : m_curveEntries)
-		{
-			if (entry->key == key && entry->begin <= begin && entry->end >= end)
-			{
-				if (best == nullptr || entry->serial > (*best)->serial)
-				{
-					best = &entry;
-				}
-			}
-		}
-		if (best == nullptr)
-		{
-			return nullptr;
-		}
-		m_curvePins.push_back(*best);	// 钉住：保证本帧内指针有效
-		spanBegin = (*best)->begin;
-		return best->get();
-	}
-
-	const PlotView::CurveEntry* PlotView::AcquireNewestCurve(const CurveKey& key, std::size_t begin,
-	                                                         std::size_t end,
-	                                                         std::size_t& spanBegin) const
-	{
-		std::lock_guard<std::mutex> lock(m_curveMutex);
-		// ⚠️ **只按「信号 + 曲线种类」匹配**（忽略参数）：拖动参数滑块时每帧参数都在变，
-		// 若要求键完全相同就永远找不到"上一帧的曲线"，于是本帧无曲线可画 → **预览曲线闪烁**、
-		// 甚至短暂消失（用户报告的"滑动滑块时曲线消失一会儿又出现"）。
-		// 旧曲线只是参数略旧，按采样下标映射位置依然完全正确，先顶上再等后台算好新曲线，
-		// 视觉上就是平滑过渡而不是闪烁。
-		//
-		// 优先挑「窗口覆盖所需区间」的：覆盖不到时曲线会缺一段（看起来像被切断）。
-		const CurveEntryPtr* newest = nullptr;
-		const CurveEntryPtr* newestCovering = nullptr;
-		for (const CurveEntryPtr& entry : m_curveEntries)
-		{
-			if (entry->key.signal != key.signal || entry->key.kind != key.kind)
-			{
-				continue;
-			}
-			if (newest == nullptr || entry->serial > (*newest)->serial)
-			{
-				newest = &entry;
-			}
-			if (entry->begin <= begin && entry->end >= end &&
-			    (newestCovering == nullptr || entry->serial > (*newestCovering)->serial))
-			{
-				newestCovering = &entry;
-			}
-		}
-		const CurveEntryPtr* pick = (newestCovering != nullptr) ? newestCovering : newest;
-		if (pick == nullptr)
-		{
-			return nullptr;
-		}
-		m_curvePins.push_back(*pick);
-		spanBegin = (*pick)->begin;
-		return pick->get();
-	}
-
-	const PlotView::CurveEntry* PlotView::PublishCurve(const CurveKey& key, std::size_t begin,
-	                                                   std::size_t end, std::vector<float>&& values,
-	                                                   std::size_t& spanBegin) const
-	{
-		std::shared_ptr<CurveEntry> entry = std::make_shared<CurveEntry>();
-		entry->key = key;
-		entry->begin = begin;
-		entry->end = end;
-		entry->values = std::move(values);
-		{
-			std::lock_guard<std::mutex> lock(m_curveMutex);
-			entry->serial = ++m_curveSerial;
-			m_curveEntries.push_back(entry);
-		}
-		m_curvePins.push_back(entry);
-		spanBegin = begin;
-		return entry.get();
-	}
-
-	bool PlotView::CurveJobIsStale(const CurveKey& key, std::uint64_t requestSerial) const
-	{
-		std::lock_guard<std::mutex> lock(m_curveMutex);
-		const auto found = m_curveLatest.find(std::make_pair(key.signal, key.kind));
-		if (found == m_curveLatest.end())
-		{
-			return true;		// 已经被清理（例如预览被关闭）→ 没有意义，直接作废
-		}
-		return found->second != requestSerial;
-	}
-
-	std::size_t PlotView::DerivedMinimumBytes(std::size_t samples)
-	{
-		// 输出曲线本体（float，占 1 份）+ 内部工作缓冲（「弱峰调整」实测 ≈34 B/采样，
-		// 含两个 float 工作缓冲与极值表）——取 48 B/采样作为「连一条曲线都装不下」的门槛。
-		return samples * 48u + (64u * 1024u * 1024u);
-	}
-
 	std::size_t PlotView::AvailablePhysicalBytes()
 	{
 		// ⚠️ 结果按 200ms 缓存：本函数在绘制路径上每次请求曲线都会调用，
@@ -3405,1389 +675,6 @@ namespace jdi
 		return available;
 	}
 
-	bool PlotView::DerivedMemoryAllows(std::size_t samples, bool& throttle) const
-	{
-		throttle = false;
-		const std::size_t minimum = DerivedMinimumBytes(samples);
-		const std::size_t available = AvailablePhysicalBytes();
-		if (available < minimum)
-		{
-			NotifyDerivedLowMemory();
-			return false;
-		}
-		// 低于「舒适线」（最小需求的 4 倍）→ 低内存模式：串行 + 节流，慢慢算完。
-		if (available < minimum * 4u)
-		{
-			throttle = true;
-		}
-		return true;
-	}
-
-	void PlotView::NotifyDerivedLowMemory() const
-	{
-		if (m_curveLowMemoryWarned)
-		{
-			return;		// 同一轮只提示一次，避免反复弹窗
-		}
-		m_curveLowMemoryWarned = true;
-		const HWND host = m_host;
-		if (host != nullptr)
-		{
-			PostMessageW(host, kMessagePlotLowMemory, 0, 0);
-		}
-	}
-
-	void PlotView::ScheduleCurveJob(const CurveKey& key, std::size_t alignedBegin,
-	                                std::size_t alignedEnd, std::size_t count) const
-	{
-		std::size_t windowBegin = 0;
-		std::size_t windowEnd = 0;
-		DerivedGuardWindow(static_cast<DerivedCurveKind>(key.kind), alignedBegin, alignedEnd, key.points,
-		                   key.iterations, count, windowBegin, windowEnd);
-		if (windowEnd <= windowBegin)
-		{
-			return;
-		}
-		// 「大任务」判据：窗口采样数超过大信号门槛（此时工作缓冲会到数百 MB 量级）。
-		const std::size_t windowSamples = windowEnd - windowBegin;
-		const bool huge = (windowSamples >= kHugeSignalPreviewSamples);
-		int hugeLimit = 1;
-		// ⚠️ **内存严重不足时根本不入队**（连一条曲线都装不下）：告警一次并直接放弃本次计算。
-		//    这样“低内存设备”不会因为换页而把整机拖死，也不会抛 `bad_alloc` 逸出线程导致崩溃。
-		if (huge)
-		{
-			bool throttle = false;
-			if (!DerivedMemoryAllows(windowSamples, throttle))
-			{
-				return;
-			}
-			hugeLimit = throttle ? 1 : 2;
-		}
-		{
-			std::lock_guard<std::mutex> lock(m_curveMutex);
-			// 新的计算请求 ⇒ 取消标志必须清零（此前可能因关闭预览/结构变化而被置位）。
-			m_curveCancelAll.store(false, std::memory_order_relaxed);
-			// ⚠️ **幂等**：边沿统计会在“曲线还没算好”时每帧请求一次整条曲线的计算。
-			//    如果每次都当作新请求（自增序号），正在算的那份就会被判为过时而退出 ——
-			//    于是永远算不完（请求 → 作废 → 重请求 的死循环）。
-			for (const CurveKey& running : m_curveRunningKeys)
-			{
-				if (running == key)
-				{
-					return;		// 同一份曲线正在算，无需重复排队
-				}
-			}
-			for (const CurveJob& pending : m_curveJobs)
-			{
-				if (pending.key == key)
-				{
-					return;	// 同一份曲线已在队列里等待
-				}
-			}
-			// 全局请求序号：这次请求之后，同一 (信号, 种类) 的旧任务就都过时了。
-			const std::uint64_t requestSerial = ++m_curveRequestSerial;
-			m_curveLatest[std::make_pair(key.signal, key.kind)] = requestSerial;
-			// 同一「信号 + 曲线种类」的**其它参数**的待算任务全部移除：参数已被取代，
-			// 正在计算的那个会在下一阶处看到自己已过时并**立即退出**。
-			for (auto iterator = m_curveJobs.begin(); iterator != m_curveJobs.end();)
-			{
-				if (iterator->key.signal == key.signal && iterator->key.kind == key.kind)
-				{
-					iterator = m_curveJobs.erase(iterator);
-				}
-				else
-				{
-					++iterator;
-				}
-			}
-			CurveJob job;
-			job.key = key;
-			job.windowBegin = windowBegin;
-			job.windowEnd = windowEnd;
-			job.generation = m_curveGeneration;
-			job.requestSerial = requestSerial;
-			job.huge = huge;
-			job.hugeLimit = hugeLimit;
-			m_curveJobs.push_back(job);
-		}
-		EnsureCurveWorker();
-		m_curveCv.notify_all();
-	}
-
-	void PlotView::EnsureCurveWorker() const
-	{
-		if (!m_curveWorkers.empty())
-		{
-			return;
-		}
-		// **多核并行**：后台线程池并发计算多条派生曲线（5 个网格各一条时，
-		// 串行要 5×368ms，并行只要约 1×368ms），预览曲线因此能很快出现。
-		// 线程数 = 硬件并发 - 1（给 UI/绘制线程留一个核），夹在 1~4。
-		unsigned int hardware = std::thread::hardware_concurrency();
-		int workers = static_cast<int>(hardware == 0 ? 2u : hardware) - 1;
-		workers = std::max(1, std::min(workers, 4));
-		m_curveWorkerStop = false;
-		m_curveWorkers.reserve(static_cast<std::size_t>(workers));
-		for (int index = 0; index < workers; ++index)
-		{
-			m_curveWorkers.emplace_back([this]() { CurveWorkerLoop(); });
-		}
-	}
-
-	void PlotView::StopCurveWorker() const
-	{
-		// 先请所有在算任务尽快退出（每阶 / 每 1M 采样检查一次），再等线程结束 ——
-		// 这是「过时任务立即清退并释放资源」的关键一步：千万级采样的一条曲线工作缓冲
-		// 可达数百 MB，必须尽早归还。
-		m_curveCancelAll.store(true, std::memory_order_relaxed);
-		if (m_curveWorkers.empty())
-		{
-			return;
-		}
-		{
-			std::lock_guard<std::mutex> lock(m_curveMutex);
-			m_curveWorkerStop = true;
-			m_curveJobs.clear();
-			m_curveLatest.clear();
-			m_curveRunningKeys.clear();
-		}
-		m_curveCv.notify_all();
-		for (std::thread& worker : m_curveWorkers)
-		{
-			if (worker.joinable())
-			{
-				worker.join();
-			}
-		}
-		m_curveWorkers.clear();
-		m_curveHugeActive = 0;
-	}
-
-	void PlotView::CurveWorkerLoop() const
-	{
-		// 后台计算线程的优先级降到「低于正常」：派生曲线计算是**可延迟的后台工作**，
-		// 绝不能让它在拖动时与 UI / 绘制线程抢 CPU。降低优先级后，只要 UI 线程要运行，
-		// 系统就会优先调度 UI；计算只在 UI 空闲时占用 CPU，从而保证交互始终跟手
-		//（用户明确要求"无论如何 UI 及控件的响应需要是跟手的"）。
-		SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
-		for (;;)
-		{
-			CurveJob job;
-			{
-				std::unique_lock<std::mutex> lock(m_curveMutex);
-				m_curveCv.wait(lock, [this]()
-				               { return m_curveWorkerStop || !m_curveJobs.empty(); });
-				if (m_curveJobs.empty())
-				{
-					return;	// 仅在 stop 且队列为空时到达
-				}
-				job = m_curveJobs.front();
-				// ⚠️ **大窗口任务不能无限并发**：一条「整段信号」的弱峰调整工作缓冲可达数百 MB，
-				//    多个同时算就是 GB 级峰值（用户报告的 4.4GB）。上限由调度时的内存压力决定：
-				//    内存充足时允许 2 条（仍然很快，但峰值封顶）；内存紧张时只允许 1 条。
-				if (job.huge && m_curveHugeActive >= std::max(1, job.hugeLimit))
-				{
-					m_curveCv.wait_for(lock, std::chrono::milliseconds(5));
-					continue;
-				}
-				m_curveJobs.pop_front();
-				if (job.generation != m_curveGeneration)
-				{
-					continue;	// 代次已变化：丢弃过期任务
-				}
-				if (job.huge)
-				{
-					++m_curveHugeActive;
-				}
-				// 记录“正在计算的曲线键”：`ScheduleCurveJob` 靠它保持幂等
-				//（边沿统计会每帧请求同一份整条曲线，不能每次都当作新请求）。
-				m_curveRunningKeys.push_back(job.key);
-			}
-
-			// 计算在锁外进行：读取的采样在「结构未变」期间只读、且地址稳定
-			//（结构变化前宿主会先 `PauseDerivedAsync`）。
-			// ⚠️ 传入取消标志：一旦同一 (信号, 种类) 有了更新的请求、或发生了结构变化/关闭预览，
-			//    计算会在下一阶（或每 1M 采样）处**立即退出**，尽早归还工作缓冲。
-			bool throttle = false;
-			if (job.huge)
-			{
-				DerivedMemoryAllows(job.windowEnd - job.windowBegin, throttle);
-			}
-			std::vector<float> values = ComputeDerivedWindow(
-			    *job.key.signal, job.windowBegin, job.windowEnd, job.key.kind, job.key.points,
-			    job.key.iterations, job.key.amountPercent, &m_curveCancelAll, throttle);
-
-			if (job.huge)
-			{
-				std::lock_guard<std::mutex> lock(m_curveMutex);
-				m_curveHugeActive = std::max(0, m_curveHugeActive - 1);
-				for (auto iterator = m_curveRunningKeys.begin(); iterator != m_curveRunningKeys.end();
-				     ++iterator)
-				{
-					if (*iterator == job.key)
-					{
-						m_curveRunningKeys.erase(iterator);
-						break;
-					}
-				}
-				m_curveCv.notify_all();
-			}
-			else
-			{
-				std::lock_guard<std::mutex> lock(m_curveMutex);
-				for (auto iterator = m_curveRunningKeys.begin(); iterator != m_curveRunningKeys.end();
-				     ++iterator)
-				{
-					if (*iterator == job.key)
-					{
-						m_curveRunningKeys.erase(iterator);
-						break;
-					}
-				}
-			}
-
-			// ⚠️ **过时结果一律不发布，并立即可回收**：
-			//    * 代次变化（结构变化）→ 丢弃；
-			//    * 同一 (信号, 种类) 已有更新的请求 → 本结果参数已过时，丢弃（后台很快会有新的）。
-			//    * 被取消（`m_curveCancelAll`）→ 曲线可能只算了一部分，绝不能发布。
-			if (m_curveCancelAll.load(std::memory_order_relaxed) ||
-			    CurveJobIsStale(job.key, job.requestSerial))
-			{
-				continue;
-			}
-			{
-				std::lock_guard<std::mutex> lock(m_curveMutex);
-				if (job.generation != m_curveGeneration)
-				{
-					continue;	// 计算期间发生了结构变化：丢弃，避免发布过期结果
-				}
-				if (values.empty())
-				{
-					continue;
-				}
-				std::shared_ptr<CurveEntry> entry = std::make_shared<CurveEntry>();
-				entry->key = job.key;
-				entry->begin = job.windowBegin;
-				entry->end = job.windowEnd;
-				entry->serial = ++m_curveSerial;
-				entry->values = std::move(values);
-				m_curveEntries.push_back(std::move(entry));
-			}
-
-			// 通知宿主重绘：下一帧会取到刚发布的曲线（双缓冲切换）。
-			m_curveSceneDirty.store(true, std::memory_order_relaxed);
-			const HWND host = m_host;
-			if (host != nullptr)
-			{
-				PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
-			}
-		}
-	}
-
-	void PlotView::PruneCurveEntriesLocked() const
-	{
-		// 1) 去掉被「同键、更新、且完全覆盖」的条目取代的旧条目。
-		std::deque<CurveEntryPtr> kept;
-		for (const CurveEntryPtr& entry : m_curveEntries)
-		{
-			bool superseded = false;
-			for (const CurveEntryPtr& other : m_curveEntries)
-			{
-				if (other.get() == entry.get())
-				{
-					continue;
-				}
-				if (other->key == entry->key && other->serial > entry->serial &&
-				    other->begin <= entry->begin && other->end >= entry->end)
-				{
-					superseded = true;
-					break;
-				}
-			}
-			if (!superseded)
-			{
-				kept.push_back(entry);
-			}
-		}
-		m_curveEntries.swap(kept);
-
-		// 2) 条目数与总字节数双重约束（最旧优先淘汰）。
-		const auto bytes = [this]() -> std::size_t
-		{
-			std::size_t total = 0;
-			for (const CurveEntryPtr& entry : m_curveEntries)
-			{
-				total += entry->values.size() * sizeof(float);
-			}
-			return total;
-		};
-		while (!m_curveEntries.empty() &&
-		       (m_curveEntries.size() > kCurveSpanCacheLimit || bytes() > kCurveSpanCacheMaxBytes))
-		{
-			m_curveEntries.pop_front();
-		}
-	}
-
-	const std::vector<float>& PlotView::MeanFilterCurveFor(const SignalData& signal, int points,
-	                                                      int iterations) const
-	{
-		const int radius = std::max(0, points);
-		const int stages = std::max(1, iterations);
-		for (const MeanCurveEntry& entry : m_meanCurveCache)
-		{
-			if (entry.signal == &signal && entry.points == radius && entry.iterations == stages)
-			{
-				return entry.values;
-			}
-		}
-
-		MeanCurveEntry entry;
-		entry.signal = &signal;
-		entry.points = radius;
-		entry.iterations = stages;
-		// 与「构建为新信号」共用同一实现（Utilities 内的自由函数），
-		// 因此预览曲线与构建出的采样值逐位一致。
-		ComputeMovingAverageIterated(signal.values, radius, stages, entry.values);
-
-		m_meanCurveCache.push_back(std::move(entry));
-		return m_meanCurveCache.back().values;
-	}
-
-	const std::vector<float>& PlotView::WeakPeakCurveFor(const SignalData& signal,
-	                                                      int amountPercent, int iterations) const
-	{
-		const int level = std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, amountPercent));
-		const int stages = std::max(kWeakPeakIterationsMin, std::min(kWeakPeakIterationsMaxLimit, iterations));
-		for (const WeakPeakCurveEntry& entry : m_weakPeakCurveCache)
-		{
-			if (entry.signal == &signal && entry.amountPercent == level && entry.iterations == stages)
-			{
-				return entry.values;
-			}
-		}
-
-		WeakPeakCurveEntry entry;
-		entry.signal = &signal;
-		entry.amountPercent = level;
-		entry.iterations = stages;
-		// 与「构建为新信号」共用同一实现（Utilities 内的自由函数），
-		// 因此预览曲线与构建出的采样值逐位一致。
-		ComputeWeakPeakAdjust(signal.values, static_cast<double>(level) / 100.0, stages, entry.values);
-
-		m_weakPeakCurveCache.push_back(std::move(entry));
-		return m_weakPeakCurveCache.back().values;
-	}
-
-	bool PlotView::WeakPeakValueAt(const TimeAxis& axis, const SignalData& signal, int amountPercent,
-	                                int iterations, double time, double& value) const
-	{
-		const int index = FindNearestSample(axis, time);
-		if (index < 0)
-		{
-			return false;
-		}
-		std::size_t spanBegin = 0;
-		const std::vector<float>* curve = CurveSpanFor(
-		    DerivedCurveKind::WEAK_PEAK, signal, 0, iterations, amountPercent,
-		    static_cast<std::size_t>(index), static_cast<std::size_t>(index) + 1, spanBegin);
-		if (curve == nullptr || static_cast<std::size_t>(index) < spanBegin ||
-		    (static_cast<std::size_t>(index) - spanBegin) >= curve->size())
-		{
-			return false;
-		}
-		const float sampled = (*curve)[static_cast<std::size_t>(index) - spanBegin];
-		if (!std::isfinite(sampled))
-		{
-			return false;
-		}
-		value = static_cast<double>(sampled);
-		return true;
-	}
-
-	void PlotView::RequestEdgeScanFrame() const
-	{
-		// 统计还没扫完时主动请宿主再送一帧 —— 否则用户不移动鼠标就不会有任何重绘，
-		// 预算也就永远不推进（用户报告："面板过去很久都一直显示统计中，
-		// 只有当鼠标瞄到浮动面板上时才会显示统计好的值"）。
-		// 与派生曲线就绪用同一条消息（宿主只失效绘图区、不置脏，代价极小）。
-		const HWND host = m_host;
-		if (host != nullptr)
-		{
-			PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
-		}
-	}
-
-	void PlotView::InvalidateEdgeScansFor(const SignalData* signal, bool centreOnly)
-	{
-		// ⚠️ **定向作废**：只有被改动的那个信号（并且只限需要的那一类）要重算，
-		// 其它信号的键没有变化、累计的块和依然有效 → 必须原样保留。
-		// 否则（过去用 `m_edgeScans.clear()`）会连**普通边沿计数**与**其它信号的中心轴统计**
-		// 一起丢掉，于是两个浮动面板里的每一个数字都要从头重新扫描：
-		// 用户报告“改变一个信号的中心轴参数，其它未改变参数的统计也重新计算了”。
-		if (signal == nullptr)
-		{
-			return;
-		}
-		m_edgeScans.erase(std::remove_if(m_edgeScans.begin(), m_edgeScans.end(),
-		                                 [signal, centreOnly](const EdgeScanState& state)
-		                                 {
-			                                 if (state.signal != signal)
-			                                 {
-				                                 return false;	// 别的信号：原样保留
-			                                 }
-			                                 return !centreOnly || state.centre;
-		                                 }),
-		                  m_edgeScans.end());
-	}
-
-	void PlotView::EdgeScanFor(const TimeAxis& axis, const SignalData& signal, const SignalStyle& style,
-	                           bool centre, double threshold, int points, int iterations, bool hasRange,
-	                           double rangeMin, double rangeMax, std::size_t& rising, std::size_t& falling,
-	                           bool& complete) const
-	{
-		rising = 0;
-		falling = 0;
-		complete = false;
-
-		const std::size_t count = signal.values.size();
-		if (count < 2)
-		{
-			complete = true;
-			return;
-		}
-		const bool monotonic = axis.monotonic;
-		// 非单调时间轴无法用「采样对下标区间」表达统计范围，只能逐点按时间过滤 →
-		// 此时区间必须进键（否则会混用别的区间结果）。
-		const bool rangeInKey = hasRange && !monotonic;
-		const std::uint64_t styleKey = EdgeStyleKey(style);
-		const int safePoints = std::max(0, std::min(points, 1000000));
-		const int safeIterations = std::max(1, std::min(iterations, 1000));
-		const bool mirrored = style.mirrorHorizontal;
-		const bool transform = (style.gain != 1.0f || style.absolute || style.mirrorVertical ||
-		                        style.offsetY != 0.0f);
-
-		// 请求的「采样对」区间 [pairFirst, pairLast]（pair k = 采样 k-1 → k，k ≥ 1）。
-		// ⚠️ 只有**两个端点都落在区间内**的采样对才计入（非单调时由 deltaAt 过滤）。
-		std::size_t pairFirst = 1;
-		std::size_t pairLast = count - 1;
-		if (hasRange && monotonic)
-		{
-			std::size_t indexBegin = 0;
-			std::size_t indexEnd = 0;
-			EdgeIndexRange(axis, count, hasRange, rangeMin, rangeMax, indexBegin, indexEnd);
-			pairFirst = (indexBegin + 1 < count) ? (indexBegin + 1) : count;
-			pairLast = (indexEnd > 0) ? (indexEnd - 1) : 0;
-			if (pairLast < pairFirst)
-			{
-				complete = true;
-				return;
-			}
-		}
-
-		// ---- 定位累积状态 -------------------------------------------------------
-		EdgeScanState* state = nullptr;
-		for (EdgeScanState& candidate : m_edgeScans)
-		{
-			if (candidate.axis == &axis && candidate.signal == &signal && candidate.centre == centre &&
-			    candidate.styleKey == styleKey && candidate.points == safePoints &&
-			    candidate.iterations == safeIterations && candidate.hasRange == rangeInKey &&
-			    (!rangeInKey || (candidate.rangeMin == rangeMin && candidate.rangeMax == rangeMax)))
-			{
-				state = &candidate;
-				break;
-			}
-		}
-		if (state == nullptr)
-		{
-			if (m_edgeScans.size() >= kEdgeScanStateLimit)
-			{
-				// ⚠️ 超限时**优先淘汰「已扫完」的最旧状态**（它重算很快、而且通常已经不需要再变），
-				//    绝不淘汰正在推进的那个 —— 否则其它信号会被迫从头重扫
-				//（那正是“改一个参数、其它几个信号也重新统计”这类现象）。
-				std::size_t victim = 0;
-				bool foundVictim = false;
-				for (std::size_t index = 0; index < m_edgeScans.size(); ++index)
-				{
-					if (m_edgeScans[index].complete)
-					{
-						victim = index;
-						foundVictim = true;
-						break;
-					}
-				}
-				if (!foundVictim)
-				{
-					victim = 0;
-				}
-				m_edgeScans.erase(m_edgeScans.begin() + static_cast<std::ptrdiff_t>(victim));
-			}
-			EdgeScanState created;
-			created.axis = &axis;
-			created.signal = &signal;
-			created.centre = centre;
-			created.styleKey = styleKey;
-			created.points = safePoints;
-			created.iterations = safeIterations;
-			created.hasRange = rangeInKey;
-			created.rangeMin = rangeMin;
-			created.rangeMax = rangeMax;
-			created.threshold = threshold;
-			const std::size_t blocks = (count - 1) / kEdgeBlockSamples + 2;
-			created.blockRising.assign(blocks, 0);
-			created.blockFalling.assign(blocks, 0);
-			created.justReset = true;
-			m_edgeScans.push_back(std::move(created));
-			state = &m_edgeScans.back();
-		}
-		else if (!centre && state->threshold != threshold)
-		{
-			// 阈值变了（横向光标正在拖动）：**就地重新开始**，不新建条目（避免拖动时状态爆炸）。
-			// ⚠️ 本 tick 不展示部分值（`justReset`）：部分计数每帧都会被重置，
-			//    显示出来就是"错误且不更新的数字"（用户报告过这个现象）。
-			state->threshold = threshold;
-			state->scannedPair = 1;
-			state->rising = 0;
-			state->falling = 0;
-			state->complete = false;
-			state->justReset = true;
-			std::fill(state->blockRising.begin(), state->blockRising.end(), 0);
-			std::fill(state->blockFalling.begin(), state->blockFalling.end(), 0);
-		}
-
-		// ---- 中心轴：**就地**计算所需的那一小段均值滤波曲线 ---------------------
-		// ⚠️ 过去这里用 `AcquireCoveringCurve`/`ScheduleCurveJob` 拿**整条**曲线，带来两个问题：
-		//    1. 千万级信号的一条曲线 ≈103MB，多条信号叠加会超出曲线缓存预算（768MB）→ 条目被
-		//       淘汰后该信号被判为“曲线未就绪”，界面显示“统计中…”并从头重扫 ——
-		//       **偶发**（取决于当时缓存里积了多少条目，用户报告“改一个参数其它几个信号也重新统计”）；
-		//    2. 几个信号的统计通过这块共享缓存互相牵连。
-		//    现在只算「当前扫描块 ± 滤波半径」：`points * iterations` 就足以让块内取值与整条曲线
-		//    完全一致（迭代 N 次、半径 X 的均值滤波最多向两侧传播 X*N 个采样），内存只有几十 KB，
-		//    且与其它信号、其它曲线彻底解耦。
-		std::size_t localReach = 0;
-		if (centre)
-		{
-			localReach = static_cast<std::size_t>(safePoints) * static_cast<std::size_t>(safeIterations) + 2u;
-			localReach = std::min(localReach, kDerivedCurveGuardMax);
-		}
-		const std::vector<double>& values = signal.values;
-		const bool filterByTime = hasRange && !monotonic;
-
-		/** 把显示下标区间映射为源下标区间（水平镜像时头尾对调）。 */
-		const auto toSourceRange = [&](std::size_t displayFirst, std::size_t displayLast,
-		                               std::size_t& srcFirst, std::size_t& srcLast)
-		{
-			if (mirrored)
-			{
-				srcFirst = (count - 1) - displayLast;
-				srcLast = (count - 1) - displayFirst;
-			}
-			else
-			{
-				srcFirst = displayFirst;
-				srcLast = displayLast;
-			}
-		};
-		/** 确保本地曲线覆盖显示下标区间 [displayFirst, displayLast]（含端点）。 */
-		const auto ensureLocalCurve = [&](std::size_t displayFirst, std::size_t displayLast) -> bool
-		{
-			if (!centre)
-			{
-				return true;
-			}
-			std::size_t srcFirst = 0;
-			std::size_t srcLast = 0;
-			toSourceRange(displayFirst, displayLast, srcFirst, srcLast);
-			if (state->localValid && state->localBegin <= srcFirst && state->localEnd > srcLast)
-			{
-				return true;
-			}
-			const std::size_t windowBegin = (srcFirst > localReach) ? (srcFirst - localReach) : 0;
-			std::size_t windowEnd = std::min(count, srcLast + 1u + localReach);
-			// 至少覆盖 8 个扫描块：迭代均值滤波每算一次窗口要 O(窗口 × 迭代次数)，
-			// 只覆盖一个块会让参数较大时每块都重算一遍（摊薄到 8 个块上就便宜得多）。
-			const std::size_t minSpan = kEdgeBlockSamples * 8u;
-			windowEnd = std::min(count, std::max(windowEnd, windowBegin + minSpan));
-			if (windowEnd <= windowBegin)
-			{
-				return false;
-			}
-			std::vector<float> local =
-			    ComputeDerivedWindow(signal, windowBegin, windowEnd,
-			                         static_cast<int>(DerivedCurveKind::MEAN_FILTER), safePoints,
-			                         safeIterations, 0, nullptr, false);
-			if (local.size() != (windowEnd - windowBegin))
-			{
-				++m_edgeScanLocalCurveFails;
-				return false;		// 计算失败（例如内存不足）：本帧不推进，下帧重试
-			}
-			state->localCurve = std::move(local);
-			state->localBegin = windowBegin;
-			state->localEnd = windowEnd;
-			state->localValid = true;
-			// 本地窗口的计算成本也计入预算（按「采样数 × 迭代次数」折算），避免一帧算太多。
-			const std::size_t cost =
-			    (windowEnd - windowBegin) * static_cast<std::size_t>(safeIterations);
-			m_edgeScanBudget -= std::min(m_edgeScanBudget, cost);
-			return true;
-		};
-
-		// 判定基准：**绘制后**的值相对阈值 / 中心曲线的偏差（区间之外 / 缺失值 → NaN）。
-		const auto deltaAt = [&](std::size_t index) -> double
-		{
-			const double nan = std::numeric_limits<double>::quiet_NaN();
-			if (index >= count)
-			{
-				return nan;
-			}
-			if (filterByTime && index < axis.time.size())
-			{
-				const double time = axis.time[index];
-				if (time < rangeMin || time > rangeMax)
-				{
-					return nan;
-				}
-			}
-			const std::size_t sourceIndex = mirrored ? ((count - 1) - index) : index;
-			if (sourceIndex >= count)
-			{
-				return nan;
-			}
-			const double raw = values[sourceIndex];
-			if (!std::isfinite(raw))
-			{
-				return nan;
-			}
-			const double drawn = transform ? ApplyDrawTransform(style, raw) : raw;
-			if (!std::isfinite(drawn))
-			{
-				return nan;
-			}
-			if (!centre)
-			{
-				return drawn - threshold;
-			}
-			if (!state->localValid || sourceIndex < state->localBegin ||
-			    sourceIndex >= state->localEnd)
-			{
-				return nan;
-			}
-			const float centerSample = state->localCurve[sourceIndex - state->localBegin];
-			if (!std::isfinite(centerSample))
-			{
-				return nan;
-			}
-			const double drawnCenter =
-			    transform ? ApplyDrawTransform(style, static_cast<double>(centerSample))
-			              : static_cast<double>(centerSample);
-			return std::isfinite(drawnCenter) ? (drawn - drawnCenter) : nan;
-		};
-
-		// ---- 推进（受「每帧总量 + 每状态配额」双重限制）--------------------------
-		// ⚠️ 预算在 `Paint` 开头**按帧**重置（不再按 `GetTickCount64()` 分桶）：系统时钟
-		//    粒度约 15.6ms，帧率一高就会在同一 tick 内连画多帧而完全不推进 —— 用户报告的
-		//    “按住横向光标不动时统计卡在统计中”“回车确认参数后不移动鼠标就一直停在部分值”
-		//    就是这个原因。
-		// ⚠️ 同时**每个状态各自持有配额**：否则推进总从列表第一个状态扫起，多条信号时
-		//    只有第一条有进展、其余长期显示“统计中…”（用户报告“很多项都停在统计中不更新”）。
-		const bool suppressPartial = state->justReset && !state->complete;
-		if (!state->complete && !state->blockRising.empty())
-		{
-			const std::size_t activeStates = std::max<std::size_t>(1, m_edgeScans.size());
-			const std::size_t share = std::max<std::size_t>(kEdgeScanFairShare, activeStates);
-			const std::size_t perState =
-			    std::max<std::size_t>(kEdgeScanPairsPerStateMin, kEdgeScanPairsPerFrame / share);
-			if (state->pumpedFrame != m_edgeScanFrame)
-			{
-				state->pumpedFrame = m_edgeScanFrame;
-				state->pumpedPairs = 0;
-			}
-			std::size_t quota = (perState > state->pumpedPairs) ? (perState - state->pumpedPairs) : 0;
-			quota = std::min(quota, m_edgeScanBudget);
-			if (quota > 0)
-			{
-				state->justReset = false;
-				// 快路径：时间单调、无水平镜像、无「调整」变换、非中心轴 ⇒ 直接比较采样值与阈值。
-				// （NaN 与任何数比较都为 false ⇒ 天然满足"NaN 不参与且打断连续"的语义。）
-				// 绝大多数信号都走这条，单次预算的耗时因此从 ~18ms 降到 ~2ms。
-				const bool plainFast = monotonic && !mirrored && !transform && !centre;
-				std::size_t scanned = 0;
-				std::size_t pair = state->scannedPair;
-				std::size_t block = (pair > 0) ? ((pair - 1) / kEdgeBlockSamples) : 0;
-				while (pair < count && scanned < quota && m_edgeScanBudget > 0)
-				{
-					const std::size_t blockFirst = block * kEdgeBlockSamples + 1;
-					const std::size_t blockLast = std::min(count - 1, (block + 1) * kEdgeBlockSamples);
-					const std::size_t from = std::max(pair, blockFirst);
-					const std::size_t avail = std::min(quota - scanned, m_edgeScanBudget);
-					const std::size_t to = std::min(blockLast, from + avail - 1);
-					if (to < from)
-					{
-						break;
-					}
-					// 中心轴：先确保本地区间曲线覆盖本块（含两端各一个采样点，供边界比较）。
-					if (!ensureLocalCurve(from - 1, to))
-					{
-						break;		// 算不出来（内存不足等）：本帧到此为止，下帧重试
-					}
-					std::size_t localRising = 0;
-					std::size_t localFalling = 0;
-					if (plainFast)
-					{
-						double previous = values[from - 1] - threshold;
-						for (std::size_t index = from; index <= to; ++index)
-						{
-							const double current = values[index] - threshold;
-							if (previous < 0.0 && current >= 0.0)
-							{
-								++localRising;
-							}
-							else if (previous > 0.0 && current <= 0.0)
-							{
-								++localFalling;
-							}
-							previous = current;
-						}
-					}
-					else
-					{
-						double previous = deltaAt(from - 1);
-						for (std::size_t index = from; index <= to; ++index)
-						{
-							const double current = deltaAt(index);
-							if (std::isfinite(previous) && std::isfinite(current))
-							{
-								if (previous < 0.0 && current >= 0.0)
-								{
-									++localRising;
-								}
-								else if (previous > 0.0 && current <= 0.0)
-								{
-									++localFalling;
-								}
-							}
-							previous = current;
-						}
-					}
-					if (block < state->blockRising.size())
-					{
-						state->blockRising[block] += localRising;
-						state->blockFalling[block] += localFalling;
-					}
-					state->rising += localRising;
-					state->falling += localFalling;
-					scanned += (to - from + 1);
-					pair = to + 1;
-					if (to == blockLast)
-					{
-						++block;
-					}
-				}
-				state->scannedPair = pair;
-				state->complete = (pair >= count);
-				if (state->complete)
-				{
-					// 扫完后**释放**本地曲线（区间查询需要时会按需重算）——
-					// 否则多信号网格下每个状态都要常驻几十 KB~几 MB。
-					state->localCurve.clear();
-					state->localCurve.shrink_to_fit();
-					state->localBegin = 0;
-					state->localEnd = 0;
-					state->localValid = false;
-				}
-				state->pumpedPairs += scanned;
-				m_edgeScanBudget -= std::min(m_edgeScanBudget, scanned);
-			}
-		}
-
-		// ---- 汇总请求区间 -------------------------------------------------------
-		// 内部整块用块和相加，只有两端边界块（≤ 2 块）需要就地精确扫描
-		// ⇒ 拖动**时间**光标时单帧代价与区间长度无关。
-		if (!suppressPartial)
-		{
-			const std::size_t limit =
-			    (state->scannedPair > 0) ? std::min(pairLast, state->scannedPair - 1) : 0;
-			if (limit >= pairFirst)
-			{
-				const std::size_t firstBlock = (pairFirst - 1) / kEdgeBlockSamples;
-				const std::size_t lastBlock = (limit - 1) / kEdgeBlockSamples;
-				bool boundaryOk = true;
-				for (std::size_t block = firstBlock; block <= lastBlock && boundaryOk; ++block)
-				{
-					const std::size_t blockFirst = block * kEdgeBlockSamples + 1;
-					const std::size_t blockLast = std::min(count - 1, (block + 1) * kEdgeBlockSamples);
-					const std::size_t low = std::max(pairFirst, blockFirst);
-					const std::size_t high = std::min(limit, blockLast);
-					const bool wholeBlock = (low == blockFirst) && (high == blockLast) &&
-					                        (state->scannedPair > blockLast) &&
-					                        (block < state->blockRising.size());
-					if (wholeBlock)
-					{
-						rising += state->blockRising[block];
-						falling += state->blockFalling[block];
-						continue;
-					}
-					// 边界块 / 尚未扫完的块：就地精确扫描这一小段（≤ 1 个块）。
-					if (!ensureLocalCurve(low - 1, high))
-					{
-						boundaryOk = false;		// 中心轴曲线算不出来：本帧不展示（下帧重试）
-						break;
-					}
-					double previous = deltaAt(low - 1);
-					for (std::size_t index = low; index <= high; ++index)
-					{
-						const double current = deltaAt(index);
-						if (std::isfinite(previous) && std::isfinite(current))
-						{
-							if (previous < 0.0 && current >= 0.0)
-							{
-								++rising;
-							}
-							else if (previous > 0.0 && current <= 0.0)
-							{
-								++falling;
-							}
-						}
-						previous = current;
-					}
-				}
-				// 边界块扫描失败（中心轴曲线算不出来）时不展示结果：保持 complete=false。
-				complete = boundaryOk && (pairLast < state->scannedPair);
-			}
-			else
-			{
-				complete = (pairLast < state->scannedPair);
-			}
-		}
-		if (!complete)
-		{
-			RequestEdgeScanFrame();
-		}
-	}
-
-	void PlotView::EdgeCountsFor(const TimeAxis& axis, const SignalData& signal, const SignalStyle& style,
-	                             double edgeValue, bool hasRange, double rangeMin, double rangeMax,
-	                             std::size_t& rising, std::size_t& falling, bool& complete) const
-	{
-		EdgeScanFor(axis, signal, style, false, edgeValue, 0, 1, hasRange, rangeMin, rangeMax, rising,
-		            falling, complete);
-	}
-
-	void PlotView::EdgeCenterCountsFor(const TimeAxis& axis, const SignalData& signal,
-	                                   const SignalStyle& style, int points, int iterations,
-	                                   bool hasRange, double rangeMin, double rangeMax,
-	                                   std::size_t& rising, std::size_t& falling, bool& complete) const
-	{
-		// 与普通边沿计数完全共用同一套「逐块累积 + 每 tick 预算推进」机制；
-		// 区别只在判定基准（信号 − 中心平均值曲线）与所需曲线（均值滤波，需整条）。
-		EdgeScanFor(axis, signal, style, true, 0.0, points, iterations, hasRange, rangeMin, rangeMax,
-		            rising, falling, complete);
-	}
-
-
-	float PlotView::EdgePanelWidth(int laneIndex, EdgePanelKind kind) const
-	{
-		if (m_tab == nullptr || m_fonts == nullptr || laneIndex < 0 ||
-		    laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return kEdgePanelWidth * m_scale;
-		}
-		const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		const bool centerAxis = (kind == EdgePanelKind::CENTER);
-		const bool meanFilter = (kind == EdgePanelKind::MEAN);
-		const bool weakPeak = (kind == EdgePanelKind::PEAK);
-		// 「均值滤波」「中心轴边沿计数」「弱峰调整」都是逐条目面板（名称 + 复选框）。
-		const bool itemized = (centerAxis || meanFilter || weakPeak);
-
-		// 标题行 = “GX” 徽标 + 标题（“边沿计数” / “中心轴边沿计数” / “均值滤波” / “弱峰调整”
-		// + 光标区间尾缀）。
-		const std::wstring title =
-		    meanFilter ? std::wstring(L"均值滤波")
-		               : (weakPeak ? std::wstring(kWeakPeakTitle)
-		                            : ((centerAxis ? L"中心轴边沿计数" : L"边沿计数") + EdgeRangeSuffix()));
-		float width = kEdgePanelPad * 2.0f * m_scale + kLaneBadgeWidth * m_scale +
-		              8.0f * m_scale + UiMeasureTextWidth(m_fonts->uiSmall, title) +
-		              kEdgePanelTitleHeight * m_scale;
-
-		// 数据行 = 名称与“上升沿 N / 下降沿 M”两行，取较宽者。
-		// ⚠️ 名称宽度有上限（`kEdgePanelNameMaxWidth`）：超长信号名不再把面板顶得很长，
-		//    绘制时超出部分用省略号（用户明确要求“超过某个长度就省略名称显示”）。
-		// ⚠️ 统计信息按「上升沿 / 下降沿」**两列**排版（列起点固定）→ 多条信号时文字垂直对齐。
-		float nameColumnWidth = 0.0f;
-		float statRisingWidth = 0.0f;
-		float statFallingWidth = 0.0f;
-		for (const SignalRef& ref : lane.signals)
-		{
-			const ResolvedSignal resolved = ResolveSignal(ref);
-			if (resolved.data == nullptr || !resolved.visible)
-			{
-				continue;
-			}
-			const float nameWidth =
-			    std::min(UiMeasureTextWidth(m_fonts->uiSmall, resolved.data->name),
-			             kEdgePanelNameMaxWidth * m_scale);
-			nameColumnWidth = std::max(nameColumnWidth, nameWidth);
-			if (itemized)
-			{
-				// 逐条目面板：第一排 = 名称 + 复选框；第三排（中心轴）= 统计结果。
-				width = std::max(width, kEdgePanelPad * 2.0f * m_scale + nameWidth +
-				                              kEdgePanelMeanCheckSize * m_scale + 6.0f * m_scale);
-			}
-			std::size_t rising = 0;
-			std::size_t falling = 0;
-			bool complete = true;
-			if (meanFilter || weakPeak)
-			{
-				continue;
-			}
-			if (centerAxis)
-			{
-				const Lane::EdgeCenterItem* item = lane.FindEdgeCenterItem(ref);
-				if (item == nullptr)
-				{
-					continue;
-				}
-				EdgeCenterCountsFor(*resolved.axis, *resolved.data, *resolved.style, item->points,
-				                    item->iterations, EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(),
-				                    rising, falling, complete);
-			}
-			else
-			{
-				EdgeCountsFor(*resolved.axis, *resolved.data, *resolved.style, lane.edgeValue,
-				              EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(), rising, falling, complete);
-			}
-			// 宽度按实际要显示的文本测量（含未算完时的“…”），否则推进过程中数字变长会被截断。
-			// 完全未算出时整行显示“统计中…”，因此两列都要预留它的宽度。
-			const float pendingWidth = UiMeasureTextWidth(m_fonts->monoSmall, L"统计中…");
-			statRisingWidth = std::max(
-			    statRisingWidth,
-			    std::max(UiMeasureTextWidth(m_fonts->monoSmall, EdgeRisingText(rising, complete)),
-			             pendingWidth));
-			statFallingWidth =
-			    std::max(statFallingWidth,
-			             UiMeasureTextWidth(m_fonts->monoSmall, EdgeFallingText(falling, complete)));
-		}
-		if (statRisingWidth > 0.0f || statFallingWidth > 0.0f)
-		{
-			// 两列**等宽**（取两列最大值中的较大者）→ 绘制时两列起点固定，
-			// 多条信号的“上升沿 / 下降沿”文字严格垂直对齐（用户明确要求）。
-			const float maxColumn = std::max(statRisingWidth, statFallingWidth);
-			const float countsWidth = maxColumn * 2.0f + kEdgePanelStatColumnGap * m_scale;
-			width = std::max(width, kEdgePanelPad * 2.0f * m_scale +
-			                            std::max(nameColumnWidth, countsWidth));
-		}
-
-		if (centerAxis || meanFilter)
-		{
-			// 参数行 = 两个「说明文字 + 数值框」，必须保证文字不被数值框压住。
-			// （MEAN / CENTER：「均值点数 X」+「迭代次数 N」。标签与数值框各占半行。）
-			const float labelXWidth = UiMeasureTextWidth(m_fonts->uiSmall, L"均值点数 X");
-			const float labelN = UiMeasureTextWidth(m_fonts->uiSmall, L"迭代次数 N");
-			const float fieldWidth =
-			    std::max(kEdgePanelEditFieldWidth * m_scale * 0.75f,
-			             UiMeasureTextWidth(m_fonts->monoSmall, L"1000000") + 18.0f * m_scale);
-			const float halfWidth = std::max(labelXWidth, labelN) + 6.0f * m_scale + fieldWidth;
-			const float rowWidth = halfWidth * 2.0f + 8.0f * m_scale;
-			width = std::max(width, kEdgePanelPad * 2.0f * m_scale + rowWidth);
-		}
-
-		if (weakPeak)
-		{
-			// 滑块行 = 「标签列 + 轨道（最小宽度）+ 数值列 + 复位按钮」（等级与迭代次数两行共用同一列宽）。
-			const float rowWidth = WeakPeakLabelColumnWidth(m_fonts->uiSmall) + 6.0f * m_scale +
-			                       kWeakPeakTrackMinWidth * m_scale + 6.0f * m_scale +
-			                       WeakPeakValueColumnWidth(m_fonts->monoSmall) +
-			                       kWeakPeakResetGap * m_scale + kWeakPeakResetButtonSize * m_scale;
-			width = std::max(width, kEdgePanelPad * 2.0f * m_scale + rowWidth);
-		}
-
-		if (meanFilter || weakPeak)
-		{
-			// 底部按钮行 = 「构建为新信号」，按按钮文字实测宽度确定下限。
-			const float buttonWidth =
-			    UiMeasureTextWidth(m_fonts->uiSmall, kBuildSignalLabel) + 28.0f * m_scale;
-			width = std::max(width, kEdgePanelPad * 2.0f * m_scale + buttonWidth);
-		}
-
-		// 夹在绘图区宽度之内（过窄的网格也不至于把面板挤到外面）。
-		return std::min(width, std::max(120.0f * m_scale, m_plotRect.Width - 8.0f * m_scale));
-	}
-
-	bool PlotView::EdgeRangeActive() const
-	{
-		return m_tab != nullptr && Tab().CursorMode() == PlotCursorMode::DOUBLE;
-	}
-
-	double PlotView::EdgeRangeMin() const
-	{
-		if (m_tab == nullptr)
-		{
-			return 0.0;
-		}
-		// 左右光标可能被拖动交换：始终取较小者为区间左端。
-		return std::min(Tab().CursorTime(), Tab().CursorTimeAlt());
-	}
-
-	double PlotView::EdgeRangeMax() const
-	{
-		if (m_tab == nullptr)
-		{
-			return 0.0;
-		}
-		return std::max(Tab().CursorTime(), Tab().CursorTimeAlt());
-	}
-
-	std::wstring PlotView::EdgeRangeSuffix() const
-	{
-		return EdgeRangeActive() ? std::wstring(L"（光标区间内）") : std::wstring();
-	}
-
-	bool PlotView::ToggleLaneAutoFitToSelection(int laneIndex)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return false;
-		}
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		lane.fitYToSelection = !lane.fitYToSelection;
-		if (lane.fitYToSelection)
-		{
-			// 打开时立即按当前视图自适应一次，否则当前量程不合适时看不到任何变化。
-			AutoRangeLaneToView(laneIndex);
-		}
-		return lane.fitYToSelection;
-	}
-
-	void PlotView::ApplyAutoFitToSelectionNow(int laneIndex)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return;
-		}
-		if (!m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].fitYToSelection)
-		{
-			return;
-		}
-		AutoRangeLaneToView(laneIndex);
-	}
-
-	void PlotView::ApplyAllAutoFitToSelectionNow()
-	{
-		if (m_tab == nullptr)
-		{
-			return;
-		}
-		const std::size_t count = m_tab->Lanes().size();
-		for (std::size_t index = 0; index < count; ++index)
-		{
-			ApplyAutoFitToSelectionNow(static_cast<int>(index));
-		}
-	}
-
-	bool PlotView::SetAllLanesAutoFitToSelection(bool enabled, bool applyNow)
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		bool changed = false;
-		for (Lane& lane : m_tab->Lanes())
-		{
-			if (lane.fitYToSelection != enabled)
-			{
-				lane.fitYToSelection = enabled;
-				changed = true;
-			}
-		}
-		if (enabled && applyNow)
-		{
-			// 全局打开时立刻让每个网格都自适应一次，保证界面立刻反映开关状态。
-			ApplyAllAutoFitToSelectionNow();
-		}
-		return changed;
-	}
-
-	bool PlotView::AutoRangeLaneToView(int laneIndex)
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return false;
-		}
-
-		const std::vector<Lane>& lanes = m_tab->Lanes();
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(lanes.size()))
-		{
-			return false;
-		}
-
-		const double viewMin = Tab().ViewMin();
-		const double viewMax = Tab().ViewMax();
-		if (!(viewMax > viewMin))
-		{
-			return false;
-		}
-
-		// 只统计时间轴当前可见区间内的采样点，因此放大局部波形后可以快速把该段铺满网格。
-		double low = std::numeric_limits<double>::infinity();
-		double high = -std::numeric_limits<double>::infinity();
-
-		for (const SignalRef& ref : lanes[static_cast<std::size_t>(laneIndex)].signals)
-		{
-			if (!Tab().IsVisible(ref))
-			{
-				continue;
-			}
-			const SignalData* signal = m_dataSet->Resolve(ref);
-			const TimeAxis* axis = m_dataSet->Axis(ref);
-			if (signal == nullptr || axis == nullptr)
-			{
-				continue;
-			}
-
-			const std::size_t count = std::min(axis->time.size(), signal->values.size());
-			const SignalStyle* style = m_dataSet->Style(ref);
-			// 时间偏移：可见采样对应的源时刻区间要整体左移（画在 t + shift 处）。
-			const double timeShift = (style != nullptr) ? style->offsetTime : 0.0;
-			const double sourceMin = viewMin - timeShift;
-			const double sourceMax = viewMax - timeShift;
-			std::size_t begin = 0;
-			std::size_t end = count;
-			if (axis->monotonic)
-			{
-				// 时间单调时直接二分定位区间，百万级采样也只需扫过可见段。
-				begin = static_cast<std::size_t>(
-				    std::lower_bound(axis->time.begin(), axis->time.end(), sourceMin) - axis->time.begin());
-				if (begin > 0)
-				{
-					--begin;
-				}
-				end = static_cast<std::size_t>(
-				    std::lower_bound(axis->time.begin(), axis->time.end(), sourceMax) - axis->time.begin());
-				if (end < count)
-				{
-					++end;
-				}
-			}
-
-			// ⚠️ **性能：把样式指针提到循环之外**。`DataSet::Style(ref)` 每次调用都要做
-			// 指针解析与边界检查；放在循环体里等于**每个采样点解析两次**
-			//（实测全段自适应因此从 147ms 劣化到 1200ms —— 8 倍回归）。
-			const SignalStyle* resolvedStyle = style;	// 可能为 nullptr（视为无变换）
-			const bool mirrored = (resolvedStyle != nullptr) && resolvedStyle->mirrorHorizontal;
-			const bool transform = (resolvedStyle != nullptr) &&
-			                       (resolvedStyle->gain != 1.0f || resolvedStyle->absolute ||
-			                        resolvedStyle->mirrorVertical || resolvedStyle->offsetY != 0.0f);
-
-			// ⚠️ **整段自适应直接取信号已缓存的 min/max**（O(1)）：
-			// 当视界覆盖整条信号、且该信号没有任何数值变换时，逐点扫描的结果与
-			// `ComputeStats` 预存的 min/max 完全一致。工具栏「Y 轴自适应」开关在全视图下
-			// 会一次性对全部网格做这件事 —— 逐点扫描 2580 万 × 5 是秒级卡顿（实测 1200ms），
-			// 这里改为 O(1)。
-			if (axis->monotonic && begin == 0 && end == count && !mirrored && !transform &&
-			    signal->finiteCount > 0)
-			{
-				low = std::min(low, signal->minValue);
-				high = std::max(high, signal->maxValue);
-				continue;
-			}
-
-			if (!mirrored && !transform)
-			{
-				// 无变换：与既有实现完全一致的紧凑循环（无逐点分支，便于向量化）。
-				for (std::size_t index = begin; index < end; ++index)
-				{
-					if (!axis->monotonic)
-					{
-						const double t = axis->time[index];
-						if (!std::isfinite(t) || t < sourceMin || t > sourceMax)
-						{
-							continue;
-						}
-					}
-					const double value = signal->values[index];
-					if (!std::isfinite(value))
-					{
-						continue;
-					}
-					low = std::min(low, value);
-					high = std::max(high, value);
-				}
-				continue;
-			}
-
-			// 有变换（系数 / 绝对值 / 镜像 / Y 偏移）或水平镜像：逐点套用与绘制**相同**的变换。
-			// ⚠️ 自适应必须基于**画出来的曲线**，否则调整系数/镜像后自适应范围会按原始数据算错
-			//（用户报告"自适应区域错误，看上去还是按照原始数据来的"）。
-			// 水平镜像时画面上的第 index 个位置取源下标 count-1-index 的值。
-			for (std::size_t index = begin; index < end; ++index)
-			{
-				if (!axis->monotonic)
-				{
-					const double t = axis->time[index];
-					if (!std::isfinite(t) || t < sourceMin || t > sourceMax)
-					{
-						continue;
-					}
-				}
-				const std::size_t sourceIndex =
-				    (mirrored && count > 0) ? ((count - 1) - index) : index;
-				if (sourceIndex >= count)
-				{
-					continue;
-				}
-				const double raw = signal->values[sourceIndex];
-				if (!std::isfinite(raw))
-				{
-					continue;
-				}
-				const double value = transform ? ApplyDrawTransform(*resolvedStyle, raw) : raw;
-				if (std::isfinite(value))
-				{
-					low = std::min(low, value);
-					high = std::max(high, value);
-				}
-			}
-		}
-
-		if (!std::isfinite(low) || !std::isfinite(high))
-		{
-			return false;
-		}
-
-		// ⚠️ 留白必须与整段自适应（`TabConfig::ComputeLaneRange` → `PadRange`）**共用同一规则**
-		//（`PadValueRange`）：否则「点过适应视图后再打开 Y 轴自适应」会因为留白不同
-		//（6% vs 5%）而算出不一样的区间，网格被无意义地重绘一次；
-		// 反向（关掉 Y 轴自适应再点适应视图）同样会变。
-		PadValueRange(low, high);
-
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		lane.autoRange = false;
-		lane.yMin = low;
-		lane.yMax = high;
-		BuildLaneVisuals();
-		return true;
-	}
-
-	void PlotView::ApplySelectionAutoFit()
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-
-		const std::vector<Lane>& lanes = m_tab->Lanes();
-		bool any = false;
-		for (const Lane& lane : lanes)
-		{
-			if (lane.fitYToSelection)
-			{
-				any = true;
-				break;
-			}
-		}
-		if (!any)
-		{
-			return;
-		}
-
-		// 只对开启了「选区 Y 轴自适应」的网格重新匹配 Y 轴；
-		// 重新匹配依据的是刚刚更新过的时间视图范围。
-		for (std::size_t index = 0; index < lanes.size(); ++index)
-		{
-			if (m_tab->Lanes()[index].fitYToSelection)
-			{
-				AutoRangeLaneToView(static_cast<int>(index));
-			}
-		}
-	}
-
-	void PlotView::ReapplyGlobalAutoFitIfEnabled()
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-		// 与工具栏「Y 轴自适应」按钮的勾选判据完全一致（全部网格都开启才叫“全局开启”）。
-		if (!AllLanesAutoFitToSelection())
-		{
-			return;
-		}
-		// 结构变化后重新匹配一次：新网格要按当前视界自适应，
-		// 移除信号后的网格也要按剩下信号重新收敛（旧幅值区间是按旧信号集合算的）。
-		ApplyAllAutoFitToSelectionNow();
-	}
-
-	bool PlotView::UpdateAutoScatterStyles()
-	{
-		if (m_dataSetWritable == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-
-		bool changed = false;
-		// 只处理当前标签页里**可见**的信号：绘制方式的自动切换是「视界」驱动的，
-		// 看不见的信号与当前视界无关（它们可见时会经 `RefreshLanes` 再判一次）。
-		for (const Lane& lane : m_tab->Lanes())
-		{
-			for (const SignalRef& ref : lane.signals)
-			{
-				if (!m_tab->IsVisible(ref))
-				{
-					continue;
-				}
-				const TimeAxis* axis = m_dataSetWritable->Axis(ref);
-				const SignalData* data = m_dataSetWritable->Resolve(ref);
-				SignalStyle* style = m_dataSetWritable->Style(ref);
-				if (axis == nullptr || data == nullptr || style == nullptr)
-				{
-					continue;
-				}
-
-				// ⚠️ **先**判定“用户是否手动改过绘制方式”：本机制只会写入「点线」，
-				// 所以自动启用期间 mode 不等于「点线」只可能是用户改的。
-				// 这一步必须在下面的分支之前做 —— 用户改完样式可能**紧接着就缩出去**
-				// （例如直接点适应视图），那次调用的视界已经不再满足条件，若等到那时才判定，
-				// 恢复逻辑会先把用户的修改覆盖掉（用户明确要求不能这样）。
-				if (style->autoScatterActive && style->mode != DrawMode::LINE_SCATTER)
-				{
-					style->autoScatterUserOverride = true;
-				}
-
-				// 判定与**光标吸附完全同源**（用户 2026-10-15 明确要求）：
-				// 只有“一屏内数据点少于 N×4”的信号才自动切「点线」，
-				// 不再满足时（适应视图、或把视界移到信号的稠密区）自动恢复原样式。
-				// ⚠️ 可见性同样按**显示时间**判断（含 `offsetTime`），与吸附保持一致。
-				if (SignalSnapEnabled(*axis, *data, style->offsetTime))
-				{
-					if (!style->autoScatterActive)
-					{
-						// 进入阈值：保存原绘制方式并自动切到「点线」提示用户数据点位置。
-						style->autoScatterSavedMode = style->mode;
-						style->autoScatterActive = true;
-						style->autoScatterUserOverride = false;
-						if (style->mode != DrawMode::LINE_SCATTER)
-						{
-							style->mode = DrawMode::LINE_SCATTER;
-							changed = true;
-						}
-					}
-				}
-				else if (style->autoScatterActive)
-				{
-					// 退出阈值（例如适应视图）：恢复自动启用之前的绘制方式；
-					// 但用户手动改过时**不恢复**（尊重用户的选择）。
-					style->autoScatterActive = false;
-					if (!style->autoScatterUserOverride && style->mode != style->autoScatterSavedMode)
-					{
-						style->mode = style->autoScatterSavedMode;
-						changed = true;
-					}
-					style->autoScatterUserOverride = false;
-				}
-			}
-		}
-		return changed;
-	}
-
 	void PlotView::ShiftLaneRange(int laneIndex, double deltaValue)
 	{
 		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()) ||
@@ -4895,8802 +782,6 @@ namespace jdi
 		return true;
 	}
 
-	float PlotView::SinglePointDotRadius(const ResolvedSignal& resolved) const
-	{
-		if (resolved.style == nullptr)
-		{
-			return kMinScatterRadius * m_scale;
-		}
-		// 与 `PaintLane` / 拖拽虚影画那个点时的半径**完全同源**（散点半径随线宽线性增长），
-		// 命中判定与光晕半径都复用它，三者不会出现“看着点中了却没反应”。
-		const double radius = ClampDouble(static_cast<double>(resolved.style->lineWidth) * kScatterRadiusScale,
-		                                 static_cast<double>(kMinScatterRadius),
-		                                 static_cast<double>(kMaxScatterRadius));
-		return static_cast<float>(radius) * m_scale;
-	}
-
-	bool PlotView::SinglePointScreenPos(const ResolvedSignal& resolved, const LaneVisual& lane,
-	                                    gd::PointF& out) const
-	{
-		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
-		{
-			return false;
-		}
-		if (resolved.data->finiteCount != 1)
-		{
-			return false;
-		}
-		double time = 0.0;
-		double value = 0.0;
-		if (!SinglePointOfSignal(*resolved.data, *resolved.axis, time, value))
-		{
-			return false;
-		}
-		// 与绘制一致：采样画在 `t + offsetTime` 处，取值先过「调整」变换。
-		const double displayTime = time + resolved.style->offsetTime;
-		const double drawValue = ApplyDrawTransform(*resolved.style, value);
-		if (!std::isfinite(displayTime) || !std::isfinite(drawValue))
-		{
-			return false;
-		}
-		out.X = TimeToX(displayTime);
-		out.Y = ValueToY(drawValue, lane);
-		return true;
-	}
-
-	SignalRef PlotView::HitTestSignal(int x, int y) const
-	{
-		SignalRef empty;
-		if (m_tab == nullptr || m_dataSet == nullptr || !HasDrawableContent())
-		{
-			return empty;
-		}
-		if (!UiPointInRect(m_plotRect, static_cast<float>(x), static_cast<float>(y)))
-		{
-			return empty;
-		}
-
-		const int laneIndex = LaneAtY(y);
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return empty;
-		}
-
-		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
-		const float tolerance = kSignalHitTolerance * m_scale;
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-
-		SignalRef best;
-		float bestDistance = tolerance;
-
-		// 只为当前网格内的可见信号做精确的点到线段距离检测，避免跨网格误命中。
-		for (const SignalRef& ref : m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals)
-		{
-			const ResolvedSignal resolved = ResolveSignal(ref);
-			if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
-			{
-				continue;
-			}
-
-			// ⚠️ **只有单个有效数据点**的信号没有“折线”可测距（`AcquirePolyline` 给不出两点的
-			// 线段），必须直接用数据点的屏幕坐标判定。否则用户永远无法悬停/拖动单点信号
-			//（用户 2026-10-15 报告：“光标瞄到数据点没有高亮、也不能拖拽换网格”）。
-			if (resolved.data->finiteCount == 1)
-			{
-				gd::PointF dot;
-				if (!SinglePointScreenPos(resolved, lane, dot))
-				{
-					continue;
-				}
-				const float dx = dot.X - fx;
-				const float dy = dot.Y - fy;
-				const float distance = std::sqrt(dx * dx + dy * dy);
-				// 容差取“常规命中容差”与“该点绘制半径”的较大者：点本身很粗时更好点中。
-				const float dotRadius = SinglePointDotRadius(resolved);
-				const float limit = std::max(tolerance, dotRadius);
-				if (distance <= limit && distance <= bestDistance + dotRadius)
-				{
-					bestDistance = distance;
-					best = ref;
-				}
-				continue;
-			}
-
-			// 复用绘制阶段的折线顶点：悬停检测通常与上一帧几何完全相同，
-			// 不再为“鼠标移动但命中结果未变”重复扫描全量采样点。
-			const PolylineCacheEntry* cached = AcquirePolyline(ref, resolved, lane);
-			if (cached == nullptr)
-			{
-				continue;
-			}
-			const std::vector<gd::PointF>& points = cached->points;
-			const std::vector<std::size_t>& breaks = cached->breaks;
-			if (points.size() < 2)
-			{
-				continue;
-			}
-
-			// 横向先行裁剪：点到线段的距离必然不小于横向距离本身，
-			// 因此只有横向落在容差范围内的顶点才可能命中。
-			// 时间单调时折线顶点按 x 递增，可二分定位后只扫描这一小段；
-			// 否则每次鼠标移动都要遍历上万个顶点（悬停卡顿的来源之一）。
-			std::size_t windowFirst = 0;
-			std::size_t windowLast = points.size();
-			if (resolved.axis->monotonic)
-			{
-				const auto byX = [](const gd::PointF& point, float limit) { return point.X < limit; };
-				windowFirst = static_cast<std::size_t>(
-				    std::lower_bound(points.begin(), points.end(), fx - tolerance, byX) - points.begin());
-				windowLast = static_cast<std::size_t>(
-				    std::upper_bound(points.begin(), points.end(), fx + tolerance,
-				                     [](float limit, const gd::PointF& point) { return limit < point.X; }) -
-				    points.begin());
-			}
-			if (windowFirst >= windowLast)
-			{
-				continue;
-			}
-			// 散点模式下把采样点本身也视为可命中目标。
-			if (resolved.style->mode == DrawMode::SCATTER)
-			{
-				for (std::size_t index = windowFirst; index < windowLast; ++index)
-				{
-					const gd::PointF& point = points[index];
-					const float dx = point.X - fx;
-					const float dy = point.Y - fy;
-					const float distance = std::sqrt(dx * dx + dy * dy);
-					if (distance <= bestDistance)
-					{
-						bestDistance = distance;
-						best = ref;
-					}
-				}
-				continue;
-			}
-
-			for (std::size_t k = 0; k < breaks.size(); ++k)
-			{
-				const std::size_t start = breaks[k];
-				const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
-				const std::size_t scanBegin = std::max(start + 1, windowFirst);
-				const std::size_t scanEnd = std::min(stop, windowLast);
-				for (std::size_t index = scanBegin; index < scanEnd; ++index)
-				{
-					const gd::PointF& a = points[index - 1];
-					const gd::PointF& b = points[index];
-
-					const float vx = b.X - a.X;
-					const float vy = b.Y - a.Y;
-					const float wx = fx - a.X;
-					const float wy = fy - a.Y;
-
-					const float lengthSquared = vx * vx + vy * vy;
-					float t = 0.0f;
-					if (lengthSquared > 1.0e-6f)
-					{
-						t = (wx * vx + wy * vy) / lengthSquared;
-						t = std::max(0.0f, std::min(1.0f, t));
-					}
-
-					const float dx = wx - t * vx;
-					const float dy = wy - t * vy;
-					const float distance = std::sqrt(dx * dx + dy * dy);
-					if (distance < bestDistance)
-					{
-						bestDistance = distance;
-						best = ref;
-					}
-				}
-			}
-		}
-
-		return best;
-	}
-
-	gd::RectF PlotView::EditFieldRect() const
-	{
-		if (m_editTarget == PlotEditTarget::NONE || m_fonts == nullptr || m_fonts->monoSmall == nullptr)
-		{
-			return gd::RectF();
-		}
-
-		const float height = 22.0f * m_scale;
-		float width = std::max(90.0f * m_scale,
-		                       UiMeasureTextWidth(m_fonts->monoSmall, m_edit.Text()) + 24.0f * m_scale);
-
-		if (m_editTarget == PlotEditTarget::CURSOR_TIME)
-		{
-			// 与显示态标签取相同宽度与位置（底部），避免进入编辑时框体跳动。
-			const int which = (m_editCursor == 2) ? 2 : 1;
-			const gd::RectF displayRect = CursorLabelRect(which);
-			width = std::max(width, displayRect.Width);
-			float left = CursorX(which) - width * 0.5f;
-			left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
-			return gd::RectF(left, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale, width,
-			                 height);
-		}
-
-		if (m_editTarget == PlotEditTarget::CURSOR_SPAN)
-		{
-			// 差值输入框落在差值标签处（时间轴上方或时间轴内部）。
-			bool insideAxis = false;
-			const gd::RectF displayRect = CursorSpanRect(insideAxis);
-			if (displayRect.Width <= 0.0f)
-			{
-				return gd::RectF();
-			}
-			width = std::max(width, displayRect.Width);
-			float left = displayRect.X + displayRect.Width * 0.5f - width * 0.5f;
-			left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
-			return gd::RectF(left, displayRect.Y, width, height);
-		}
-
-		if (m_editTarget == PlotEditTarget::SIGNAL_NAME)
-		{
-			// 图例改名：输入框直接落在被双击的图例条目位置上。
-			if (m_editFieldRect.Width <= 0.0f)
-			{
-				return gd::RectF();
-			}
-			const float nameWidth = std::max(width, m_editFieldRect.Width);
-			return gd::RectF(m_editFieldRect.X, m_editFieldRect.Y, nameWidth, height);
-		}
-
-		if (m_editTarget == PlotEditTarget::EDGE_CENTER_POINTS ||
-		    m_editTarget == PlotEditTarget::EDGE_CENTER_ITERATIONS ||
-		    m_editTarget == PlotEditTarget::MEAN_FILTER_POINTS ||
-		    m_editTarget == PlotEditTarget::MEAN_FILTER_ITERATIONS ||
-		    m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX)
-		{
-			// 「均值点数 X」/「迭代次数 N」（均值滤波、中心轴）与「迭代次数 N 上限」（弱峰调整）：
-			// 输入框都落在对应的字段/滑块行矩形上。
-			if (m_editFieldRect.Width <= 0.0f)
-			{
-				return gd::RectF();
-			}
-			const float fieldHeight = std::max(height, m_editFieldRect.Height - 4.0f * m_scale);
-			return gd::RectF(m_editFieldRect.X, m_editFieldRect.Y + 2.0f * m_scale,
-			                 m_editFieldRect.Width, fieldHeight);
-		}
-
-		// 网格 Y 轴上下限输入框：优先落在被点击的菜单条目位置，保证"就地编辑"的观感。
-		if (m_editFieldRect.Width > 0.0f && m_editFieldRect.Height > 0.0f)
-		{			float left = m_editFieldRect.X;
-			float top = m_editFieldRect.Y;
-			left = std::max(m_area.X + 2.0f * m_scale,
-			                std::min(left, m_area.X + m_area.Width - width - 2.0f * m_scale));
-			top = std::max(m_area.Y + 2.0f * m_scale,
-			               std::min(top, m_area.Y + m_area.Height - height - 2.0f * m_scale));
-			return gd::RectF(left, top, width, height);
-		}
-
-		if (m_editLane < 0 || m_editLane >= static_cast<int>(m_lanes.size()))
-		{
-			return gd::RectF();
-		}
-		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(m_editLane)];
-		const float left = lane.rect.X + kLaneLabelPad * m_scale;
-		const float top = lane.rect.Y + kLaneLabelPad * m_scale;
-		return gd::RectF(left, top, std::min(width, lane.rect.Width - 2.0f * kLaneLabelPad * m_scale), height);
-	}
-
-	bool PlotView::BeginEdit(PlotEditTarget target, int laneIndex, const std::wstring& initialText,
-	                         const gd::RectF& anchorRect)
-	{
-		if (target == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-		// 切换编辑目标时清掉上一轮残留（图例改名需由调用方在进入前先设置 m_editSignal）。
-		if (target != PlotEditTarget::SIGNAL_NAME)
-		{
-			m_editSignal = SignalRef();
-		}
-		// 调用方可以用锚点矩形指定输入框位置（如菜单条目、图例条目）；
-		// 未提供锚点时由 EditFieldRect() 按目标类型自动推导。
-		if (anchorRect.Width > 0.0f && anchorRect.Height > 0.0f)
-		{
-			m_editFieldRect = anchorRect;
-		}
-		else if (target != PlotEditTarget::SIGNAL_NAME)
-		{
-			m_editFieldRect = gd::RectF();
-		}
-		m_editTarget = target;
-		m_editLane = laneIndex;
-		// 名称与数值均不限长度（数值在提交时会做范围夹取）。
-		const bool nameField = (target == PlotEditTarget::SIGNAL_NAME);
-		m_edit.Begin(initialText, true, nameField ? EditFilter::ANY : EditFilter::NUMBER, 0u);
-		return true;
-	}
-
-	bool PlotView::TakePendingRename(SignalRef& ref, std::wstring& name)
-	{
-		if (!m_pendingRename)
-		{
-			return false;
-		}
-		ref = m_pendingRenameRef;
-		name = m_pendingRenameName;
-		m_pendingRename = false;
-		m_pendingRenameRef = SignalRef();
-		m_pendingRenameName.clear();
-		return true;
-	}
-
-	bool PlotView::EndEdit(bool commit)
-	{
-		if (m_editTarget == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-
-		const PlotEditTarget target = m_editTarget;
-		const int laneIndex = m_editLane;
-		const SignalRef editSignal = m_editSignal;
-		const std::wstring text = Trim(m_edit.Text());
-
-		m_editTarget = PlotEditTarget::NONE;
-		m_editLane = -1;
-		m_editSignal = SignalRef();
-		m_editFieldRect = gd::RectF();
-		m_peakEditCurrentMax = 0;	// 退出编辑：清除“迭代上限”输入框的灰色提示值
-		m_edit.End();
-
-		// 信号改名：交给宿主窗口落到数据层，绘图区只持有只读数据。
-		if (target == PlotEditTarget::SIGNAL_NAME)
-		{
-			if (commit && !text.empty() && editSignal.IsValid())
-			{
-				m_pendingRenameRef = editSignal;
-				m_pendingRenameName = text;
-				m_pendingRename = true;
-			}
-			return true;
-		}
-
-		double parsed = 0.0;
-		bool parsedOk = false;
-		if (commit && !text.empty())
-		{
-			wchar_t* stop = nullptr;
-			parsed = std::wcstod(text.c_str(), &stop);
-			parsedOk = (stop != text.c_str()) && (parsed == parsed) && std::isfinite(parsed);
-		}
-
-		if (!parsedOk)
-		{
-			return true;
-		}
-
-		if (target == PlotEditTarget::CURSOR_TIME)
-		{
-			double low = 0.0;
-			double high = 1.0;
-			TimeBounds(low, high);
-			const double span = std::max(high - low, kMinTimeSpan);
-			const double clamped = ClampDouble(parsed, low - span * 10.0, high + span * 10.0);
-			if (m_editCursor == 2 && Tab().CursorMode() == PlotCursorMode::DOUBLE)
-			{
-				Tab().CursorTimeAlt() = clamped;
-			}
-			else
-			{
-				Tab().CursorTime() = clamped;
-			}
-			m_activeCursor = (m_editCursor == 2) ? 2 : 1;
-			return true;
-		}
-
-		if (target == PlotEditTarget::CURSOR_SPAN)
-		{
-			// 差值编辑：输入值**始终以秒为单位**（即使界面上显示为 1.5min，编辑内容也是 90）。
-			// **前方（时间较小）的光标不动**，后方光标向后移动到"前方 + 输入差值"。
-			const double span = std::fabs(parsed);
-			const double front = std::min(Tab().CursorTime(), Tab().CursorTimeAlt());
-			const bool secondIsBack = (Tab().CursorTimeAlt() >= Tab().CursorTime());
-			const double moved = front + span;
-			if (secondIsBack)
-			{
-				Tab().CursorTime() = front;
-				Tab().CursorTimeAlt() = moved;
-			}
-			else
-			{
-				Tab().CursorTimeAlt() = front;
-				Tab().CursorTime() = moved;
-			}
-			m_activeCursor = secondIsBack ? 2 : 1;
-			return true;
-		}
-
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return true;
-		}
-
-		// 「弱峰调整」迭代次数滑块的**上限**：用户可直接输入一个正整数作为新的量程上限。
-		// 规则（用户明确要求）：
-		//   * 输入框只允许输入正整数（过滤策略为 BYTE = 纯数字，粘贴同样会被清洗）；
-		//   * 空内容 / 非法值（0、超出允许范围）→ 保持原上限不变；
-		//   * 生效后若当前迭代次数超过新上限，则自动夹到新上限。
-		if (target == PlotEditTarget::PEAK_ITERATIONS_MAX)
-		{
-			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-			const Lane::WeakPeakItem* existing = lane.FindWeakPeakItem(m_editMeanRef);
-			if (existing == nullptr)
-			{
-				return true;
-			}
-			if (parsedOk)
-			{
-				const long long value = static_cast<long long>(std::llround(parsed));
-				if (value >= kWeakPeakIterationsMin && value <= kWeakPeakIterationsMaxLimit)
-				{
-					Lane::WeakPeakItem& item = lane.EnsureWeakPeakItem(m_editMeanRef);
-					item.maxIterations = static_cast<int>(value);
-					// 当前值超出新上限 → 自动替换为上界。
-					item.iterations = std::max(kWeakPeakIterationsMin,
-					                           std::min(item.maxIterations, item.iterations));
-					// 曲线可能因迭代次数被夹取而变化，缓存整体作废最稳妥。
-					m_weakPeakCurveCache.clear();
-				}
-			}
-			return true;
-		}
-
-		// 「均值点数 X」/「迭代次数 N」：作用于被勾选信号的均值滤波曲线，夹在合理范围内。
-		// 「中心轴边沿计数」用**完全相同的参数与语义**，只是作用于自己的条目列表。
-		const bool centerTarget =
-		    (target == PlotEditTarget::EDGE_CENTER_POINTS || target == PlotEditTarget::EDGE_CENTER_ITERATIONS);
-		if (target == PlotEditTarget::MEAN_FILTER_POINTS || target == PlotEditTarget::MEAN_FILTER_ITERATIONS ||
-		    centerTarget)
-		{
-			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-			const bool isPoints = (target == PlotEditTarget::MEAN_FILTER_POINTS ||
-			                       target == PlotEditTarget::EDGE_CENTER_POINTS);
-			const Lane::MeanFilterItem* existing = centerTarget ? lane.FindEdgeCenterItem(m_editMeanRef)
-			                                                   : lane.FindMeanFilterItem(m_editMeanRef);
-			if (existing == nullptr)
-			{
-				return true;
-			}
-			const int maximum = isPoints ? 1000000 : 1000;
-			int value = static_cast<int>(std::lround(parsed));
-			// 迭代次数至少为 1（1 次迭代等于不做滤波）；均值点数可以为 0。
-			value = isPoints ? std::max(0, std::min(value, maximum))
-			                 : std::max(1, std::min(value, maximum));
-
-			Lane::MeanFilterItem& item = centerTarget ? lane.EnsureEdgeCenterItem(m_editMeanRef)
-			                                         : lane.EnsureMeanFilterItem(m_editMeanRef);
-			if (isPoints)
-			{
-				item.points = value;
-			}
-			else
-			{
-				item.iterations = value;
-			}
-			// ⚠️ **只作废被改动的那个信号**的统计状态。
-			//    过去的 `m_edgeScans.clear()` 会把两个面板里**所有**信号的统计一起丢掉，
-			//    于是改一个信号的参数会让其余未改参数的统计也从头重扫（用户报告的缺陷）。
-			m_meanCurveCache.clear();
-			if (centerTarget)
-			{
-				InvalidateEdgeScansFor(ResolveSignal(m_editMeanRef).data, true);
-			}
-			return true;
-		}
-
-		// 直接输入上下限：先固化当前范围，再用新值替换对应端点（保证 max > min）。
-		if (laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return true;
-		}
-		const LaneVisual& visual = m_lanes[static_cast<std::size_t>(laneIndex)];
-		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		// 直接输入上下限属于手动调整幅值：关闭本网格的「选区 Y 轴自适应」。
-		lane.fitYToSelection = false;
-		if (lane.autoRange)
-		{
-			lane.autoRange = false;
-			lane.yMin = visual.yMin;
-			lane.yMax = visual.yMax;
-		}
-
-		const double magnitude = std::max(std::fabs(lane.yMin), std::fabs(lane.yMax));
-		const double minimumGap = std::max(magnitude * 1.0e-6, 1.0e-12);
-
-		if (target == PlotEditTarget::LANE_Y_MAX)
-		{
-			if (parsed <= lane.yMin)
-			{
-				parsed = lane.yMin + minimumGap;
-			}
-			lane.yMax = parsed;
-		}
-		else
-		{
-			if (parsed >= lane.yMax)
-			{
-				parsed = lane.yMax - minimumGap;
-			}
-			lane.yMin = parsed;
-		}
-
-		BuildLaneVisuals();
-		return true;
-	}
-
-	bool PlotView::OnEditChar(wchar_t character)
-	{
-		if (m_editTarget == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-
-		// 剪贴板与全选快捷键经 WM_CHAR 送达（Ctrl+C/X/V/A 分别对应 3/24/22/1）。
-		switch (character)
-		{
-		case 0x03: // Ctrl+C
-			m_edit.CopyToClipboard(m_host);
-			return false;
-		case 0x18: // Ctrl+X
-			return m_edit.CutToClipboard(m_host);
-		case 0x16: // Ctrl+V
-			return m_edit.PasteFromClipboard(m_host);
-		case 0x01: // Ctrl+A
-			m_edit.SelectAll();
-			return true;
-		default:
-			break;
-		}
-
-		if (character == L'\r' || character == L'\n')
-		{
-			return EndEdit(true);
-		}
-		// 退格/删除已由 WM_KEYDOWN 的 OnEditKey 处理，此处忽略控制字符避免重复删除。
-		if (character < 0x20 || character == 0x7F)
-		{
-			return false;
-		}
-		return m_edit.Insert(character);
-	}
-
-	bool PlotView::CollapseEditSelectionToEnd()
-	{
-		if (m_editTarget == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-		return m_edit.DeselectToEnd();
-	}
-
-	bool PlotView::OnEditMouseDown(int x, int y)
-	{
-		if (m_editTarget == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-		const gd::RectF rect = EditFieldRect();
-		if (rect.Width <= 0.0f)
-		{
-			return false;
-		}
-		return UiEditFieldMouseDown(m_fonts->uiSmall, rect, m_edit, m_scale, x, y);
-	}
-
-	bool PlotView::OnEditMouseMove(int x)
-	{
-		if (m_editTarget == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-		const gd::RectF rect = EditFieldRect();
-		if (rect.Width <= 0.0f)
-		{
-			return false;
-		}
-		return UiEditFieldMouseMove(m_fonts->uiSmall, rect, m_edit, m_scale, x);
-	}
-
-	bool PlotView::OnEditMouseUp()
-	{
-		if (!m_edit.Dragging())
-		{
-			return false;
-		}
-		m_edit.EndDrag();
-		return true;
-	}
-
-	bool PlotView::OnEditKey(WPARAM key)
-	{
-		if (m_editTarget == PlotEditTarget::NONE)
-		{
-			return false;
-		}
-
-		const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
-		const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
-
-		switch (key)
-		{
-		case VK_RETURN:
-			return EndEdit(true);
-		case VK_ESCAPE:
-			return EndEdit(false);
-		case VK_BACK:
-			return m_edit.Backspace();
-		case VK_DELETE:
-			return m_edit.DeleteForward();
-		case VK_LEFT:
-			return m_edit.MoveCaret(-1, shift);
-		case VK_RIGHT:
-			return m_edit.MoveCaret(1, shift);
-		case VK_HOME:
-			return m_edit.MoveHome(shift);
-		case VK_END:
-			return m_edit.MoveEnd(shift);
-		case 'A':
-			if (control)
-			{
-				m_edit.SelectAll();
-			}
-			return true;
-		default:
-			break;
-		}
-		return true;
-	}
-
-	bool PlotView::HitTest(int x, int y) const
-	{
-		return UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y));
-	}
-
-	HCURSOR PlotView::QueryCursor(int x, int y) const
-	{
-		switch (m_dragMode)
-		{
-		case PlotDragMode::PAN:
-			return LoadCursorW(nullptr, IDC_SIZEALL);
-		case PlotDragMode::RUBBER_SELECT:
-			// 选区放大：轴向未定时为十字，确定后按方向给出上下/左右箭头。
-			if (m_rubberAxis == PlotRubberAxis::VALUE)
-			{
-				return LoadCursorW(nullptr, IDC_SIZENS);
-			}
-			if (m_rubberAxis == PlotRubberAxis::TIME)
-			{
-				return LoadCursorW(nullptr, IDC_SIZEWE);
-			}
-			return LoadCursorW(nullptr, IDC_CROSS);
-		case PlotDragMode::SCROLL_LANES:
-			return LoadCursorW(nullptr, IDC_SIZENS);
-		case PlotDragMode::CURSOR_MOVE:
-			// 光标拖拽（无论是抓住光标线还是抓住时间读数标签）都沿时间轴移动 → 左右箭头。
-			return LoadCursorW(nullptr, IDC_SIZEWE);
-		case PlotDragMode::CURSOR_SPAN_MOVE:
-			// 差值标签拖拽：两条光标整体沿时间轴平移 → 左右箭头。
-			return LoadCursorW(nullptr, IDC_SIZEWE);
-		case PlotDragMode::PEAK_LEVEL:
-		case PlotDragMode::PEAK_ITERATIONS:
-			// 「弱峰调整」滑块拖拽 → 左右箭头。
-			return LoadCursorW(nullptr, IDC_SIZEWE);
-		case PlotDragMode::MOVE_SIGNAL:
-			// 拖动信号（参考 Photoshop 平移元素的抓握光标）。
-			return LoadCursorW(nullptr, IDC_SIZEALL);
-		case PlotDragMode::EDGE_MOVE:
-			// 「边沿计数」横向光标：上下移动幅值。
-			return LoadCursorW(nullptr, IDC_SIZENS);
-		case PlotDragMode::EDGE_PANEL_MOVE:
-			// 边沿统计浮动面板：可自由拖动。
-			return LoadCursorW(nullptr, IDC_SIZEALL);
-		case PlotDragMode::LANE_REORDER:
-			// 网格次序拖拽：上下箭头（只能上下移动）。
-			return LoadCursorW(nullptr, IDC_SIZENS);
-		default:
-			break;
-		}
-
-		if (m_scrollBarVisible &&
-		    UiPointInRect(m_scrollBarRect, static_cast<float>(x), static_cast<float>(y)))
-		{
-			return LoadCursorW(nullptr, IDC_SIZENS);
-		}
-
-		// 实验性功能面板与横向光标优先于信号悬停提示判定（面板会盖住波形）。
-		// 面板**只有标题栏**可以拖拽（显示抓握光标）；✕ 与面板主体一律保持原始箭头。
-		if (m_tab != nullptr)
-		{
-			// 按**层序从上层往下**判定，重叠时以最上层的面板为准。
-			int panelLane = -1;
-			int panelKind = 0;
-			if (TopPanelAtPoint(static_cast<float>(x), static_cast<float>(y), panelLane, panelKind))
-			{
-				const EdgePanelLayout layout =
-				    EdgePanelLayoutFor(panelLane, static_cast<EdgePanelKind>(panelKind));
-				if (UiPointInRect(layout.close, static_cast<float>(x), static_cast<float>(y)))
-				{
-					// ✕ 按钮：与面板/标签栏的其它 ✕ 一致，用手型光标作为可点击提示。
-					return LoadCursorW(nullptr, IDC_HAND);
-				}
-				if (UiPointInRect(layout.title, static_cast<float>(x), static_cast<float>(y)))
-				{
-					return LoadCursorW(nullptr, IDC_SIZEALL);
-				}
-				if ((static_cast<EdgePanelKind>(panelKind) == EdgePanelKind::MEAN ||
-				     static_cast<EdgePanelKind>(panelKind) == EdgePanelKind::PEAK) &&
-				    layout.button.Width > 0.0f &&
-				    UiPointInRect(layout.button, static_cast<float>(x), static_cast<float>(y)))
-				{
-					// 「构建为新信号」按钮：手型光标作为可点击提示。
-					return LoadCursorW(nullptr, IDC_HAND);
-				}
-				// 「弱峰调整」的逐信号滑块：轨道 → 左右箭头；迭代次数右侧数值 → 手型（可点击改上限）。
-				if (static_cast<EdgePanelKind>(panelKind) == EdgePanelKind::PEAK)
-				{
-					for (std::size_t rowIndex = 0; rowIndex < layout.rowIterValues.size(); ++rowIndex)
-					{
-						if (layout.rowIterValues[rowIndex].Width > 0.0f &&
-						    UiPointInRect(layout.rowIterValues[rowIndex], static_cast<float>(x),
-						                  static_cast<float>(y)))
-						{
-							return LoadCursorW(nullptr, IDC_HAND);
-						}
-						// 两行滑块右侧的**复位控件**：与其它可点击图标一致，用手型光标提示可点击。
-						if (rowIndex < layout.rowLevelResets.size() &&
-						    layout.rowLevelResets[rowIndex].Width > 0.0f &&
-						    UiPointInRect(layout.rowLevelResets[rowIndex], static_cast<float>(x),
-						                  static_cast<float>(y)))
-						{
-							return LoadCursorW(nullptr, IDC_HAND);
-						}
-						if (rowIndex < layout.rowIterResets.size() &&
-						    layout.rowIterResets[rowIndex].Width > 0.0f &&
-						    UiPointInRect(layout.rowIterResets[rowIndex], static_cast<float>(x),
-						                  static_cast<float>(y)))
-						{
-							return LoadCursorW(nullptr, IDC_HAND);
-						}
-						if (rowIndex < layout.rowIterTracks.size() &&
-						    WeakPeakSliderHit(layout.rowIterTracks[rowIndex], m_scale,
-						                      static_cast<float>(x), static_cast<float>(y)))
-						{
-							return LoadCursorW(nullptr, IDC_SIZEWE);
-						}
-						if (rowIndex < layout.rowLevelTracks.size() &&
-						    WeakPeakSliderHit(layout.rowLevelTracks[rowIndex], m_scale,
-						                      static_cast<float>(x), static_cast<float>(y)))
-						{
-							return LoadCursorW(nullptr, IDC_SIZEWE);
-						}
-					}
-				}
-				// 面板主体（含底部编辑行与参数输入框）：保持原始箭头。
-				return nullptr;
-			}
-			int edgeLane = -1;
-			if (IsOnEdgeCursorLine(x, y, edgeLane))
-			{
-				return LoadCursorW(nullptr, IDC_SIZENS);
-			}
-		}
-
-		// 图例中的「GX」编号徽标：**悬停时不改变鼠标形状**（用户明确要求：只在按下左键
-		// 拖拽时才显示上下箭头，见 `LANE_REORDER` 分支）。这里保持“不改变”的语义并
-		// **提前返回**（不再往下落到光标线/图例判定），与原先的优先级完全一致。
-		if (LaneBadgeAtPoint(x, y) >= 0)
-		{
-			return nullptr;
-		}
-
-		// 光标时间读数标签与双光标差值标签：**悬停（未按下）时不改变鼠标形状**。
-		// 两个标签都叠在光标线的正上方，因此必须先于"光标线"判定返回 nullptr，
-		// 由调用方回退成箭头；只有真正拖拽时才切成左右箭头（见 CURSOR_MOVE / CURSOR_SPAN_MOVE）。
-		if (IsOnCursorSpanLabel(x, y))
-		{
-			return nullptr;
-		}
-		{
-			int labelWhich = 0;
-			if (IsOnCursorTimeLabel(x, y, labelWhich))
-			{
-				return nullptr;
-			}
-		}
-
-		{
-			int cursorWhich = 0;
-			if (IsOnCursorLine(x, cursorWhich) && UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y)))
-			{
-				return LoadCursorW(nullptr, IDC_SIZEWE);
-			}
-		}
-
-		if (UiPointInRect(m_plotRect, static_cast<float>(x), static_cast<float>(y)))
-		{
-			// 悬停命中可拖拽信号时**不改变鼠标形状**（维持原始箭头）；
-			// 只有真正按下拖动（MOVE_SIGNAL）才切换为抓握光标。
-			// 悬停图例时同样保持箭头，仅做半高亮提示。
-
-			// 选区放大模式下**未开始框选时保持默认箭头**（不改变鼠标形状）；
-			// 只有真正按下并拖动后才切成十字/方向箭头。
-			// （m_dragMode == RUBBER_SELECT 的情况已在上面处理。）
-		}
-		return nullptr;
-	}
-
-	bool PlotView::OnMouseMove(int x, int y)
-	{
-		const bool mouseMoved = (x != m_mouseX) || (y != m_mouseY);
-		m_mouseX = x;
-		m_mouseY = y;
-
-		if (!HasDrawableContent())
-		{
-			return false;
-		}
-
-		const float fx = static_cast<float>(x);
-
-		switch (m_dragMode)
-		{
-		case PlotDragMode::PAN:
-		{
-			if (m_plotRect.Width <= 0.0f)
-			{
-				return false;
-			}
-
-			// 横向拖动平移时间轴；纵向拖动偏移当前网格的幅值显示位置。
-			const double span = Tab().ViewMax() - Tab().ViewMin();
-			const double delta =
-			    -static_cast<double>(x - m_dragLastX) / static_cast<double>(m_plotRect.Width) * span;
-			if (delta != 0.0)
-			{
-				Tab().ViewMin() += delta;
-				Tab().ViewMax() += delta;
-				ClampTimeView();
-			}
-
-			const int laneIndex = m_dragLane;
-			if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()) && y != m_dragLastY)
-			{
-				const LaneVisual& visual = m_lanes[static_cast<std::size_t>(laneIndex)];
-				if (visual.rect.Height > 0.0f)
-				{
-					const double valueSpan = visual.yMax - visual.yMin;
-					const double deltaValue = static_cast<double>(y - m_dragLastY) /
-					                          static_cast<double>(visual.rect.Height) * valueSpan;
-					ShiftLaneRange(laneIndex, deltaValue);
-				}
-			}
-
-			m_dragLastX = x;
-			m_dragLastY = y;
-			if (std::abs(x - m_dragStartX) > 3 || std::abs(y - m_dragStartY) > 3)
-			{
-				m_dragMoved = true;
-			}
-			return true;
-		}
-		case PlotDragMode::RUBBER_SELECT:
-		{
-			const float dx = static_cast<float>(x - m_dragStartX);
-			const float dy = static_cast<float>(y - m_dragStartY);
-
-			// 轴向由首次明显位移决定，之后固定不变（避免拖拽中途选区形态跳变）。
-			if (m_rubberAxis == PlotRubberAxis::UNDECIDED)
-			{
-				const float threshold = 4.0f * m_scale;
-				if (std::fabs(dx) < threshold && std::fabs(dy) < threshold)
-				{
-					return true;
-				}
-				m_rubberAxis = (std::fabs(dx) >= std::fabs(dy)) ? PlotRubberAxis::TIME : PlotRubberAxis::VALUE;
-			}
-
-			if (m_rubberAxis == PlotRubberAxis::TIME)
-			{
-				// 竖向选区贯穿整个绘图区高度，只取横向区间用于时间轴缩放。
-				// **横向必须夹在绘图区内**：鼠标被捕获时可能移动到工具栏 / 信号面板等处，
-				// 若不夹取，选区会画到绘图区之外（那些区域只会被局部失效，于是残留成"绘制错误"）。
-				const float plotLeft = m_plotRect.X;
-				const float plotRight = m_plotRect.X + m_plotRect.Width;
-				const float from = ClampDouble(static_cast<double>(m_dragStartX),
-				                               static_cast<double>(plotLeft),
-				                               static_cast<double>(plotRight));
-				const float to = ClampDouble(static_cast<double>(x), static_cast<double>(plotLeft),
-				                             static_cast<double>(plotRight));
-				const float left = std::min(from, to);
-				const float width = std::fabs(to - from);
-				m_rubberRect = gd::RectF(left, m_plotRect.Y, width, m_plotRect.Height);
-			}
-			else
-			{
-				// 横向选区限定在按下时的网格内（纵向同样夹在该网格内），只取纵向区间用于幅值轴缩放。
-				if (m_dragLane < 0 || m_dragLane >= static_cast<int>(m_lanes.size()))
-				{
-					return false;
-				}
-				const gd::RectF& laneRect = m_lanes[static_cast<std::size_t>(m_dragLane)].rect;
-				const float from = ClampDouble(static_cast<double>(m_dragStartY),
-				                               static_cast<double>(laneRect.Y),
-				                               static_cast<double>(laneRect.Y + laneRect.Height));
-				const float to = ClampDouble(static_cast<double>(y), static_cast<double>(laneRect.Y),
-				                             static_cast<double>(laneRect.Y + laneRect.Height));
-				const float top = std::min(from, to);
-				const float bottom = std::max(from, to);
-				m_rubberRect = gd::RectF(laneRect.X, top, laneRect.Width, bottom - top);
-			}
-			m_dragMoved = true;
-			// 拖动过程中维持显示"右键取消选区"说明（粘滞，直到松开左键后才淡出）。
-			SetHintSticky(L"右键取消选区，ESC退出选区模式");
-			return true;
-		}
-		case PlotDragMode::SCROLL_LANES:
-		{
-			if (m_plotRect.Height <= 0.0f || m_laneContentHeight <= m_plotRect.Height)
-			{
-				return false;
-			}
-			const double travel =
-			    static_cast<double>(y - m_dragLastY) / static_cast<double>(m_plotRect.Height);
-			Tab().LaneScroll() += static_cast<float>(travel * m_laneContentHeight);
-			m_dragLastY = y;
-			m_dragMoved = true;
-			BuildLaneVisuals();
-			return true;
-		}
-		case PlotDragMode::CURSOR_MOVE:
-		{
-			// 从时间读数标签上抓起时保留横向抓取偏移，避免一按下光标就跳到鼠标中心。
-			const double target = XToTime(fx - static_cast<float>(m_cursorGrabOffset));
-			const bool second =
-			    (m_hoverCursor == 2 && Tab().CursorMode() == PlotCursorMode::DOUBLE);
-			// 吸附 + 夹取统一在 `PlaceCursorTime` 里完成（光标位置不变量只在那里维护）：
-			//  * 吸附只接受可见区间内、且视界内还能分辨的采样点；
-			//  * 结果必定落在当前可见区间内（否则用户看到的是一拖就"飞到视界边缘"）。
-			PlaceCursorTime(second ? 2 : 1, target);
-			m_dragMoved = true;
-			m_cursorHover = true;
-			return true;
-		}
-		case PlotDragMode::CURSOR_SPAN_MOVE:
-		{
-			// 拖拽差值标签：两条光标整体平移，间隔保持不变。
-			const double startTime = XToTime(static_cast<float>(m_spanDragStartX));
-			const double delta = XToTime(fx) - startTime;
-			double first = m_spanDragTime1 + delta;
-			double second = m_spanDragTime2 + delta;
-			// 整体平移后同样不能越出可视区：先尝试保持间隔地整体夹取，
-			// 两光标间隔本身就大于可视跨度时退化为各自夹取。
-			const double low = Tab().ViewMin();
-			const double high = Tab().ViewMax();
-			if (high > low)
-			{
-				const double inset = (high - low) * 0.002;
-				const double lo = low + inset;
-				const double hi = high - inset;
-				const double pairLow = std::min(first, second);
-				const double pairHigh = std::max(first, second);
-				if (pairHigh - pairLow <= hi - lo)
-				{
-					if (pairLow < lo)
-					{
-						first += lo - pairLow;
-						second += lo - pairLow;
-					}
-					else if (pairHigh > hi)
-					{
-						first -= pairHigh - hi;
-						second -= pairHigh - hi;
-					}
-				}
-				else
-				{
-					first = ClampDouble(first, lo, hi);
-					second = ClampDouble(second, lo, hi);
-				}
-			}
-			Tab().CursorTime() = first;
-			Tab().CursorTimeAlt() = second;
-			m_dragMoved = true;
-			return true;
-		}
-		case PlotDragMode::PEAK_LEVEL:
-		{
-			// 「弱峰调整」某信号的等级滑块：按滑轨横向位置换算 -400% – +400%。
-			if (m_tab == nullptr || m_peakDragLane < 0 ||
-			    m_peakDragLane >= static_cast<int>(m_tab->Lanes().size()))
-			{
-				break;
-			}
-			const EdgePanelLayout layout = EdgePanelLayoutFor(m_peakDragLane, EdgePanelKind::PEAK);
-			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_peakDragLane)];
-			if (lane.FindWeakPeakItem(m_peakDragRef) == nullptr)
-			{
-				break;
-			}
-			Lane::WeakPeakItem& item = lane.EnsureWeakPeakItem(m_peakDragRef);
-			const int rowIndex = PeakRowIndexOf(layout, m_peakDragRef);
-			if (rowIndex < 0 || rowIndex >= static_cast<int>(layout.rowLevelTracks.size()) ||
-			    layout.rowLevelTracks[static_cast<std::size_t>(rowIndex)].Width <= 0.0f)
-			{
-				break;
-			}
-			const double ratio =
-			    UiSliderRatioFromX(layout.rowLevelTracks[static_cast<std::size_t>(rowIndex)], fx);
-			// 滑块量程 -200% – +200%：0 在正中间。
-			// 滑块量程 -400% – +400%（三组规则的梯度区间）：0 在正中间。
-			item.amountPercent = std::max(
-			    kWeakPeakAmountMin,
-			    std::min(kWeakPeakAmountMax,
-			             static_cast<int>(std::lround((ratio * 2.0 - 1.0) * 100.0 * kWeakPeakSliderScale))));
-			m_weakPeakCurveCache.clear();
-			m_dragMoved = true;
-			return true;
-		}
-		case PlotDragMode::PEAK_ITERATIONS:
-		{
-			// 「弱峰调整」某信号的迭代次数滑块：量程为 1 … 该信号自己的上限。
-			if (m_tab == nullptr || m_peakDragLane < 0 ||
-			    m_peakDragLane >= static_cast<int>(m_tab->Lanes().size()))
-			{
-				break;
-			}
-			const EdgePanelLayout layout = EdgePanelLayoutFor(m_peakDragLane, EdgePanelKind::PEAK);
-			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_peakDragLane)];
-			if (lane.FindWeakPeakItem(m_peakDragRef) == nullptr)
-			{
-				break;
-			}
-			Lane::WeakPeakItem& item = lane.EnsureWeakPeakItem(m_peakDragRef);
-			const int rowIndex = PeakRowIndexOf(layout, m_peakDragRef);
-			if (rowIndex < 0 || rowIndex >= static_cast<int>(layout.rowIterTracks.size()) ||
-			    layout.rowIterTracks[static_cast<std::size_t>(rowIndex)].Width <= 0.0f)
-			{
-				break;
-			}
-			const double ratio =
-			    UiSliderRatioFromX(layout.rowIterTracks[static_cast<std::size_t>(rowIndex)], fx);
-			const int peakMax = std::max(kWeakPeakIterationsMin,
-			                             std::min(kWeakPeakIterationsMaxLimit, item.maxIterations));
-			item.iterations = std::max(
-			    kWeakPeakIterationsMin,
-			    std::min(peakMax, kWeakPeakIterationsMin +
-			                          static_cast<int>(std::lround(
-			                              ratio * (peakMax - kWeakPeakIterationsMin)))));
-			m_weakPeakCurveCache.clear();
-			m_dragMoved = true;
-			return true;
-		}
-		case PlotDragMode::MOVE_SIGNAL:
-		{
-			const int target = LaneAtY(y);
-			m_dragMoved = true;
-			m_dragMouseX = x;
-			m_dragMouseY = y;
-			if (target != m_dragTargetLane)
-			{
-				m_dragTargetLane = target;
-			}
-			return true;
-		}
-		case PlotDragMode::LANE_REORDER:
-		{
-			// 被拖拽的网格自由跟随鼠标；目标位置变化时其它网格实时让位（吸附）。
-			m_laneDragMouseY = y;
-			const int target = LaneDragTargetAt(y);
-			if (target != m_laneDragTarget)
-			{
-				m_laneDragTarget = target;
-			}
-			m_dragMoved = true;
-			return true;
-		}
-		case PlotDragMode::EDGE_MOVE:
-		{
-			// 横向光标：上下移动幅值（夹在该网格的可见幅值范围内）。
-			if (m_tab == nullptr || m_edgeDragLane < 0 ||
-			    m_edgeDragLane >= static_cast<int>(m_lanes.size()) ||
-			    m_edgeDragLane >= static_cast<int>(m_tab->Lanes().size()))
-			{
-				break;
-			}
-			const LaneVisual& visual = m_lanes[static_cast<std::size_t>(m_edgeDragLane)];
-			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_edgeDragLane)];
-			double value = YToValue(static_cast<float>(y), visual);
-			const double low = std::min(visual.yMin, visual.yMax);
-			const double high = std::max(visual.yMin, visual.yMax);
-			value = std::max(low, std::min(value, high));
-			lane.edgeValue = value;
-			lane.edgeValueValid = true;
-			m_dragMoved = true;
-			return true;
-		}
-		case PlotDragMode::EDGE_PANEL_MOVE:
-		{
-			// 浮动面板：**只能从标题栏拖动**（按下时已限制），整体限制在绘图区内。
-			if (m_tab == nullptr || m_edgePanelDragLane < 0 ||
-			    m_edgePanelDragLane >= static_cast<int>(m_tab->Lanes().size()))
-			{
-				break;
-			}
-			const gd::RectF panel =
-			    EdgePanelLayoutFor(m_edgePanelDragLane, m_edgePanelDragKind).panel;
-			if (panel.Width <= 0.0f)
-			{
-				break;
-			}
-			float left = static_cast<float>(x) - m_edgePanelDragOffset.X;
-			float top = static_cast<float>(y) - m_edgePanelDragOffset.Y;
-			left = std::max(m_plotRect.X + 2.0f * m_scale,
-			                std::min(left, m_plotRect.X + m_plotRect.Width - panel.Width - 2.0f * m_scale));
-			top = std::max(m_plotRect.Y + 2.0f * m_scale,
-			               std::min(top, m_plotRect.Y + m_plotRect.Height - panel.Height - 2.0f * m_scale));
-			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_edgePanelDragLane)];
-			switch (m_edgePanelDragKind)
-			{
-			case EdgePanelKind::CENTER:
-				lane.edgeCenterPanelX = left;
-				lane.edgeCenterPanelY = top;
-				break;
-			case EdgePanelKind::MEAN:
-				lane.meanFilterPanelX = left;
-				lane.meanFilterPanelY = top;
-				break;
-			case EdgePanelKind::PEAK:
-				lane.weakPeakPanelX = left;
-				lane.weakPeakPanelY = top;
-				break;
-			case EdgePanelKind::COUNT:
-			default:
-				lane.edgePanelX = left;
-				lane.edgePanelY = top;
-				break;
-			}
-			m_dragMoved = true;
-			return true;
-		}
-		case PlotDragMode::NONE:
-		default:
-			break;
-		}
-
-		bool changed = false;
-
-		// 鼠标压在实验性功能面板上时不再触发信号悬停提示（面板本来就盖住波形），
-		// 但该面板所属的网格仍然要高亮（与鼠标直接停在网格上一致）。
-		// 按**层序**取最上层的面板（与点击命中保持一致，重叠时以最上层为准）。
-		bool overEdgePanel = false;
-		int panelLane = -1;
-		int hoverPanelKind = 0;
-		{
-			overEdgePanel = TopPanelAtPoint(static_cast<float>(x), static_cast<float>(y), panelLane,
-			                                hoverPanelKind);
-		}
-
-		// 「弱峰调整」每行滑块右侧的**复位控件**：悬停时给出一次性提示（进入时设置、离开时清除）。
-		// 与「系数/偏移」二级面板标题栏的还原图标同一交互语义（悬停高亮 + 手型 + 提示）。
-		bool overPeakReset = false;
-		if (overEdgePanel && panelLane >= 0 && m_tab != nullptr &&
-		    static_cast<EdgePanelKind>(hoverPanelKind) == EdgePanelKind::PEAK)
-		{
-			const EdgePanelLayout resetLayout = EdgePanelLayoutFor(panelLane, EdgePanelKind::PEAK);
-			for (std::size_t rowIndex = 0; rowIndex < resetLayout.rowLevelResets.size(); ++rowIndex)
-			{
-				const gd::RectF& level = resetLayout.rowLevelResets[rowIndex];
-				if (level.Width > 0.0f && UiPointInRect(level, fx, static_cast<float>(y)))
-				{
-					overPeakReset = true;
-					break;
-				}
-				if (rowIndex < resetLayout.rowIterResets.size())
-				{
-					const gd::RectF& iter = resetLayout.rowIterResets[rowIndex];
-					if (iter.Width > 0.0f && UiPointInRect(iter, fx, static_cast<float>(y)))
-					{
-						overPeakReset = true;
-						break;
-					}
-				}
-			}
-		}
-		if (overPeakReset != m_peakResetHover)
-		{
-			m_peakResetHover = overPeakReset;
-			SetHint(overPeakReset ? std::wstring(L"点击恢复该参数的默认值") : std::wstring());
-			changed = true;
-		}
-
-		// 悬停网格：**只有**鼠标悬停在实验性功能浮动面板上时才高亮该面板所属网格。
-		// ⚠️ 用户 2026-10-15 明确要求：鼠标在网格里移动**不再触发**网格变色高亮；
-		//    改为在信号列表 / 样式区「目标」行悬停到某条已绘制信号时联动高亮
-		//    （见 `SetExternalHoverSignal` 与 `EffectiveHoverLane`）。
-		const int lane = overEdgePanel ? panelLane : -1;
-		if (lane != m_hoverLane)
-		{
-			m_hoverLane = lane;
-			changed = true;
-		}
-
-		// 「GX」编号徽标的悬停高亮：徽标本体在静态场景 / 装饰缓存里被冻结，高亮是叠加层，
-		// 因此必须靠这个**单独的状态**触发重绘与取消。徽标命中的网格直接用鼠标纵坐标算，
-		// 与上面的「悬停网格高亮」解耦（后者已不再跟随鼠标位置）。
-		int hoverBadge = -1;
-		if (m_dragMode == PlotDragMode::NONE && !overEdgePanel)
-		{
-			const int underMouse = LaneAtY(y);
-			if (underMouse >= 0)
-			{
-				const gd::RectF badge = LaneBadgeRect(underMouse);
-				if (badge.Width > 0.0f &&
-				    UiPointInRect(badge, static_cast<float>(x), static_cast<float>(y)))
-				{
-					hoverBadge = underMouse;
-				}
-			}
-		}
-		if (hoverBadge != m_hoverBadge)
-		{
-			m_hoverBadge = hoverBadge;
-			changed = true;
-		}
-
-		// ✕ 关闭按钮 / 等级与迭代次数滑块 / 底部按钮的悬停提示都直接依赖鼠标坐标，
-		// 但它们在面板内部移动时上面这些状态可能毫无变化（例如从同一网格的波形移到面板上），
-		// 于是返回值恒为 false → 宿主不重绘 → **悬停提示不会出现**。
-		// 因此在“鼠标进入 / 离开 / 在面板内移动”时强制标记需要重绘。
-		if ((overEdgePanel || m_mouseOverPanel) && mouseMoved)
-		{
-			changed = true;
-		}
-		m_mouseOverPanel = overEdgePanel;
-
-		// 时间光标不再跟随鼠标移动，仅在鼠标覆盖光标时才显示具体时间读数。
-		int hoverWhich = 0;
-		const bool hover = Tab().CursorEnabled() && IsOnCursorLine(x, hoverWhich);
-		if (hover != m_cursorHover)
-		{
-			m_cursorHover = hover;
-			changed = true;
-		}
-		if (hoverWhich != m_hoverCursor)
-		{
-			m_hoverCursor = hoverWhich;
-			changed = true;
-		}
-
-		// 精确检测鼠标是否贴近某条信号曲线，用于给出可拖拽提示。
-		// 图例优先于曲线：图例条目是可点选目标（与左侧信号列表一致），
-		// 但悬停图例时**只做半高亮提示**，不显示曲线拖拽提示（也不触发光晕）。
-		// **图例悬停在选区放大模式下同样生效**（该模式只改变拖拽语义）。
-		SignalRef hoverSignal;
-		SignalRef hoverLegend;
-		if (!m_cursorHover && !overEdgePanel)
-		{
-			hoverLegend = LegendAtPoint(x, y);
-			if (!hoverLegend.IsValid() && Tab().ZoomMode() == PlotZoomMode::NONE)
-			{
-				hoverSignal = HitTestSignal(x, y);
-			}
-		}
-		if (hoverSignal != m_hoverSignal)
-		{
-			m_hoverSignal = hoverSignal;
-			changed = true;
-		}
-		if (hoverLegend != m_hoverLegend)
-		{
-			m_hoverLegend = hoverLegend;
-			changed = true;
-		}
-
-		// 双光标差值标签的悬停状态（用于区分"抓握/悬停"光标与普通状态）。
-		const bool spanHover = IsOnCursorSpanLabel(x, y);
-		if (spanHover != m_spanHover)
-		{
-			m_spanHover = spanHover;
-			changed = true;
-		}
-
-		// 悬停提示跟随鼠标：只要提示可见，鼠标移动本身就要触发重绘；
-		// 否则鼠标在可拖拽区域内继续移动时，提示会停在上一帧的位置。
-		if (m_hoverSignal.IsValid() && mouseMoved)
-		{
-			changed = true;
-		}
-		return changed;
-	}
-
-	bool PlotView::OnLButtonDown(int x, int y)
-	{
-		if (!HasDrawableContent())
-		{
-			return false;
-		}
-
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-
-		m_dragStartX = x;
-		m_dragStartY = y;
-		m_dragLastX = x;
-		m_dragLastY = y;
-		m_dragMoved = false;
-		m_rubberRect = gd::RectF();
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-		m_cursorGrabOffset = 0;
-		// 新的交互开始：清掉上一次留下的提示（拖动过程中会重新设置粘滞提示）。
-		SetHint(std::wstring());
-		// 上一轮尚未抬起确认的面板关闭请求一律作废。
-		m_pendingPanelClose = false;
-		m_pendingPanelCloseLane = -1;
-
-		if (m_scrollBarVisible &&
-		    UiPointInRect(m_scrollBarRect, static_cast<float>(x), static_cast<float>(y)))
-		{
-			m_dragMode = PlotDragMode::SCROLL_LANES;
-			return true;
-		}
-
-		// 内联输入中：输入框之外的点击视为提交（与线宽输入一致）。
-		if (IsEditing())
-		{
-			if (!UiPointInRect(EditFieldRect(), fx, fy))
-			{
-				EndEdit(true);
-			}
-			return true;
-		}
-
-		// 双光标模式下先检查差值标签：它可拖拽（两条光标整体平移，间隔不变）。
-		if (IsOnCursorSpanLabel(x, y))
-		{
-			m_dragMode = PlotDragMode::CURSOR_SPAN_MOVE;
-			m_spanDragStartX = x;
-			m_spanDragTime1 = Tab().CursorTime();
-			m_spanDragTime2 = Tab().CursorTimeAlt();
-			return true;
-		}
-
-		// 光标时间读数标签：可直接抓住拖动（与抓住光标线等价）。
-		{
-			int labelWhich = 0;
-			if (IsOnCursorTimeLabel(x, y, labelWhich))
-			{
-				m_dragMode = PlotDragMode::CURSOR_MOVE;
-				m_hoverCursor = labelWhich;
-				m_activeCursor = labelWhich;
-				m_cursorHover = true;
-				// 抓取偏移 = “手指按在读数标签的哪个位置”。
-				// ⚠️ 但光标**滞留在视界之外**时读数被钉在网格边缘，此时抓取点与光标真实位置
-				// 之间没有任何有意义的对应关系：仍然沿用偏移会让首次移动把目标送到视界之外
-				//（再被夹回边缘），表现为“一拖就跳很远 / 光标钉在边缘不动”。
-				// 因此这种情形下不带偏移：首次移动就把光标放在鼠标处（自然地拖回来）。
-				bool offRight = false;
-				const bool offView = CursorOffViewSide(labelWhich, offRight);
-				m_cursorGrabOffset =
-				    offView ? 0
-				            : (x - static_cast<int>(std::lround(CursorDisplayX(labelWhich))));
-				return true;
-			}
-		}
-
-		// 图例与 GX 编号徽标叠在波形之上、且直接位于网格顶部——用户明确要求它们**优先响应**：
-		// 必须先于「时间光标线 / 光标读数 / 边沿计数横向光标 / 选区放大」判定，否则：
-		//  * 光标线恰好经过徽标/图例时，按下会变成拖光标；
-		//  * 选区放大模式下会变成“开始框选”，用户看到的就是“GX 拖不动、图例点不中”。
-		// 层序上仍然让位于浮动面板（面板绘制在徽标与图例之上），因此先挡一次面板命中。
-		int guardLane = -1;
-		int guardKind = 0;
-		const bool guardPanel = TopPanelAtPoint(fx, fy, guardLane, guardKind);
-
-		// 网格次序拖拽：按在图例的 GX 编号徽标上即可整块拎起该网格上下移动。
-		if (!guardPanel)
-		{
-			const int badgeLane = LaneBadgeAtPoint(x, y);
-			if (badgeLane >= 0)
-			{
-				m_dragMode = PlotDragMode::LANE_REORDER;
-				m_laneDragFrom = badgeLane;
-				m_laneDragTarget = badgeLane;
-				m_laneDragMouseY = y;
-				m_laneDragGrabOffset =
-				    static_cast<float>(y) - m_lanes[static_cast<std::size_t>(badgeLane)].rect.Y;
-				// 拖动期间保持静态场景缓存有效：内容按网格条带平移贴回，
-				// 因此不必重绘百万级采样的波形（见 PaintLaneReorder）。
-				return true;
-			}
-		}
-
-		// 点击图例条目等价于在左侧列表中选中该信号（样式区随之切换目标）。
-		// **必须在选区放大判定之前**：选区放大模式只改变拖拽语义，
-		// 不应影响图例的悬停与点选（否则用户在选区放大模式下无法切换信号）。
-		if (!guardPanel)
-		{
-			const SignalRef legendHit = LegendAtPoint(x, y);
-			if (legendHit.IsValid())
-			{
-				SelectSignal(legendHit);
-				m_dragMode = PlotDragMode::NONE;
-				return true;
-			}
-		}
-
-		// 靠近时间光标线时进入拖动。
-		// （放在徽标/图例之后：两者重叠时徽标与图例优先，与用户要求一致。）
-		if (!guardPanel)
-		{
-			int cursorWhich = 0;
-			if (IsOnCursorLine(x, cursorWhich) && UiPointInRect(m_area, fx, fy))
-			{
-				m_dragMode = PlotDragMode::CURSOR_MOVE;
-				m_hoverCursor = cursorWhich;
-				// 点中的光标成为“活动光标”：它触发的内容将画在上层。
-				m_activeCursor = cursorWhich;
-				m_cursorHover = true;
-				return true;
-			}
-		}
-
-		// 实验性功能浮动面板（面板压在波形之上，必须先于信号拖拽判定）：
-		// * ✕ → 关闭该网格对应的功能；
-		// * 逐条目参数输入框 → 进入内联编辑；
-		// * 底部按钮 → 触发「构建为新信号」请求；
-		// * 标题栏 → 拖动面板；
-		// * 面板主体 → 消费点击，但**不拖动也不穿透**（用户明确要求只有标题栏可拖拽）。
-		//
-		// ⚠️ **按层序从上层往下命中**（重叠时只有最上层那个面板响应），并在命中后把该面板
-		// **置顶**（用户点击哪个就把哪个放到最上层），这样：
-		//  * 上层面板的 ✕ / 标题栏不会被下层面板的参数输入框抢走（否则"上层面板关不掉 / 拖不动"）；
-		//  * 两个面板重叠时总能操作到用户想要的那一个。
-		{
-			int panelLane = -1;
-			int panelKindValue = 0;
-			if (TopPanelAtPoint(fx, fy, panelLane, panelKindValue))
-			{
-				const EdgePanelKind kind = static_cast<EdgePanelKind>(panelKindValue);
-				const int index = panelLane;
-				BringPanelToFront(index, panelKindValue);
-				const EdgePanelLayout layout = EdgePanelLayoutFor(index, kind);
-
-				if (UiPointInRect(layout.close, fx, fy))
-				{
-					// ✕：**抬起**时才关闭该网格对应的实验性功能，这里只记录目标；
-					// 按住后移开再松开视为放弃（与面板/标签栏的关闭 ✕ 语义一致）。
-					// ⚠️ 必须在此**直接消费**该次按下：✕ 位于标题栏矩形内部，
-					// 若继续往下走会被“标题栏 → 拖动面板”分支命中，表现为“按下 ✕ 却拖走了面板”。
-					m_pendingPanelClose = true;
-					m_pendingPanelCloseLane = index;
-					m_pendingPanelCloseKind = kind;
-					m_dragMode = PlotDragMode::NONE;
-					return true;
-				}
-
-				// 「中心轴边沿计数」/「均值滤波」/「弱峰调整」面板：逐信号条目
-				// （前两者是「名称 + 复选框 + 两个参数输入框」，弱峰调整是「名称 + 复选框 + 两行滑块」）。
-				if ((kind == EdgePanelKind::MEAN || kind == EdgePanelKind::CENTER ||
-				     kind == EdgePanelKind::PEAK) &&
-				    m_tab != nullptr)
-				{
-					const bool meanMode = (kind == EdgePanelKind::MEAN);
-					const bool boostMode = (kind == EdgePanelKind::PEAK);
-					Lane& tabLane = m_tab->Lanes()[static_cast<std::size_t>(index)];
-
-					// 「弱峰调整」：先判两行滑块（数值文本 → 改上限；轨道 → 拖动）。
-					if (boostMode)
-					{
-						for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
-						{
-							const SignalRef& ref = layout.rowRefs[rowIndex];
-							const bool hasLevel = rowIndex < layout.rowLevelTracks.size() &&
-							                      layout.rowLevelTracks[rowIndex].Width > 0.0f;
-							if (!hasLevel)
-							{
-								continue;
-							}
-							if (tabLane.FindWeakPeakItem(ref) == nullptr)
-							{
-								continue;
-							}
-							Lane::WeakPeakItem& item = tabLane.EnsureWeakPeakItem(ref);
-							// 两行滑块右侧的**复位控件**：点击恢复该行参数的默认值
-							//（幅度 → 0；迭代次数 → 1 且上限回到初始上限 `kWeakPeakIterationsDefaultMax`）。
-							// 与「系数/偏移」二级面板里的还原图标同一交互语义（面板保持打开、就地回显）。
-							if (rowIndex < layout.rowLevelResets.size() &&
-							    layout.rowLevelResets[rowIndex].Width > 0.0f &&
-							    UiPointInRect(layout.rowLevelResets[rowIndex], fx, fy))
-							{
-								item.amountPercent = 0;
-								m_weakPeakCurveCache.clear();
-								m_dragMode = PlotDragMode::NONE;
-								return true;
-							}
-							if (rowIndex < layout.rowIterResets.size() &&
-							    layout.rowIterResets[rowIndex].Width > 0.0f &&
-							    UiPointInRect(layout.rowIterResets[rowIndex], fx, fy))
-							{
-								item.iterations = kWeakPeakIterationsMin;
-								item.maxIterations = kWeakPeakIterationsDefaultMax;
-								m_weakPeakCurveCache.clear();
-								m_dragMode = PlotDragMode::NONE;
-								return true;
-							}
-							// 迭代次数行右侧的**数值文本**：点击后整行变成输入框以修改滑块上限。
-							// ⚠️ 必须放在轨道命中之前（数值区在轨道右侧，命中区不重叠，但顺序更安全）。
-							if (layout.rowIterValues[rowIndex].Width > 0.0f &&
-							    UiPointInRect(layout.rowIterValues[rowIndex], fx, fy))
-							{
-								m_editMeanRef = ref;
-								m_peakEditCurrentMax = item.maxIterations;
-								// 输入框以**空内容**开始：空内容时显示当前上限作为灰色提示。
-								// 输入框覆盖"整条滑块行"（从轨道左端到数值文本右端）。
-								const gd::RectF& track = layout.rowIterTracks[rowIndex];
-								const gd::RectF& value = layout.rowIterValues[rowIndex];
-								const gd::RectF rowRect(track.X, value.Y, value.X + value.Width - track.X,
-								                        value.Height);
-								BeginEdit(PlotEditTarget::PEAK_ITERATIONS_MAX, index, L"", rowRect);
-								// `BeginEdit` 默认用 NUMBER 过滤（允许负号/小数点）；这里改为**纯数字**，
-								// 从源头保证"只允许输入正整数"（负数、小数根本无法键入，粘贴同样被清洗）。
-								m_edit.Begin(L"", false, EditFilter::BYTE, 0u);
-								m_dragMode = PlotDragMode::NONE;
-								return true;
-							}
-							if (layout.rowIterTracks[rowIndex].Width > 0.0f &&
-							    WeakPeakSliderHit(layout.rowIterTracks[rowIndex], m_scale, fx, fy))
-							{
-								m_dragMode = PlotDragMode::PEAK_ITERATIONS;
-								m_peakDragLane = index;
-								m_peakDragRef = ref;
-								const double ratio = UiSliderRatioFromX(layout.rowIterTracks[rowIndex], fx);
-								const int peakMax = std::max(kWeakPeakIterationsMin,
-								                             std::min(kWeakPeakIterationsMaxLimit,
-								                                      item.maxIterations));
-								item.iterations = std::max(
-								    kWeakPeakIterationsMin,
-								    std::min(peakMax, kWeakPeakIterationsMin +
-								                          static_cast<int>(std::lround(
-								                              ratio * (peakMax - kWeakPeakIterationsMin)))));
-								m_weakPeakCurveCache.clear();
-								return true;
-							}
-							if (layout.rowLevelTracks[rowIndex].Width > 0.0f &&
-							    WeakPeakSliderHit(layout.rowLevelTracks[rowIndex], m_scale, fx, fy))
-							{
-								m_dragMode = PlotDragMode::PEAK_LEVEL;
-								m_peakDragLane = index;
-								m_peakDragRef = ref;
-								// 单击轨道：直接写入该处对应的幅度（-400% … +400%，0 在正中间）。
-								item.amountPercent = static_cast<int>(std::lround(
-								    (UiSliderRatioFromX(layout.rowLevelTracks[rowIndex], fx) * 2.0 - 1.0) *
-								    100.0 * kWeakPeakSliderScale));
-								item.amountPercent = std::max(
-								    kWeakPeakAmountMin,
-								    std::min(kWeakPeakAmountMax, item.amountPercent));
-								m_weakPeakCurveCache.clear();
-								return true;
-							}
-						}
-					}
-
-					for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
-					{
-						const SignalRef& ref = layout.rowRefs[rowIndex];
-						// 第一排右侧的复选框 → 切换该信号的预览勾选状态。
-						if (layout.rowChecks[rowIndex].Width > 0.0f &&
-						    UiPointInRect(layout.rowChecks[rowIndex], fx, fy))
-						{
-							if (meanMode)
-							{
-								ToggleLaneMeanFilterSignal(index, ref);
-							}
-							else if (boostMode)
-							{
-								ToggleLaneWeakPeakSignal(index, ref);
-							}
-							else
-							{
-								ToggleLaneEdgeCenterSignal(index, ref);
-							}
-							// 勾选变化只改变该信号“是否显示”，它的统计状态（与参数相关）依然有效，
-							// 其它信号更是完全无关 ⇒ **不要**清任何缓存（清掉就会让所有统计重算）。
-							// 这里**不**整体作废场景缓存（交给 `m_sceneDerived` 快照驱动局部重画）。
-							m_dragMode = PlotDragMode::NONE;
-							return true;
-						}
-						// 第二排的两个输入框 → 就地编辑该信号的参数（仅 MEAN / CENTER 面板；
-						// 弱峰调整用的是滑块，已在上面处理）。
-						if (layout.rowPoints[rowIndex].Width > 0.0f &&
-						    UiPointInRect(layout.rowPoints[rowIndex], fx, fy))
-						{
-							m_editMeanRef = ref;
-							const Lane::MeanFilterItem* item =
-							    meanMode ? tabLane.FindMeanFilterItem(ref)
-							             : tabLane.FindEdgeCenterItem(ref);
-							BeginEdit(meanMode ? PlotEditTarget::MEAN_FILTER_POINTS
-							                   : PlotEditTarget::EDGE_CENTER_POINTS,
-							          index, std::to_wstring(item != nullptr ? item->points : 5),
-							          layout.rowPoints[rowIndex]);
-							return true;
-						}
-						if (layout.rowIterations[rowIndex].Width > 0.0f &&
-						    UiPointInRect(layout.rowIterations[rowIndex], fx, fy))
-						{
-							m_editMeanRef = ref;
-							const Lane::MeanFilterItem* item =
-							    meanMode ? tabLane.FindMeanFilterItem(ref)
-							             : tabLane.FindEdgeCenterItem(ref);
-							BeginEdit(meanMode ? PlotEditTarget::MEAN_FILTER_ITERATIONS
-							                   : PlotEditTarget::EDGE_CENTER_ITERATIONS,
-							          index, std::to_wstring(item != nullptr ? item->iterations : 1),
-							          layout.rowIterations[rowIndex]);
-							return true;
-						}
-					}
-
-					if (boostMode && layout.button.Width > 0.0f && UiPointInRect(layout.button, fx, fy))
-					{
-						// 「弱峰调整 → 构建为新信号」：与均值滤波同一套请求机制，
-						// **每个信号用自己的等级与迭代次数**（与预览曲线逐位一致）。
-						const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(index)];
-						m_pendingWeakPeakItems.clear();
-						for (const SignalRef& ref : lane.signals)
-						{
-							const ResolvedSignal resolved = ResolveSignal(ref);
-							if (resolved.data == nullptr || !resolved.visible)
-							{
-								continue;
-							}
-							const Lane::WeakPeakItem* item = lane.FindWeakPeakItem(ref);
-							if (item == nullptr)
-							{
-								continue;
-							}
-							WeakPeakBuild build;
-							build.groupIndex = ref.groupIndex;
-							build.signalIndex = ref.signalIndex;
-							const int peakAmount =
-							    std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, item->amountPercent));
-							build.amountPercent = peakAmount;
-							// 迭代次数按**该信号自己的滑块量程**（1 … `maxIterations`）夹取。
-							const int peakMax = std::max(
-							    kWeakPeakIterationsMin,
-							    std::min(kWeakPeakIterationsMaxLimit, item->maxIterations));
-							build.iterations =
-							    std::max(kWeakPeakIterationsMin, std::min(peakMax, item->iterations));
-							m_pendingWeakPeakItems.push_back(build);
-						}
-						if (!m_pendingWeakPeakItems.empty())
-						{
-							const WeakPeakBuild& first = m_pendingWeakPeakItems.front();
-							SetHint(L"正在构建弱峰调整信号（幅度 " + std::to_wstring(first.amountPercent) +
-							        L"% / " + std::to_wstring(first.iterations) + L" 次迭代，共 " +
-							        std::to_wstring(m_pendingWeakPeakItems.size()) + L" 条）…");
-							m_pendingWeakPeakLane = index;
-						}
-						m_dragMode = PlotDragMode::NONE;
-						return true;
-					}
-
-					if (meanMode && layout.button.Width > 0.0f && UiPointInRect(layout.button, fx, fy))
-					{
-						// 「构建为新信号」：只登记请求（含每个信号自己的 X/N），
-						// 真正的信号构建由宿主（Application）完成。
-						const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(index)];
-						m_pendingMeanFilterItems.clear();
-						for (const SignalRef& ref : lane.signals)
-						{
-							const ResolvedSignal resolved = ResolveSignal(ref);
-							if (resolved.data == nullptr || !resolved.visible)
-							{
-								continue;
-							}
-							const Lane::MeanFilterItem* item = lane.FindMeanFilterItem(ref);
-							if (item == nullptr)
-							{
-								continue;
-							}
-							MeanFilterBuild build;
-							build.groupIndex = ref.groupIndex;
-							build.signalIndex = ref.signalIndex;
-							build.points = item->points;
-							build.iterations = item->iterations;
-							m_pendingMeanFilterItems.push_back(build);
-						}
-						if (!m_pendingMeanFilterItems.empty())
-						{
-							const MeanFilterBuild& first = m_pendingMeanFilterItems.front();
-							SetHint(L"正在构建均值滤波信号（" + std::to_wstring(first.points) +
-							        L" 点 " + std::to_wstring(first.iterations) + L" 次迭代，共 " +
-							        std::to_wstring(m_pendingMeanFilterItems.size()) + L" 条）…");
-							m_pendingMeanFilterLane = index;
-						}
-						m_dragMode = PlotDragMode::NONE;
-						return true;
-					}
-				}
-
-				if (UiPointInRect(layout.title, fx, fy))
-				{
-					m_dragMode = PlotDragMode::EDGE_PANEL_MOVE;
-					m_edgePanelDragLane = index;
-					m_edgePanelDragKind = kind;
-					m_edgePanelDragOffset.X = fx - layout.panel.X;
-					m_edgePanelDragOffset.Y = fy - layout.panel.Y;
-					return true;
-				}
-
-				// 面板主体：消费该次点击，避免误触发底层的平移/选区/信号拖拽。
-				m_dragMode = PlotDragMode::NONE;
-				return true;
-			}
-		}
-
-		// 「边沿计数」横向光标：上下拖动改变幅值。
-		{
-			int edgeLane = -1;
-			if (IsOnEdgeCursorLine(x, y, edgeLane))
-			{
-				m_dragMode = PlotDragMode::EDGE_MOVE;
-				m_edgeDragLane = edgeLane;
-				return true;
-			}
-		}
-
-		if (!UiPointInRect(m_plotRect, fx, fy))
-		{
-			m_dragMode = PlotDragMode::NONE;
-			return false;
-		}
-
-		const PlotZoomMode mode = Tab().ZoomMode();
-		if (mode == PlotZoomMode::SELECT)
-		{
-			// 选区放大：轴向由鼠标移动方向决定，因此按下时先记录网格并置为未定。
-			// 按下本身**不显示提示**（拖动开始后才显示"右键取消选区"）。
-			m_dragLane = LaneAtY(y);
-			m_rubberAxis = PlotRubberAxis::UNDECIDED;
-			m_dragMode = PlotDragMode::RUBBER_SELECT;
-			return true;
-		}
-
-		// 常规模式下：先检测是否落在信号曲线上；只有命中提示时才允许拖拽该信号。
-		const SignalRef hit = HitTestSignal(x, y);
-		if (hit.IsValid())
-		{
-			m_dragSignal = hit;
-			m_dragTargetLane = Tab().LaneOfSignal(hit);
-			SelectSignal(hit);
-			m_dragMouseX = x;
-			m_dragMouseY = y;
-			m_dragMode = PlotDragMode::MOVE_SIGNAL;
-			return true;
-		}
-
-		m_dragLane = LaneAtY(y);
-		m_dragMode = PlotDragMode::PAN;
-		return true;
-	}
-
-	bool PlotView::OnMButtonDown(int x, int y)
-	{
-		if (!HasDrawableContent())
-		{
-			return false;
-		}
-
-		// 中键：无论当前是否处于选区放大模式，都直接进入自由平移
-		// （不改变选区放大模式本身，松手后仍可继续框选）。
-		m_dragStartX = x;
-		m_dragStartY = y;
-		m_dragLastX = x;
-		m_dragLastY = y;
-		m_dragMoved = false;
-		m_rubberRect = gd::RectF();
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-		m_cursorGrabOffset = 0;
-		m_edgeDragLane = -1;
-		m_edgePanelDragLane = -1;
-		m_edgePanelDragKind = EdgePanelKind::COUNT;
-		SetHint(std::wstring());
-		m_dragLane = LaneAtY(y);
-		m_dragMode = PlotDragMode::PAN;
-		return true;
-	}
-
-	bool PlotView::OnMButtonUp()
-	{
-		const bool changed = (m_dragMode == PlotDragMode::PAN);
-		if (changed)
-		{
-			m_dragMode = PlotDragMode::NONE;
-			m_dragLane = -1;
-			m_dragMoved = false;
-			ReleaseHint();
-		}
-		return changed;
-	}
-
-	bool PlotView::OnLButtonUp(int x, int y)
-	{
-		bool changed = (m_dragMode != PlotDragMode::NONE);
-
-		// 实验性功能面板的 ✕：只有"按下后仍在同一个 ✕ 上抬起"才真正关闭该功能。
-		if (m_pendingPanelClose)
-		{
-			const int lane = m_pendingPanelCloseLane;
-			const EdgePanelKind kind = m_pendingPanelCloseKind;
-			m_pendingPanelClose = false;
-			m_pendingPanelCloseLane = -1;
-
-			if (lane >= 0 && lane < static_cast<int>(m_lanes.size()))
-			{
-				const EdgePanelLayout layout = EdgePanelLayoutFor(lane, kind);
-				if (layout.close.Width > 0.0f &&
-				    UiPointInRect(layout.close, static_cast<float>(x), static_cast<float>(y)))
-				{
-					switch (kind)
-					{
-					case EdgePanelKind::CENTER:
-						SetLaneEdgeCenterCount(lane, false);
-						break;
-					case EdgePanelKind::MEAN:
-						SetLaneMeanFilter(lane, false);
-						break;
-					case EdgePanelKind::PEAK:
-						SetLaneWeakPeak(lane, false);
-						break;
-					case EdgePanelKind::COUNT:
-					default:
-						SetLaneEdgeCount(lane, false);
-						break;
-					}
-					changed = true;
-				}
-			}
-		}
-
-		switch (m_dragMode)
-		{
-		case PlotDragMode::RUBBER_SELECT:
-		{
-			// 按拖拽方向应用对应的缩放（横向 → 时间轴；纵向 → 当前网格幅值轴）。
-			if (m_rubberAxis == PlotRubberAxis::TIME)
-			{
-				if (m_dragMoved &&
-				    ApplyTimeSelection(m_rubberRect.X, m_rubberRect.X + m_rubberRect.Width))
-				{
-					changed = true;
-				}
-			}
-			else if (m_rubberAxis == PlotRubberAxis::VALUE)
-			{
-				if (m_dragMoved &&
-				    ApplyValueSelection(m_dragLane, m_rubberRect.Y, m_rubberRect.Y + m_rubberRect.Height))
-				{
-					changed = true;
-				}
-			}
-			break;
-		}
-		case PlotDragMode::CURSOR_MOVE:
-			m_cursorHover = true;
-			break;
-		case PlotDragMode::CURSOR_SPAN_MOVE:
-			break;
-		case PlotDragMode::LANE_REORDER:
-			// 网格次序拖拽结束：真正重排并重编号（GX 徽标随之同步）。
-			FinishLaneReorder();
-			changed = true;
-			break;
-		case PlotDragMode::MOVE_SIGNAL:
-		{
-			const int target = LaneAtY(y);
-			const int source = (m_tab != nullptr) ? m_tab->LaneOfSignal(m_dragSignal) : -1;
-			if (m_dataSet != nullptr && m_tab != nullptr && m_dragSignal.IsValid() && target >= 0 &&
-			    target != source && m_dragMoved)
-			{
-				m_tab->MoveSignalToLane(*m_dataSet, m_dragSignal, target);
-				changed = true;
-			}
-			m_dragSignal = SignalRef();
-			m_dragTargetLane = -1;
-			break;
-		}
-		default:
-			break;
-		}
-
-		m_dragMode = PlotDragMode::NONE;
-		m_rubberAxis = PlotRubberAxis::UNDECIDED;
-		m_dragLane = -1;
-		m_dragMoved = false;
-		m_rubberRect = gd::RectF();
-		m_cursorGrabOffset = 0;
-		m_edgeDragLane = -1;
-		m_edgePanelDragLane = -1;
-		m_edgePanelDragKind = EdgePanelKind::COUNT;
-		// 弱峰滑块拖拽结束：清掉目标（避免留下上一轮的信号引用）。
-		m_peakDragLane = -1;
-		m_peakDragRef = SignalRef();
-		// 松开左键：粘滞提示结束计时，开始"停留后淡出"。
-		ReleaseHint();
-		return changed;
-	}
-
-	bool PlotView::OnMouseWheel(int delta, bool shift)
-	{
-		if (!HasDrawableContent() || delta == 0)
-		{
-			return false;
-		}
-
-		const double notches = static_cast<double>(delta) / 120.0;
-
-		// 滚轮不再承担缩放：默认纵向滚动网格，按住 Shift 时水平平移时间轴。
-		if (shift)
-		{
-			const double span = Tab().ViewMax() - Tab().ViewMin();
-			const double sweep = -notches * span * 0.15;
-			Tab().ViewMin() += sweep;
-			Tab().ViewMax() += sweep;
-			ClampTimeView();
-			return true;
-		}
-
-		if (m_plotRect.Height <= 0.0f || m_laneContentHeight <= m_plotRect.Height)
-		{
-			return false;
-		}
-
-		Tab().LaneScroll() -= static_cast<float>(notches * 48.0 * m_scale);
-		BuildLaneVisuals();
-		return true;
-	}
-
-	bool PlotView::OnDoubleClick(int x, int y)
-	{
-		if (!UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y)))
-		{
-			return false;
-		}
-
-		// ⚠️ **上层元素的交互绝不能穿透到下层**：实验性功能的浮动面板浮在网格之上（且绘制在
-		//    光标标签 / 图例之上），因此在它上面双击必须由它消费掉。旧实现在所有下层命中都不成
-		//    立时无条件 `FitAll()`，于是"在面板上双击任意位置"会让网格莫名其妙地自适应一次
-		//    （用户 2026-10-15 报告）。面板自身双击没有额外语义，直接消费即可。
-		{
-			int panelLane = -1;
-			int panelKind = 0;
-			if (TopPanelAtPoint(static_cast<float>(x), static_cast<float>(y), panelLane, panelKind))
-			{
-				return true;
-			}
-		}
-
-		// 双光标差值标签：双击进入差值编辑（输入值的量级始终为秒）。
-		// 注意：差值标签在"两光标过近"时会落到主时间轴内部，因此必须先于区域判定。
-		if (IsOnCursorSpanLabel(x, y))
-		{
-			return BeginEdit(PlotEditTarget::CURSOR_SPAN, -1, FormatDurationSeconds(CursorSpan()));
-		}
-
-		if (!UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y)))
-		{
-			return false;
-		}
-
-		// 命中光标时间读数标签：编辑该条光标的时间（优先于光标线，避免两条过近时选错）。
-		{
-			int labelWhich = 0;
-			if (IsOnCursorTimeLabel(x, y, labelWhich))
-			{
-				m_editCursor = labelWhich;
-				m_activeCursor = labelWhich;
-				const double time = (labelWhich == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
-				return BeginEdit(PlotEditTarget::CURSOR_TIME, -1, FormatValue(time));
-			}
-		}
-
-		// 命中时间光标：进入精确时间输入（交互与线宽输入框一致）。
-		{
-			int cursorWhich = 0;
-			if (IsOnCursorLine(x, cursorWhich))
-			{
-				m_editCursor = (cursorWhich == 2) ? 2 : 1;
-				m_activeCursor = m_editCursor;
-				const double time =
-				    (m_editCursor == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
-				return BeginEdit(PlotEditTarget::CURSOR_TIME, -1, FormatValue(time));
-			}
-		}
-
-		// 命中图例条目：进入信号改名（与左侧列表双击改名的交互一致）。
-		const SignalRef legendHit = LegendAtPoint(x, y);
-		if (legendHit.IsValid())
-		{
-			const ResolvedSignal resolved = ResolveSignal(legendHit);
-			if (resolved.data != nullptr)
-			{
-				SelectSignal(legendHit);
-				m_editSignal = legendHit;
-
-				// 先把输入框位置落在被双击的条目上，再进入编辑态。
-				for (const LegendHit& hit : m_legendHits)
-				{
-					if (hit.ref == legendHit)
-					{
-						m_editFieldRect = hit.rect;
-						break;
-					}
-				}
-				return BeginEdit(PlotEditTarget::SIGNAL_NAME, -1, resolved.data->name);
-			}
-		}
-
-		// 其它位置：回到初始状态（自适应 + 退出缩放模式）。
-		FitAll();
-		return true;
-	}
-
-	bool PlotView::OnMouseLeave()
-	{
-		bool changed = false;
-		if (m_hoverLane != -1)
-		{
-			m_hoverLane = -1;
-			changed = true;
-		}
-		if (m_hoverBadge != -1)
-		{
-			m_hoverBadge = -1;
-			changed = true;
-		}
-		if (m_hoverSignal.IsValid())
-		{
-			m_hoverSignal = SignalRef();
-			changed = true;
-		}
-		// 图例悬停半高亮同样随鼠标离开而消失（否则右键弹菜单/移出绘图区后残留在原地）。
-		if (m_hoverLegend.IsValid())
-		{
-			m_hoverLegend = SignalRef();
-			changed = true;
-		}
-		if (m_cursorHover)
-		{
-			m_cursorHover = false;
-			changed = true;
-		}
-		if (m_hoverCursor != 0 && m_dragMode != PlotDragMode::CURSOR_MOVE)
-		{
-			m_hoverCursor = 0;
-			changed = true;
-		}
-		if (m_spanHover)
-		{
-			m_spanHover = false;
-			changed = true;
-		}
-		return changed;
-	}
-
-
-	const PlotView::PolylineCacheEntry* PlotView::AcquirePolyline(const SignalRef& ref,
-	                                                             const ResolvedSignal& resolved,
-	                                                             const LaneVisual& lane) const
-	{
-		if (resolved.data == nullptr || resolved.group == nullptr)
-		{
-			return nullptr;
-		}
-
-		// ⚠️ **横向补条渲染：不进缓存**。补条只构建"条带区间"的折线顶点，若写进缓存，
-		// 后续整块渲染命中同键时会拿到这段**不完整**的折线（只画了条带那一段）。
-		// 因此补条专用一个独立条目，避免污染按"宽窗口几何"键控的缓存。
-		if (m_stripRenderActive)
-		{
-			BuildPolyline(resolved, lane, m_stripPolylineEntry.points, m_stripPolylineEntry.breaks,
-			              m_stripPolylineEntry.band, m_stripPolylineEntry.bandBreaks,
-			              m_stripPolylineEntry.bandMode, m_stripPolylineEntry.bandSpiky);
-			return &m_stripPolylineEntry;
-		}
-
-		// 键 = 构建折线时实际读取的全部输入：
-		// 信号（引用 + 文件内容 + 采样点数）、时间轴显示范围、绘图区横向几何、网格纵向几何。
-		// 这些值全部相同时，BuildPolyline 的输出必然完全一致，可直接复用。
-		const std::size_t sampleCount = std::min(resolved.axis->time.size(), resolved.data->values.size());
-		const double viewMin = Tab().ViewMin();
-		const double viewMax = Tab().ViewMax();
-		// 绘制前的数值变换（系数/绝对值/镜像/偏移）会改变顶点，必须进缓存键。
-		const float gain = (resolved.style != nullptr) ? resolved.style->gain : 1.0f;
-		const bool absolute = (resolved.style != nullptr) && resolved.style->absolute;
-		const bool mirrorVertical = (resolved.style != nullptr) && resolved.style->mirrorVertical;
-		const bool mirrorHorizontal = (resolved.style != nullptr) && resolved.style->mirrorHorizontal;
-		const float offsetY = (resolved.style != nullptr) ? resolved.style->offsetY : 0.0f;
-		const double offsetTime = (resolved.style != nullptr) ? resolved.style->offsetTime : 0.0;
-
-		for (const PolylineCacheEntry& entry : m_polylineCache)
-		{
-			if (entry.ref == ref && entry.group == resolved.group && entry.sampleCount == sampleCount &&
-			    entry.viewMin == viewMin && entry.viewMax == viewMax && entry.plotX == m_plotRect.X &&
-			    entry.plotWidth == m_plotRect.Width && entry.laneY == lane.rect.Y &&
-			    entry.laneHeight == lane.rect.Height && entry.laneYMin == lane.yMin &&
-			    entry.laneYMax == lane.yMax && entry.gain == gain && entry.absolute == absolute &&
-			    entry.mirrorVertical == mirrorVertical && entry.mirrorHorizontal == mirrorHorizontal &&
-			    entry.offsetY == offsetY && entry.offsetTime == offsetTime)
-			{
-				return &entry;
-			}
-		}
-
-		// 未命中：重建并写入缓存（deque 保证已有元素的引用在追加后依然有效）。
-		// 缓存只用于消除重复计算，容量上限约等于“网格数 × 每网格信号数”的两倍。
-		if (m_polylineCache.size() >= kPolylineCacheLimit)
-		{
-			m_polylineCache.clear();
-		}
-		m_polylineCache.push_back(PolylineCacheEntry());
-		PolylineCacheEntry& entry = m_polylineCache.back();
-		entry.ref = ref;
-		entry.group = resolved.group;
-		entry.sampleCount = sampleCount;
-		entry.viewMin = viewMin;
-		entry.viewMax = viewMax;
-		entry.plotX = m_plotRect.X;
-		entry.plotWidth = m_plotRect.Width;
-		entry.laneY = lane.rect.Y;
-		entry.laneHeight = lane.rect.Height;
-		entry.laneYMin = lane.yMin;
-		entry.laneYMax = lane.yMax;
-		entry.gain = gain;
-		entry.absolute = absolute;
-		entry.mirrorVertical = mirrorVertical;
-		entry.mirrorHorizontal = mirrorHorizontal;
-		entry.offsetY = offsetY;
-		entry.offsetTime = offsetTime;
-
-		BuildPolyline(resolved, lane, entry.points, entry.breaks, entry.band, entry.bandBreaks,
-		              entry.bandMode, entry.bandSpiky);
-		// BuildPolyline 通过引用填充，push_back 过程中不会再次进入本函数，引用安全。
-		return &m_polylineCache.back();
-	}
-
-	void PlotView::BuildPolyline(const ResolvedSignal& resolved, const LaneVisual& lane,
-	                             std::vector<gd::PointF>& points, std::vector<std::size_t>& breaks,
-	                             std::vector<gd::PointF>& band, std::vector<std::size_t>& bandBreaks,
-	                             bool& bandMode, bool& bandSpiky) const
-	{
-		points.clear();
-		breaks.clear();
-		band.clear();
-		bandBreaks.clear();
-		bandMode = false;
-		bandSpiky = false;
-
-		if (resolved.data == nullptr || resolved.group == nullptr)
-		{
-			return;
-		}
-
-		const std::vector<double>& time = resolved.axis->time;
-		const std::vector<double>& values = resolved.data->values;
-		const std::size_t count = std::min(time.size(), values.size());
-		if (count == 0 || m_plotRect.Width <= 1.0f)
-		{
-			return;
-		}
-
-		const double viewMin = Tab().ViewMin();
-		const double viewMax = Tab().ViewMax();
-
-		// 时间偏移：采样画在 `t + offsetTime` 处，因此“落在当前视界内的采样”
-		// 其源时刻位于 `[viewMin - offsetTime, viewMax - offsetTime]`。
-		const double timeShift = resolved.style->offsetTime;
-		const double sourceMin = viewMin - timeShift;
-		const double sourceMax = viewMax - timeShift;
-
-		std::size_t begin = 0;
-		std::size_t end = count;
-
-		if (resolved.axis->monotonic)
-		{
-			const std::vector<double>::const_iterator first = std::lower_bound(time.begin(), time.end(), sourceMin);
-			begin = static_cast<std::size_t>(first - time.begin());
-			if (begin > 0)
-			{
-				--begin;
-			}
-			const std::vector<double>::const_iterator last = std::lower_bound(time.begin(), time.end(), sourceMax);
-			end = static_cast<std::size_t>(last - time.begin());
-			if (end < count)
-			{
-				++end;
-			}
-		}
-
-		if (end <= begin)
-		{
-			return;
-		}
-
-		// ⚠️ **横向补条裁剪**（只对本函数后半段的"逐点描边"路径生效，见 `budget` 之后）：
-		// 图层横向补条只覆盖位图里的一条窄竖带（`m_area` 的 x 区间），其余像素由已有图层像素提供，
-		// 因此折线只需构建并绘制落在条带 x 范围内的那一段顶点。放在"包络/描边"分支判定**之后**
-		// 是必须的 —— 若先裁剪，`visibleCount` 会变成条带内的采样数，可能改变"走包络还是走描边"
-		// 的判定，使条带与整块渲染的像素不一致（出现接缝）。
-
-		const float limitTop = lane.rect.Y - lane.rect.Height * 4.0f;
-		const float limitBottom = lane.rect.Y + lane.rect.Height * 5.0f;
-
-		const std::size_t visibleCount = end - begin;
-
-		// 顶点预算由绘图区宽度决定（而不是固定值）：折线顶点数直接决定
-		// GDI+ 抗锯齿折线的绘制耗时，百万级采样文件若按固定 20000 顶点绘制，
-		// 会把大量顶点堆在同一个像素列上（画出来完全重合），纯粹浪费 CPU。
-		std::size_t budget =
-		    static_cast<std::size_t>(std::max(1.0f, m_plotRect.Width)) * kPolylinePointsPerPixel;
-		budget = std::max(budget, kMinPolylinePoints);
-		budget = std::min(budget, kMaxPolylinePoints);
-
-		// 采样点密度超过像素分辨率时改用“像素列上下包络”抽稀：
-		// 每个像素列只保留最小/最大两个顶点（按出现先后排序），
-		// 既不会漏掉尖峰（等间隔抽样会整段跳过），又把顶点数压到像素量级。
-		//
-		// ⚠️ **阈值必须是「每像素列 1 个采样」而不是 `budget`（每列 2 个）**：
-		// 逐点描边（`DrawLines`）的代价与「竖向线段数 × 覆盖行数」成正比 ——
-		// 方波/编码器这类信号在 1~2 采样/像素时会形成**满幅高的锯齿**，GDI+ 抗锯齿
-		// 逐段扫描这些竖直段，实测 **4481 个顶点要 712ms**（关抗锯齿也无用，因为瓶颈是
-		// 每段的扫描线而非边缘平滑），而同样画面的「像素列包络」只要 ~1.7ms。
-		// 把阈值降到 1 采样/像素后，1~2 采样/像素区间走包络带（逐列 min/max 与折线在该密度下
-		// 几乎等价，且**保留抗锯齿**），彻底消除这一区间的病态卡顿。
-		const bool useEnvelopeBand = (visibleCount > static_cast<std::size_t>(m_plotRect.Width)) &&
-		                             resolved.axis->monotonic && (m_plotRect.Width > 1.0f);
-
-		// 逐点描边路径若处于"横向补条"渲染：把采样区间裁剪到条带对应的 x 范围
-		//（两侧各留少量像素余量以避免接缝与抗锯齿溢出）。逐点描边路径必然 `visibleCount <= budget`
-		//（否则走包络），此时 `stride == 1`，裁剪后条带内的顶点序列与整块渲染完全一致 → 像素不变。
-		if (!useEnvelopeBand && m_stripRenderActive && resolved.axis->monotonic &&
-		    m_stripX1 > m_stripX0)
-		{
-			const float marginPx =
-			    std::max(4.0f, std::max(1.0f, resolved.style->lineWidth) * m_scale + 3.0f);
-			// 条带边界是**绘制时刻**，换算成源时刻要减去时间偏移。
-			const double ta = XToTime(m_stripX0 - marginPx) - timeShift;
-			const double tb = XToTime(m_stripX1 + marginPx) - timeShift;
-			const double clipLo = std::min(ta, tb);
-			const double clipHi = std::max(ta, tb);
-			std::size_t sBegin = static_cast<std::size_t>(
-			    std::lower_bound(time.begin(), time.end(), clipLo) - time.begin());
-			if (sBegin > 0)
-			{
-				--sBegin;	// 多含一个采样点：让跨越条带左界的线段完整绘出。
-			}
-			std::size_t sEnd = static_cast<std::size_t>(
-			    std::lower_bound(time.begin(), time.end(), clipHi) - time.begin());
-			if (sEnd < count)
-			{
-				++sEnd;
-			}
-			if (sBegin > begin)
-			{
-				begin = sBegin;
-			}
-			if (sEnd < end)
-			{
-				end = sEnd;
-			}
-			if (end <= begin)
-			{
-				return;
-			}
-		}
-
-		// 采样点密度远超像素分辨率时改用“像素列上下包络”抽稀：
-		// 每个像素列只保留最小/最大两个顶点（按出现先后排序），
-		// 既不会漏掉尖峰（等间隔抽样会整段跳过），又把顶点数压到像素量级。
-		if (useEnvelopeBand)
-		{
-			const double viewSpan = viewMax - viewMin;
-			const float plotLeft = m_plotRect.X;
-			const float plotWidth = m_plotRect.Width;
-			const std::size_t columns = std::max<std::size_t>(1, budget / 2);
-			const float columnWidth = plotWidth / static_cast<float>(columns);
-
-			const std::vector<double>::const_iterator rangeEnd = time.begin() + static_cast<std::ptrdiff_t>(end);
-
-			// 粗粒度包络层（若已构建）：每列只需读取覆盖到的分组，
-			// 数据量从“可见采样数”降到“像素列数 × 少量分组”，
-			// 且分组内存的就是真实极值，绘制结果与逐点扫描完全一致。
-			const std::vector<double>& coarseMin = resolved.data->coarseMin;
-			const std::vector<double>& coarseMax = resolved.data->coarseMax;
-			const std::size_t coarseStride = resolved.data->coarseStride;
-			// ⚠️ 粗粒度分组只存了逐组的 min/max：取绝对值 / 垂直镜像会把两者互换，
-			// 此时分组层无法再给出正确的包络，必须回退到逐采样点变换（见 `DrawTransformOrderPreserving`）。
-			// Y 偏移是保序的（整体加常数），因此仍可用分组层 —— 只需把偏移一并加上。
-			const bool hasCoarse =
-			    (coarseStride > 0) && !coarseMin.empty() && (coarseMin.size() == coarseMax.size()) &&
-			    DrawTransformOrderPreserving(*resolved.style);
-			// 保序变换（正系数 + Y 偏移）下：分组极值 × 系数 + 偏移 即为变换后的极值
-			//（系数 1、偏移 0 时逐位不变）。
-			const double coarseScale = static_cast<double>(resolved.style->gain);
-			const double coarseOffset = static_cast<double>(resolved.style->offsetY);
-
-			bool inSegment = false;
-
-			// 稠密包络带：逐列记录上/下包络，收段时拼成「上包络正向 + 下包络反向」的
-			// 闭合多边形。绘制时一次 FillPath 即可，实测比逐段描边快约 8 倍
-			// （1224 列：14.3ms → 1.7ms），且**保留抗锯齿**，
-			// 因此静态帧与拖拽帧的观感完全一致（不是"交互降级"）。
-			bandMode = true;
-			const float strokeHalf =
-			    std::max(1.0f, resolved.style->lineWidth) * m_scale * 0.5f;
-			std::vector<BandColumn> segmentColumns;
-			const auto flushBandSegment = [&band, &bandBreaks, &segmentColumns, &bandSpiky, &lane]()
-			{
-				bool spiky = false;
-				EmitEnvelopeBand(segmentColumns, band, bandBreaks, spiky, lane.rect.Height);
-				bandSpiky = bandSpiky || spiky;
-				segmentColumns.clear();
-			};
-
-			std::size_t searchFrom = begin;
-			for (std::size_t column = 0; column < columns; ++column)
-			{
-				// `t0/t1` 是**绘制时刻**的列边界；源时刻要减去时间偏移（偏移为 0 时二者相同）。
-				const double t0 = viewMin + viewSpan * (static_cast<double>(column) / static_cast<double>(columns));
-				const double t1 =
-				    viewMin + viewSpan * (static_cast<double>(column + 1) / static_cast<double>(columns));
-				const double s0 = t0 - timeShift;
-				const double s1 = t1 - timeShift;
-
-				// 列边界随 column 单调递增，从上一列的位置继续二分，
-				// 把每次搜索的范围压到剩余区间，避免 2400 次全区间二分带来的缓存缺失。
-				const std::size_t i0 = static_cast<std::size_t>(
-				    std::lower_bound(time.begin() + static_cast<std::ptrdiff_t>(searchFrom), rangeEnd, s0) -
-				    time.begin());
-				searchFrom = i0;
-				const std::size_t i1 = (column + 1 == columns)
-				                           ? end
-				                           : static_cast<std::size_t>(
-				                                 std::lower_bound(time.begin() + static_cast<std::ptrdiff_t>(i0),
-				                                                  rangeEnd, s1) -
-				                                 time.begin());
-
-				double low = std::numeric_limits<double>::infinity();
-				double high = -std::numeric_limits<double>::infinity();
-				std::size_t lowOrder = 0;
-				std::size_t highOrder = 0;
-				bool broken = false;
-
-				// （一）落在本列区间内的采样点。
-				// 水平镜像时取的是**源下标**（区间同样反转），因此先把列区间映射到源下标区间。
-				const std::size_t srcA = std::min(SourceIndexFor(*resolved.style, count, i0),
-				                                 SourceIndexFor(*resolved.style, count, (i1 > 0) ? (i1 - 1) : 0));
-				const std::size_t srcB = std::max(SourceIndexFor(*resolved.style, count, i0),
-				                                 SourceIndexFor(*resolved.style, count, (i1 > 0) ? (i1 - 1) : 0));
-				if (i1 > i0 && hasCoarse && (i1 - i0) >= 2 * coarseStride)
-				{
-					const std::size_t firstBucket = srcA / coarseStride;
-					const std::size_t lastBucket =
-					    std::min(srcB / coarseStride, coarseMin.size() - 1);
-					for (std::size_t bucket = firstBucket; bucket <= lastBucket; ++bucket)
-					{
-						const double bucketLow = coarseMin[bucket] * coarseScale + coarseOffset;
-						const double bucketHigh = coarseMax[bucket] * coarseScale + coarseOffset;
-						if (!std::isfinite(bucketLow))
-						{
-							// 该分组全部是无效值：包络到此断开，后续另起一段。
-							broken = true;
-							continue;
-						}
-						if (bucketLow < low)
-						{
-							low = bucketLow;
-							lowOrder = bucket;
-						}
-						if (bucketHigh > high)
-						{
-							high = bucketHigh;
-							highOrder = bucket;
-						}
-					}
-				}
-				else if (i1 > i0)
-				{
-					for (std::size_t index = srcA; index <= srcB; ++index)
-					{
-						const double value = ApplyDrawTransform(*resolved.style, values[index]);
-						if (!std::isfinite(value))
-						{
-							// 该列含无效值：包络绘制到本列结束，后续另起一段。
-							broken = true;
-							continue;
-						}
-						if (value < low)
-						{
-							low = value;
-							lowOrder = index;
-						}
-						if (value > high)
-						{
-							high = value;
-							highOrder = index;
-						}
-					}
-				}
-
-				// （二）跨越列边界的两段折线在边界处的取值。
-				//
-				// 波形按相邻采样点之间的**直线**绘制，而包络是按像素列聚合的。采样间隔
-				// 可能大于一个像素列（本仓库的 Problem_Data.csv 相邻采样间隔约 27µs 且不固定，
-				// 放大到 10ms/大格时一个像素列约 60µs），此时一次跃变的两个端点会分别落在
-				// 相邻两列里：对每一列来说"落在本列内的采样点"都在同一边，于是这段竖向折线
-				// 在两侧的包络里都不出现 → 波形在这些跃变处被整段丢掉，看上去就是"断开"。
-				//
-				// 把列边界处的折线取值计入本列包络即可消除该现象：折线在列内是线性的，
-				// 其极值必然出现在采样点或列边界上，因此「列内采样点 + 两侧边界取值」就是
-				// 该列包络的精确解，且相邻两列在边界处取到同一个值，包络带严丝合缝。
-				double boundary = 0.0;
-				if (PolylineValueAt(time, values, count, *resolved.style, i0, s0, boundary))
-				{
-					boundary = ApplyDrawTransform(*resolved.style, boundary);
-					if (boundary < low)
-					{
-						low = boundary;
-						lowOrder = (i0 > 0) ? SourceIndexFor(*resolved.style, count, i0 - 1) : 0;
-					}
-					if (boundary > high)
-					{
-						high = boundary;
-						highOrder = (i0 > 0) ? SourceIndexFor(*resolved.style, count, i0 - 1) : 0;
-					}
-				}
-				if (PolylineValueAt(time, values, count, *resolved.style, i1, s1, boundary))
-				{
-					boundary = ApplyDrawTransform(*resolved.style, boundary);
-					const std::size_t order = SourceIndexFor(*resolved.style, count, (i1 > 0) ? (i1 - 1) : 0);
-					if (boundary < low)
-					{
-						low = boundary;
-						lowOrder = order;
-					}
-					if (boundary > high)
-					{
-						high = boundary;
-						highOrder = order;
-					}
-				}
-
-				if (!(low <= high))
-				{
-					// 本列没有任何有效取值：折线尚未开始、已经结束，或该处数据缺失。
-					inSegment = false;
-					flushBandSegment();
-					continue;
-				}
-
-				const float x = plotLeft + (static_cast<float>(column) + 0.5f) * columnWidth;
-				const float yTop =
-				    static_cast<float>(ClampDouble(ValueToY(high, lane), limitTop, limitBottom));
-				const float yBottom =
-				    static_cast<float>(ClampDouble(ValueToY(low, lane), limitTop, limitBottom));
-
-				// 包络带每列都记录（上下各外扩半个线宽，保证细波动也有可见粗细）。
-				BandColumn bandColumn;
-				bandColumn.x = x;
-				bandColumn.top = yTop - strokeHalf;
-				bandColumn.bottom = yBottom + strokeHalf;
-				segmentColumns.push_back(bandColumn);
-
-				if (yBottom - yTop < kEnvelopeMinPixelSpan)
-				{
-					// 波动不足半个像素：只留一个顶点，避免无意义的重复顶点。
-					if (!inSegment)
-					{
-						breaks.push_back(points.size());
-						inSegment = true;
-					}
-					points.push_back(gd::PointF(x, yTop));
-				}
-				else
-				{
-					if (!inSegment)
-					{
-						breaks.push_back(points.size());
-						inSegment = true;
-					}
-					// 按采样点出现的先后顺序连接上下包络，保持走线方向一致。
-					if (lowOrder <= highOrder)
-					{
-						points.push_back(gd::PointF(x, yBottom));
-						points.push_back(gd::PointF(x, yTop));
-					}
-					else
-					{
-						points.push_back(gd::PointF(x, yTop));
-						points.push_back(gd::PointF(x, yBottom));
-					}
-				}
-
-				if (broken)
-				{
-					inSegment = false;
-					flushBandSegment();
-				}
-			}
-
-			flushBandSegment();
-			return;
-		}
-
-		std::size_t stride = 1;
-		if (visibleCount > budget)
-		{
-			stride = (visibleCount + budget - 1) / budget;
-		}
-
-		bool inSegment = false;
-
-		for (std::size_t index = begin; index < end; index += stride)
-		{
-			const double t = time[index];
-			// 水平镜像 = 数据反序：画面上第 index 个位置取源下标 count-1-index 的值。
-			const double value = ApplyDrawTransform(
-			    *resolved.style, values[SourceIndexFor(*resolved.style, count, index)]);
-			if (!std::isfinite(t) || !std::isfinite(value))
-			{
-				inSegment = false;
-				continue;
-			}
-
-			// 时间偏移：该采样画在 `t + offsetTime` 处（例如 t=1s、偏移 -0.5s → 画在 0.5s）。
-			const float x = TimeToX(t + timeShift);
-			float y = ValueToY(value, lane);
-			y = static_cast<float>(ClampDouble(y, limitTop, limitBottom));
-
-			if (!inSegment)
-			{
-				breaks.push_back(points.size());
-				points.push_back(gd::PointF(x, y));
-				inSegment = true;
-			}
-			else
-			{
-				points.push_back(gd::PointF(x, y));
-			}
-		}
-	}
-
-	void PlotView::PaintEmptyState(gd::Graphics& g)
-	{
-		std::wstring message;
-		if (m_dataSet == nullptr || m_dataSet->Empty())
-		{
-			message = L"打开数据文件以查看波形";
-		}
-		else
-		{
-			message = L"请在左侧勾选需要查看的信号（可同时加载多个文件，各自成为一个分组）";
-		}
-		UiText(g, message, m_fonts->ui, m_area, m_theme->textMuted, TextAlign::CENTER);
-	}
-
-	void PlotView::Paint(gd::Graphics& g)
-	{
-		if (m_theme == nullptr || m_fonts == nullptr)
-		{
-			return;
-		}
-
-		// 本帧整帧都在改写渲染状态（`m_area` / `m_plotRect` / 视界 / 图层…），
-		// 因此必须与「后台派生曲线计算」线程隔离：本锁同时保护渲染状态与派生缓存。
-		// ⚠️ 图层渲染**只在本线程内进行**（见头文件说明）：后台线程一旦改写
-		// `m_area` / `m_plotRect` / `Tab().ViewMin()`，就会覆盖用户正在进行的平移。
-		std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-
-		BuildLaneVisuals();
-
-		// 「边沿计数」的扫描预算**按帧重置**（见 `m_edgeScanFrame` 的说明）：
-		// 旧实现按 `GetTickCount64()` 分桶，帧率一高（`PostMessage` 自持重绘会把它拉高）
-		// 就会在同一系统 tick 内连画多帧而**完全不推进**统计 —— 用户报告
-		// “按住横向光标不动时统计卡住不更新”“回车确认参数后不移动鼠标就停在部分值”。
-		++m_edgeScanFrame;
-		m_edgeScanBudget = kEdgeScanPairsPerFrame;
-
-		// 双缓冲：清掉上一帧钉住的曲线条目（本帧会按需重新钉住），并清理已被更新条目覆盖 /
-		// 超出内存预算的旧条目。此刻没有任何条目被钉住，回收是安全的。
-		m_curvePins.clear();
-		{
-			std::lock_guard<std::mutex> lock(m_curveMutex);
-			PruneCurveEntriesLocked();
-		}
-		// 后台算好了新曲线：
-		//  * **静止**时：整幅作废一次，让新曲线（与新的静态场景缓存）立刻出现。
-		//  * **拖拽中**（拖弱峰调整/均值滤波参数滑块）：**不作废整幅** —— 拖拽时参数每帧都在变，
-		//    本来就每帧走"样式补丁"路径，补丁会直接取到最新曲线；若此时还整幅作废，
-		//    每帧会退化成整幅重绘（实测单帧 150ms+，与"拖动要跟手"直接冲突）。
-		//    改为标记"已降级"，等拖拽结束后再补一帧全质量。
-		if (m_curveSceneDirty.exchange(false, std::memory_order_relaxed))
-		{
-			if (m_dragMode == PlotDragMode::NONE)
-			{
-				InvalidateSceneCache();
-			}
-			else
-			{
-				m_sceneDegraded = true;
-			}
-		}
-
-		if (m_lanes.empty())
-		{
-			InvalidateSceneCache();
-			PaintEmptyState(g);
-			return;
-		}
-
-		// 「快速绘制（关闭抗锯齿）」只在**会改变画面主体（波形/网格几何）**的拖拽期间启用：
-		// 这些拖拽每帧都要重画波形，关掉抗锯齿能显著加速（同一条包络带 27.6ms → 3.2ms）。
-		// ⚠️ 像「拖时间光标」「选区框选」「拖浮动面板」这类**只改叠加层、画面主体不变**的交互，
-		// 一旦启用快速帧就会给静态场景缓存打上「已降级」标记 → 缓存失效 → 每帧整幅重画
-		//（实测拖光标从约 1ms 骤升到十几毫秒）。因此这里**不**把它们算作快速帧，
-		// 让它们直接复用静态场景缓存（贴图 ~1ms）+ 叠加层，做到真正跟手。
-		const bool sceneChangingDrag =
-		    (m_dragMode == PlotDragMode::PAN) || (m_dragMode == PlotDragMode::SCROLL_LANES) ||
-		    (m_dragMode == PlotDragMode::LANE_REORDER) || (m_dragMode == PlotDragMode::MOVE_SIGNAL);
-		m_fastFrame = sceneChangingDrag;
-
-		// 贴图之后、静态场景之外的全部内容（随鼠标变化或位于最上层）。
-		// 三个分支（完全命中 / 局部重画 / 整幅重绘）共用同一段，保证观感完全一致。
-		const auto paintOverlays = [this, &g]()
-		{
-			PaintHoverHighlight(g);
-			PaintLegendHighlight(g);
-			PaintRubberBand(g);
-			PaintCursor(g, m_lanes);
-			PaintEdgeCursor(g, m_lanes);
-			PaintSignalInteraction(g);
-			PaintHint(g);
-			// 网格 Y 轴上下限的输入框、以及「弱峰调整 → 迭代次数上限」的输入框都绘制在最上层
-			//（后者覆盖在浮动面板的滑块行之上）。
-			if (m_editTarget == PlotEditTarget::LANE_Y_MAX ||
-			    m_editTarget == PlotEditTarget::LANE_Y_MIN ||
-			    m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX)
-			{
-				PaintEditField(g);
-			}
-			PaintScrollBar(g);
-
-			// 绘图区外框（比网格内部分界线更重，形成明确整体边界）。
-			// 用 GDI 画 4 条线：GDI+ 的 DrawRectangle 带抗锯齿时单帧要花掉 1ms 以上。
-			{
-				const float left = m_plotRect.X;
-				const float top = m_plotRect.Y;
-				const float right = m_plotRect.X + m_plotRect.Width;
-				const float bottom = m_plotRect.Y + m_plotRect.Height;
-				const float border[16] = {left, top, right, top, right, top, right, bottom,
-				                          right, bottom, left, bottom, left, bottom, left, top};
-				UiDrawSolidLines(g, gd::RectF(left - 2.0f, top - 2.0f, m_plotRect.Width + 4.0f,
-				                             m_plotRect.Height + 4.0f),
-				                 border, 4, m_theme->axisLine | 0xFF000000u, 2);
-			}
-		};
-
-		// 网格次序拖拽：静态场景缓存仍然有效，但各网格要按位移重新"摆放"。
-		// 这里逐网格把缓存中的横向条带平移贴回（几十微秒），
-		// 因此拖动百万级采样的网格时依然流畅，且被拖网格的波形随鼠标自由移动。
-		if (m_dragMode == PlotDragMode::LANE_REORDER && m_laneDragFrom >= 0 && m_sceneValid)
-		{
-			PaintLaneReorder(g);
-			paintOverlays();
-			return;
-		}
-
-		// 静态场景复用（不再局限于拖拽）：只要视图几何、信号集合与显示样式都没变，
-		// "绘图区底色 + 全部网格 + 时间轴"就逐像素相同，直接贴图即可。
-		// 大文件下整幅重绘约 80ms，贴图约 1ms —— 鼠标悬停、拖拽选区这些
-		// "只改一小块叠加层"的交互因此不再重绘波形。
-		// 随鼠标变化的内容（悬停高亮、读数框、选区、光标、拖拽虚影、输入框）一律画在贴图之后。
-		if (SceneCacheMatches() && BlitSceneCache(g))
-		{
-			// ⚠️ **顺手做一次"空闲预热"**：图层不存在（刚加载 / 网格数量变化）或仍是旧跨度时，
-			// 在这里用既有预算机制**每帧至多补 1 个网格**。若不预热，用户第一次平移 / 选区放大
-			// 时，`Paint` 会在那一帧里**同步重建全部网格图层**（5 个网格实测 30~80ms）——
-			// 这正是"选区放大的第一帧特别卡"的根因（该帧其余工作只有约 16ms 的占位拉伸）。
-			// 命中静态场景缓存 ⇒ 本帧视图与缓存同源（视界没变），因此预热出来的图层不会白费。
-			WarmLaneLayersStep();
-			paintOverlays();
-			return;
-		}
-
-		// 视界平移 / 派生预览曲线参数变化：画面**基底**（网格/波形）不变，只是横向平移或
-		// 叠加的派生曲线变化。直接复用「宽缓冲区」已渲染的**基底**像素，只把派生曲线作为
-		// 叠加层重画 —— 前台 O(1)，不重画波形，因此无论放大到多深都保持跟手。
-		// 判定：网格结构未变（几何指纹一致）且**逐信号外观样式未变** → 属视图/派生变化，可用宽基底；
-		// 外观样式（颜色/粗细/透明度/模式）变化 → 交给下方"样式补丁"分支局部重画。
-		// ⚠️ 位置必须在"静态场景贴图"**之后**：视界与样式都没变时（典型：鼠标悬停移动）
-		//    应由静态场景贴图命中，绝不能落到这里 —— 否则每两帧就会触发一次"结算整幅重绘"，
-		//    悬停反而变卡。而它又必须在"样式补丁"**之前**：派生曲线参数变化（拖弱峰调整 /
-		//    均值滤波滑块）同样只需叠加重画派生曲线，走本分支比"逐网格补丁"更快且质量更高。
-		// ⚠️ **不要求"正在拖拽"**：非拖拽的视界变化（键盘方向键 / 工具栏）同样走此快路径，
-		//    避免该放大区间"整幅重绘约 124ms"的卡顿。
-		bool wideUsable = false;
-		if (HasDrawableContent() && m_sceneValid && m_sceneGeometryHash == SceneGeometryHash())
-		{
-			std::vector<std::vector<SceneStyleEntry>> currentStyles;
-			CollectSceneStyles(currentStyles);
-			wideUsable = (currentStyles == m_sceneStyles);
-		}
-		if (wideUsable)
-		{
-			// 内容（含视界）与本帧上一条快路径帧相同 → 视界已停止变化 → 走一次整幅"结算"
-			// 全质量帧（保证最终呈现**像素精确**；此后命中静态场景缓存，不再回到本分支）。
-			std::uint64_t wideKey = SceneContentHash(true);
-			wideKey ^= static_cast<std::uint64_t>(std::llround(Tab().ViewMin() * 1.0e6));
-			wideKey *= 1099511628211ull;
-			wideKey ^= static_cast<std::uint64_t>(std::llround(Tab().ViewMax() * 1.0e6));
-
-			// 「结算」：视界已停止变化（内容与视界都与上一条快路径帧相同）、**不在拖拽中**、
-			// 且**全部网格图层都已就绪** → 落到下方整幅全质量重绘，保证最终呈现像素精确
-			// （此后命中静态场景缓存，不再回到本分支）。
-			//
-			// ⚠️ 三个条件缺一不可：
-			//  * **不在拖拽中**：拖拽期间不做结算，否则每两帧就会穿插一次整幅重绘 ——
-			//    而拖拽帧的 `m_fastFrame` 为真（关抗锯齿），于是出现"波形质量轮流变差/抖动"
-			//    与周期性卡顿（这正是用户报告的"按住拖拽时显示效果下降、断线"的根因）。
-			//  * **全部图层就绪**：还有网格没画好时不能结算，否则结算帧之后的格子又是旧的。
-			//  * 记录已消费本 key，避免下一帧重复结算。
-			const bool viewStopped = (m_wideLastValid && m_wideLastKey == wideKey);
-			if (viewStopped && m_dragMode == PlotDragMode::NONE && LanesAllReadyForView())
-			{
-				m_wideLastValid = false;	// 结算：落到下方整幅重绘（非拖拽 → 全质量）
-			}
-			else
-			{
-				// ⚠️ **绝不在这里同步整批重建全部图层**：跨度变化（选区放大 / 键盘缩放 /
-				// 工具栏缩放）时若一次性重建 5 个网格，实测 70~80ms —— 这正是"缩放首帧卡顿"
-				// 的根因。改为：
-				//   * 只有"图层数量与网格数量不符"（首次绘制 / 增删网格）才必须同步整批建立；
-				//   * 跨度/内容过期的网格一律登记到待重画队列，由 `RollWideBuffer` 登记、
-				//     `RenderPendingLaneRebuilds` 按预算逐帧补齐；其间 `BlitWideBuffer`
-				//     会用**旧跨度像素拉伸**当占位图（低分辨率但立即可用，O(1)）。
-				if (!LayersAllocated())
-				{
-					RebuildWideBuffer();
-				}
-				// 逐网格滚动跟随视界。⚠️ `RollWideBuffer` **不做整块重画**：内容过期 / 锚点
-				// 过远的网格只登记到待重画队列，因此前台每帧的工作量恒定且很小。
-				RollWideBuffer();
-				// 预算内补画"待重画"的网格：**本帧最多一个**，其余留到后续帧
-				//（即使 5 个网格同时需要重画，前台也不会在某一帧里做完整批而卡顿）。
-				// ⚠️ **必须在贴图之前**：否则本帧画好的网格要到下一帧才显示，
-				// 拖拽时表现为"波形比鼠标慢半拍"、快速拖动时出现"断线"（图层覆盖不到视界）。
-				//
-				// ⚠️ **只在视界稳定后才花预算做精细重绘**（视界仍在变化的每一帧只贴"旧跨度像素拉伸"
-				// 的占位图，O(1)，把重建推迟到视界停下来之后 —— 用户要求"先画了再说，别卡住前台"），
-				// 且**仍按预算逐个补**（不用一次把全部过期网格塞进同一帧）：实测同一台机器上 4 线程
-				// 真并行（3.98x），但**图层光栅化（GDI+）本身会被串行化**，并行重建 5 个网格 ≈ 逐个重建
-				//（1.03x）→ 一次性补齐只会把一帧从 ~10ms 抬到 ~31ms（更容易掉帧）。
-				// 因此保持"视界停后**每帧补一个网格**"（`RenderPendingLaneRebuilds` 在 `budget>1` 时才走并行）。
-				const bool morePending =
-				    viewStopped ? RenderPendingLaneRebuilds(1) : !m_layerRebuildPending.empty();
-				// 绘图区底色（覆盖时间轴与侧边留白区域）。
-				UiFillRect(g, m_area, m_theme->plotBg);
-				// 贴基底（绘图区：网格 + 波形）。图层没覆盖到的部分先留空，后续帧补齐。
-				if (BlitWideBuffer(g))
-				{
-					m_wideLastKey = wideKey;
-					m_wideLastValid = true;
-					// 时间轴：宽缓冲不含它，前台按当前视图绘制。
-					const double wideViewMin = Tab().ViewMin();
-					const double wideViewMax = Tab().ViewMax();
-					const double wideSpanNow = wideViewMax - wideViewMin;
-					const double wideTimeStep =
-					    NiceStep((wideSpanNow > 0.0) ? wideSpanNow : 1.0, kTimeTickTarget);
-					std::vector<double> wideTimeTicks;
-					BuildTicks(wideViewMin, wideViewMax, wideTimeStep, wideTimeTicks);
-					PaintTimeAxis(g, wideTimeTicks, wideTimeStep);
-					// 网格分界线：图层里**不含**它（它锚定在网格的屏幕位置，会被纵向偏移贴图带走），
-					// 因此在这里补画一次（与整幅重绘同一套颜色与线宽）。
-					PaintLaneDividers(g);
-					// 派生预览曲线：基底不含它们（拖参数滑块时基底不变、可直接复用像素）。
-					for (std::size_t i = 0; i < m_lanes.size(); ++i)
-					{
-						PaintLaneDerivedOverlays(g, static_cast<int>(i), m_lanes[i]);
-					}
-					// 装饰（Y 轴刻度 + GX 编号 + 图例）：基底不含（否则平移会重影）。
-					// 内容指纹一致 → 直接按 `AlphaBlend` 贴回缓存（省掉文字绘制）；
-					// 否则先把装饰单独绘制进透明缓存位图，再贴回。
-					// ⚠️ 贴回的是**带 alpha 的圆角图形**：圆角之外是全透明，
-					// 因此透出的是**当前**波形 —— 既没有"直角白边"，也不会残留旧波形像素。
-					m_useDecorCache = m_decorValid && (m_decorKey == SceneDecorHash());
-					if (!m_useDecorCache && RenderDecorCache())
-					{
-						m_decorKey = SceneDecorHash();
-						m_useDecorCache = true;
-					}
-					if (m_useDecorCache)
-					{
-						BlitDecorCache(g);
-					}
-					else
-					{
-						// 退化路径（无法建立透明缓存，例如系统不提供 AlphaBlend）：
-						// 直接把装饰画进后备缓冲区（就地绘制，不做缓存）。
-						m_renderDecorOnly = true;
-						for (std::size_t i = 0; i < m_lanes.size(); ++i)
-						{
-							PaintLane(g, static_cast<int>(i), m_lanes[i], wideTimeTicks);
-						}
-						m_renderDecorOnly = false;
-					}
-					paintOverlays();
-					if (morePending)
-					{
-						// 请宿主再送一帧（与派生曲线就绪用同一条消息：只失效绘图区且不置脏）。
-						const HWND host = m_host;
-						if (host != nullptr)
-						{
-							PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
-						}
-					}
-					return;
-				}
-			}
-		}
-
-		// 只有"外观样式"变化（典型场景：拖动自定义颜色滑块实时调色）：网格结构、视图几何、
-		// 波形采样都没变，只是颜色/不透明度/线宽/模式不同 —— 此时只重画受影响的网格，
-		// 再写回缓存。（VERY_BIG_DATA 实测：整幅重绘 30ms+，单网格重画约 4ms。）
-		{
-			std::vector<int> patchLanes;
-			if (FindStyleOnlyLanes(patchLanes) && BlitSceneCache(g))
-			{
-				// ⚠️ 样式**正在连续变化**（拖透明度 / 粗细 / 拾色滑块）：这本身就是一种"交互中"。
-				// 若不切换快速帧，本帧会用**抗锯齿**重画波形包络带 —— 实测单条网格的包络带
-				// AA 填充 ≈29ms（本机负载下 72ms），而关掉 AA 只要 ≈5.6ms。
-				// 因此补丁阶段强制快速帧，并在补丁后把场景缓存标记为"已降级"，
-				// 下一帧（参数稳定后）自动补一帧全质量 —— 既保证拖动手感，又不牺牲最终画质。
-				m_fastFrame = true;
-				RepaintSceneCachePatch(g, patchLanes);
-				m_sceneDegraded = true;
-				paintOverlays();
-				return;
-			}
-		}
-
-		const double viewMin = Tab().ViewMin();
-		const double viewMax = Tab().ViewMax();
-		const double span = viewMax - viewMin;
-		const double timeStep = NiceStep((span > 0.0) ? span : 1.0, kTimeTickTarget);
-		std::vector<double> timeTicks;
-		BuildTicks(viewMin, viewMax, timeStep, timeTicks);
-
-		// 绘图区整体底色。
-		UiFillRect(g, m_area, m_theme->plotBg);
-
-		// 波形区域底色。
-		UiFillRect(g, m_plotRect, m_theme->cardBg);
-
-		// 图例命中矩形每帧重建，避免残留已消失的信号。
-		m_legendHits.clear();
-
-		// 「装饰层」：装饰**不在网格循环里就地绘制**，而是统一由带 alpha 的装饰层贴回
-		// （这样圆角之外透出的是当前波形，不会出现"直角白边"）。
-		m_decorRects.clear();
-		m_useDecorCache = true;
-
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			PaintLane(g, static_cast<int>(index), m_lanes[index], timeTicks);
-		}
-
-		PaintTimeAxis(g, timeTicks, timeStep);
-
-		// 装饰层：缓存与当前内容同源则直接贴回；否则先把装饰绘制进透明缓存位图再贴回。
-		if (!m_decorValid || m_decorKey != SceneDecorHash())
-		{
-			if (RenderDecorCache())
-			{
-				m_decorKey = SceneDecorHash();
-			}
-		}
-		BlitDecorCache(g);
-
-		// 此刻画布上正好是"绘图区底色 + 全部网格 + 时间轴"，尚未绘制任何随鼠标变化的内容，
-		// 因此是捕获静态场景缓存的最佳时点（必须在裁剪区已全部恢复之后执行）。
-		// ⚠️ 快速帧（交互期间，关闭了抗锯齿）**仍然捕获**（这样拖动参数滑块时能走
-		// "只重画受影响网格"的快路径），但打上 `m_sceneDegraded` 标记 →
-		// `SceneCacheMatches()` 会拒绝命中，交互结束后的下一帧必定重画全质量版本。
-		CaptureSceneCache(g);
-		m_sceneDegraded = m_fastFrame;
-
-		paintOverlays();
-	}
-
-	void PlotView::PaintSignalHaloFor(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
-	                                  const PolylineCacheEntry& cached)
-	{
-		if (resolved.style == nullptr)
-		{
-			return;
-		}
-		// 光晕一律用折线描边（与"之前"的画法一致）。曾经在包络带模式下改成"带外扩填充"，
-		// 虽然更快但观感变了（用户反馈显示效果下降），因此恢复。
-		PaintSignalHalo(g, resolved, lane, cached.points, cached.breaks);
-	}
-
-	void PlotView::PaintSignalHalo(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
-	                               const std::vector<gd::PointF>& points,
-	                               const std::vector<std::size_t>& breaks)
-	{
-		// ⚠️ **只有单个数据点**的信号（默认样式是「点线」，那个点本身是一个粗圆点）：
-		// 折线光晕无从下手（不足两个顶点），改为在数据点外包一圈强调色圆环。
-		// 否则悬停时完全没有“可拖拽”的视觉反馈（用户 2026-10-15 报告）。
-		if (resolved.data != nullptr && resolved.data->finiteCount == 1)
-		{
-			gd::PointF dot;
-			if (SinglePointScreenPos(resolved, lane, dot))
-			{
-				const float radius = SinglePointDotRadius(resolved) + 3.0f * m_scale;
-				gd::Pen ring(ToGdiColor(WithAlpha(m_theme->accent, 0x88)), 2.0f * m_scale);
-				g.DrawEllipse(&ring, dot.X - radius, dot.Y - radius, radius * 2.0f, radius * 2.0f);
-			}
-			return;
-		}
-
-		const bool drawLine = (resolved.style->mode != DrawMode::SCATTER);
-		if (!drawLine || breaks.empty())
-		{
-			// 散点模式没有光晕（原实现同样只对折线绘制光晕）。
-			return;
-		}
-
-		gd::Pen halo(ToGdiColor(WithAlpha(m_theme->accent, 0x66)),
-		             (resolved.style->lineWidth + 4.0f) * m_scale);
-		halo.SetLineJoin(gd::LineJoinRound);
-		halo.SetStartCap(gd::LineCapRound);
-		halo.SetEndCap(gd::LineCapRound);
-		for (std::size_t k = 0; k < breaks.size(); ++k)
-		{
-			const std::size_t start = breaks[k];
-			const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
-			if (stop <= start + 1)
-			{
-				continue;
-			}
-			g.DrawLines(&halo, points.data() + start, static_cast<INT>(stop - start));
-		}
-	}
-
-	void PlotView::PaintHoverHighlight(gd::Graphics& g)
-	{
-		if (m_tab == nullptr || m_dragMode != PlotDragMode::NONE)
-		{
-			// 拖拽过程中不显示悬停提示（拖拽中的信号光晕已绘入静态场景缓存）。
-			return;
-		}
-
-		const int saveState = g.Save();
-		g.SetClip(m_area, gd::CombineModeIntersect);
-
-		// 悬停网格：一层很淡的强调色叠加。为了能画在静态场景之上，
-		// 这里用半透明而非不透明混色，观感与原实现基本一致。
-		// ⚠️ 高亮来源见 `EffectiveHoverLane()`（浮动面板悬停 / 信号列表悬停），
-		//    **不再**由"鼠标在网格里"触发。
-		const int hoverLane = EffectiveHoverLane();
-		if (hoverLane >= 0 && hoverLane < static_cast<int>(m_lanes.size()))
-		{
-			const gd::RectF& laneRect = m_lanes[static_cast<std::size_t>(hoverLane)].rect;
-			const float clipTop = std::max(laneRect.Y, m_plotRect.Y);
-			const float clipBottom = std::min(laneRect.Y + laneRect.Height, m_plotRect.Y + m_plotRect.Height);
-			if (clipBottom > clipTop)
-			{
-				// alpha 0x0A ≈ 4%，与原「不透明混色 3.5%」的观感基本一致。
-				UiFillRect(g, gd::RectF(laneRect.X, clipTop, laneRect.Width, clipBottom - clipTop),
-				           WithAlpha(m_theme->accent, 0x0A));
-			}
-		}
-
-		// 悬停信号：外扩一圈半透明强调色作为"可拖拽"提示。
-		// 鼠标在绘图区内直接命中时用 `m_hoverSignal`；信号列表 / 样式区悬停时用
-		// `m_externalHoverSignal`（二者高亮方式相同，用户要求列表悬停也要高亮曲线本身）。
-		SignalRef haloRef = m_hoverSignal;
-		if (!haloRef.IsValid())
-		{
-			haloRef = m_externalHoverSignal;
-		}
-		if (haloRef.IsValid())
-		{
-			const ResolvedSignal resolved = ResolveSignal(haloRef);
-			if (resolved.data != nullptr && resolved.style != nullptr && resolved.visible)
-			{
-				const int laneIndex = m_tab->LaneOfSignal(haloRef);
-				if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()))
-				{
-					const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
-					const PolylineCacheEntry* cached = AcquirePolyline(haloRef, resolved, lane);
-					if (cached != nullptr)
-					{
-						PaintSignalHaloFor(g, resolved, lane, *cached);
-					}
-				}
-			}
-		}
-
-		g.Restore(saveState);
-	}
-
-	void PlotView::PaintLegendHighlight(gd::Graphics& g)
-	{
-		if (m_tab == nullptr || m_lanes.empty())
-		{
-			return;
-		}
-
-		const int saveState = g.Save();
-		g.SetClip(m_area, gd::CombineModeIntersect);
-
-		// ------------------------------------------------------------------
-		// (1) 网格编号徽标（GX）的悬停高亮。
-		//     徽标本体画在静态场景 / 装饰缓存里（不随鼠标变化），因此悬停时必须在贴图之后
-		//     **把徽标重画一遍**（不透明底色 + 圆角 + 文字）—— 否则它在缓存里被冻结，
-		//     鼠标移上去看不到任何反馈（用户要求的"参考信号列表里 GX 徽标"的悬停提示）。
-		//     ⚠️ 只在**未拖拽**时绘制：`LANE_REORDER` 期间网格连同徽标被整体平移贴图，
-		//     这里按静态位置重画会画到错误的地方。
-		// ------------------------------------------------------------------
-		if (m_dragMode == PlotDragMode::NONE && m_hoverBadge >= 0 &&
-		    m_hoverBadge < static_cast<int>(m_lanes.size()))
-		{
-			const gd::RectF badge = LaneBadgeRect(m_hoverBadge);
-			if (badge.Width > 0.0f)
-			{
-				const float radius = kLaneBadgeHeight * m_scale * 0.5f;
-				// 只重画**圆角形状本身**（不透明）：圆角之外保持"贴图层"的像素，
-				// 因此不会出现直角白边。
-				UiFillRoundRect(g, badge, radius, m_theme->accentSoft);
-				UiDrawRoundRect(g, badge, radius, m_theme->accent, 1.0f);
-				UiText(g, L"G" + std::to_wstring(m_hoverBadge + 1), m_fonts->monoSmall, badge,
-				       m_theme->textStrong, TextAlign::CENTER);
-			}
-		}
-
-		// ------------------------------------------------------------------
-		// (2) 图例条目悬停：条目托底高亮 + **对应信号曲线**的光晕。
-		// ------------------------------------------------------------------
-		if (m_dragMode != PlotDragMode::NONE || !m_hoverLegend.IsValid())
-		{
-			g.Restore(saveState);
-			return;
-		}
-		const int laneIndex = m_tab->LaneOfSignal(m_hoverLegend);
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			g.Restore(saveState);
-			return;
-		}
-		const gd::RectF laneRect = m_lanes[static_cast<std::size_t>(laneIndex)].rect;
-		if (laneRect.Y > m_plotRect.Y + m_plotRect.Height ||
-		    laneRect.Y + laneRect.Height < m_plotRect.Y)
-		{
-			g.Restore(saveState);
-			return;
-		}
-
-		// 除了图例条目本身，还要把**对应的信号曲线**一并高亮：用户在网格图例上移动时
-		// 一眼就能确认这条条目对应哪条曲线（与"鼠标贴近曲线"时的光晕提示一致）。
-		const ResolvedSignal resolved = ResolveSignal(m_hoverLegend);
-		if (resolved.data != nullptr && resolved.style != nullptr && resolved.visible)
-		{
-			const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
-			if (const PolylineCacheEntry* cached = AcquirePolyline(m_hoverLegend, resolved, lane))
-			{
-				PaintSignalHaloFor(g, resolved, lane, *cached);
-			}
-		}
-
-		// 条目悬停高亮：**圆角托底 + 与选中态相同的高亮**（用户明确要求"悬停效果与 GX 标签
-		// 相同、选中状态与悬停提示效果相同"），并在其上**原样重绘色块与文字** ——
-		// 不透明托底若只画底色会把图例内容整块盖住（只剩一个空色块）。
-		for (const LegendHit& hit : m_legendHits)
-		{
-			if (hit.ref == m_hoverLegend)
-			{
-			const float radius = (hit.radius > 0.0f) ? hit.radius : (kLaneBadgeHeight * 0.5f * m_scale);
-				UiFillRoundRect(g, hit.rect, radius, m_theme->accentSoft);
-				UiDrawRoundRect(g, hit.rect, radius, m_theme->accent, 1.0f);
-				UiDrawSwatch(g, hit.swatch, hit.swatchColor, hit.swatchOpacity, 1.5f * m_scale, m_scale);
-				UiText(g, hit.label, m_fonts->uiTiny, hit.text, m_theme->textStrong, TextAlign::LEFT);
-				break;
-			}
-		}
-		g.Restore(saveState);
-	}
-
-	PlotView::SceneCacheKey PlotView::MakeSceneCacheKey() const
-	{
-		SceneCacheKey key;
-		key.viewMin = Tab().ViewMin();
-		key.viewMax = Tab().ViewMax();
-		key.laneScroll = Tab().LaneScroll();
-		key.laneCount = static_cast<int>(m_lanes.size());
-		key.areaX = m_area.X;
-		key.areaY = m_area.Y;
-		key.areaW = m_area.Width;
-		key.areaH = m_area.Height;
-		key.scale = m_scale;
-
-		const SignalRef halo = SceneHaloRef();
-		key.haloFile = halo.groupIndex;
-		key.haloSignal = halo.signalIndex;
-		key.contentHash = SceneContentHash();
-		return key;
-	}
-
-	bool PlotView::SceneCacheMatches() const
-	{
-		if (!m_sceneValid)
-		{
-			return false;
-		}
-		// 缓存里存的是「快速帧」（关掉了抗锯齿）→ 不能直接命中：
-		// 必须重画一次全质量版本，否则降级的画面会一直留在屏幕上。
-		if (m_sceneDegraded)
-		{
-			return false;
-		}
-		const SceneCacheKey& cached = m_sceneKey;
-		const SceneCacheKey key = MakeSceneCacheKey();
-		return (key.viewMin == cached.viewMin) && (key.viewMax == cached.viewMax) &&
-		       (key.laneScroll == cached.laneScroll) && (key.laneCount == cached.laneCount) &&
-		       (key.areaX == cached.areaX) && (key.areaY == cached.areaY) &&
-		       (key.areaW == cached.areaW) && (key.areaH == cached.areaH) &&
-		       (key.scale == cached.scale) && (key.haloFile == cached.haloFile) &&
-		       (key.haloSignal == cached.haloSignal) && (key.contentHash == cached.contentHash);
-	}
-
-	SignalRef PlotView::SceneHaloRef() const
-	{
-		// 只有拖拽中的信号光晕是“整个拖拽过程都不变”的，可以安全地绘入静态场景缓存；
-		// 悬停光晕随鼠标移动，必须画在缓存之外（见 PaintHoverHighlight）。
-		if (m_dragMode == PlotDragMode::MOVE_SIGNAL && m_dragSignal.IsValid())
-		{
-			return m_dragSignal;
-		}
-		return SignalRef();
-	}
-
-	std::uint64_t PlotView::SceneContentHash(bool includeStyles, bool includeDerived,
-	                                        bool includeLaneRange) const
-	{
-		// FNV-1a：把“视图几何之外的一切影响绘图区像素的内容”折叠成一个指纹。
-		// 这样颜色/线宽/透明度/样式/重命名/信号增删等变化都会自动让缓存失效，
-		// 不需要在各处手工调用 InvalidateSceneCache（容易漏）。
-		// `includeStyles == false` 时跳过逐信号的外观样式（颜色/不透明度/线宽/模式），
-		// 得到的就是几何指纹：它一致说明“只有外观样式变了”。
-		std::uint64_t hash = 1469598103934665603ull;
-		const auto mix = [&hash](std::uint64_t value)
-		{
-			hash ^= value;
-			hash *= 1099511628211ull;
-		};
-		const auto mixFloat = [&mix](float value)
-		{
-			std::uint32_t bits = 0;
-			std::memcpy(&bits, &value, sizeof(bits));
-			mix(bits);
-		};
-		const auto mixText = [&mix](const std::wstring& text)
-		{
-			mix(text.size());
-			for (const wchar_t character : text)
-			{
-				mix(static_cast<std::uint64_t>(character));
-			}
-		};
-
-		mixFloat(m_plotRect.X);
-		mixFloat(m_plotRect.Y);
-		mixFloat(m_plotRect.Width);
-		mixFloat(m_plotRect.Height);
-		mixFloat(m_laneContentHeight);
-		mix(m_scrollBarVisible ? 1ull : 0ull);
-		// ⚠️ 网格纵向滚动量必须参与指纹：它只改变各网格的绘制位置。
-		// 若不参与，平移宽缓冲区 / 静态场景缓存会把旧滚动位置的像素当成当前内容贴回，
-		// 表现为“网格位置错位 / 拖影 / 残留”等错误元素。
-		mixFloat(Tab().LaneScroll());
-
-		// 选中信号会改变图例条目的底色与文字颜色（绘制在缓存的静态场景里），
-		// 因此必须参与指纹：否则在左侧信号面板点选后图例不会高亮联动。
-		{
-			const SignalRef selected = SelectedRef();
-			mix(selected.IsValid() ? 1ull : 0ull);
-			mix(static_cast<std::uint64_t>(selected.groupIndex));
-			mix(static_cast<std::uint64_t>(selected.signalIndex));
-		}
-
-		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
-		{
-			const LaneVisual& visual = m_lanes[laneIndex];
-			mixFloat(visual.rect.Y);
-			mixFloat(visual.rect.Height);
-			// ⚠️ 幅值范围只在 `includeLaneRange` 时计入：拖拽平移时的纵向分量会每帧小幅改动它，
-			// 若参与“宽基底可用性”判据，每一帧都会退化成整幅重绘（质量下降 + 卡顿）。
-			if (includeLaneRange)
-			{
-				mixFloat(static_cast<float>(visual.yMin));
-				mixFloat(static_cast<float>(visual.yMax));
-			}
-
-			const std::vector<SignalRef>& signals = Tab().Lanes()[laneIndex].signals;
-			// 「边沿计数（中心轴）」「均值滤波」「弱峰调整」的开关与每条被勾选信号的参数
-			// 会改变网格内的曲线绘制。它们**只影响网格内容**（不影响网格结构/几何），
-			// 因此只在 includeStyles 时计入 —— 于是拖参数滑块可以走“局部重画”快路径，
-			// 而不必整幅重绘（`FindStyleOnlyLanes` 用 `m_sceneDerived` 定位受影响的网格）。
-			// `includeDerived == false` 时连这些参数也不计入（用于装饰层指纹：图例/Y 轴刻度
-			// 与派生曲线参数无关，拖滑块时装饰层无需失效）。
-			if (includeStyles && includeDerived)
-			{
-				mix(Tab().Lanes()[laneIndex].edgeCenter ? 1ull : 0ull);
-				mix(static_cast<std::uint64_t>(Tab().Lanes()[laneIndex].edgeCenterItems.size()));
-				for (const Lane::EdgeCenterItem& item : Tab().Lanes()[laneIndex].edgeCenterItems)
-				{
-					mix(static_cast<std::uint64_t>(item.ref.groupIndex));
-					mix(static_cast<std::uint64_t>(item.ref.signalIndex));
-					mix(static_cast<std::uint64_t>(item.points));
-					mix(static_cast<std::uint64_t>(item.iterations));
-				}
-				mix(Tab().Lanes()[laneIndex].meanFilter ? 1ull : 0ull);
-				mix(static_cast<std::uint64_t>(Tab().Lanes()[laneIndex].meanFilterItems.size()));
-				for (const Lane::MeanFilterItem& item : Tab().Lanes()[laneIndex].meanFilterItems)
-				{
-					mix(static_cast<std::uint64_t>(item.ref.groupIndex));
-					mix(static_cast<std::uint64_t>(item.ref.signalIndex));
-					mix(static_cast<std::uint64_t>(item.points));
-					mix(static_cast<std::uint64_t>(item.iterations));
-				}
-				mix(Tab().Lanes()[laneIndex].weakPeak ? 1ull : 0ull);
-				mix(static_cast<std::uint64_t>(Tab().Lanes()[laneIndex].weakPeakItems.size()));
-				for (const Lane::WeakPeakItem& item : Tab().Lanes()[laneIndex].weakPeakItems)
-				{
-					// 逐信号参数（等级 + 迭代次数）都参与指纹：改任一条的参数都会重画。
-					mix(static_cast<std::uint64_t>(item.ref.groupIndex));
-					mix(static_cast<std::uint64_t>(item.ref.signalIndex));
-					mix(static_cast<std::uint64_t>(item.amountPercent));
-					mix(static_cast<std::uint64_t>(item.iterations));
-				}
-			}
-			mix(signals.size());
-			for (const SignalRef& ref : signals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				mix(static_cast<std::uint64_t>(ref.groupIndex));
-				mix(static_cast<std::uint64_t>(ref.signalIndex));
-				mix(resolved.visible ? 1ull : 0ull);
-				if (resolved.data == nullptr || resolved.style == nullptr)
-				{
-					continue;
-				}
-				// 以下四项是“只影响外观”的样式：仅在 includeStyles 时计入指纹。
-				// （不参与时得到的就是 SceneGeometryHash：它一致说明只有外观变了，
-				//   于是可以只重画颜色变了的网格，而不必整幅重绘。）
-				if (includeStyles)
-				{
-					mix(static_cast<std::uint64_t>(resolved.style->color));
-					mixFloat(resolved.style->opacity);
-					mixFloat(resolved.style->lineWidth);
-					mix(static_cast<std::uint64_t>(resolved.style->mode));
-					// 绘制前的数值变换（系数 / 绝对值 / 镜像）会改变波形形状。
-					mixFloat(resolved.style->gain);
-					mix(resolved.style->absolute ? 1ull : 0ull);
-					mix(resolved.style->mirrorVertical ? 1ull : 0ull);
-					mix(resolved.style->mirrorHorizontal ? 1ull : 0ull);
-					// 偏移（Y 平移 + 时间平移）同样会改变波形。
-					mixFloat(resolved.style->offsetY);
-					mixFloat(static_cast<float>(resolved.style->offsetTime));
-				}
-				// 图例文案参与绘制，重命名必须让缓存失效。
-				mixText(resolved.data->name);
-				if (resolved.group != nullptr)
-				{
-					mixText(resolved.group->name);
-				}
-			}
-		}
-		return hash;
-	}
-
-	std::uint64_t PlotView::SceneGeometryHash() const
-	{
-		// 外观样式不参与；各网格的幅值范围也不参与（那由逐网格图层指纹负责，
-		// 这样拖拽时的纵向分量不会把整幅重绘的快路径打掉）。
-		return SceneContentHash(false, true, false);
-	}
-
-	std::uint64_t PlotView::SceneDecorHash() const
-	{
-		// 装饰层（图例 + Y 轴刻度）的指纹：含外观样式，但**不含派生曲线参数**
-		//（拖弱峰调整等级/迭代次数滑块时图例与刻度不变，装饰层缓存不应失效）。
-		return SceneContentHash(true, false);
-	}
-
-	void PlotView::CollectSceneStyles(std::vector<std::vector<SceneStyleEntry>>& out) const
-	{
-		out.clear();
-		out.resize(m_lanes.size());
-		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
-		{
-			const std::vector<SignalRef>& signals = Tab().Lanes()[laneIndex].signals;
-			std::vector<SceneStyleEntry>& lane = out[laneIndex];
-			lane.reserve(signals.size());
-			for (const SignalRef& ref : signals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				SceneStyleEntry entry;
-				if (resolved.style != nullptr)
-				{
-					entry.color = resolved.style->color;
-					entry.opacity = resolved.style->opacity;
-					entry.lineWidth = resolved.style->lineWidth;
-					entry.mode = static_cast<int>(resolved.style->mode);
-					entry.gain = resolved.style->gain;
-					entry.absolute = resolved.style->absolute;
-					entry.mirrorVertical = resolved.style->mirrorVertical;
-					entry.mirrorHorizontal = resolved.style->mirrorHorizontal;
-					entry.offsetY = resolved.style->offsetY;
-					entry.offsetTime = resolved.style->offsetTime;
-				}
-				lane.push_back(entry);
-			}
-		}
-	}
-
-	bool PlotView::FindStyleOnlyLanes(std::vector<int>& lanes) const
-	{
-		lanes.clear();
-		if (!m_sceneValid || m_sceneGeometryHash != SceneGeometryHash())
-		{
-			// 网格结构 / 视图几何 / 信号集合 / 图例文案有变化：必须整幅重绘。
-			return false;
-		}
-
-		// ⚠️ **必须额外确认“视图几何与缓存完全一致”**：`SceneGeometryHash()` 刻意不含视界，
-		// 所以它相等**并不能**说明视图没变。若视界已经变了还走“只重画受影响网格”的局部补丁，
-		// 就会把缓存里**旧视界**的画面（时间轴、其它网格、底色）留在屏上 —— 表现为用户反馈的
-		// “拖影 / 残留 / 错误元素”。因此这里逐项比较除内容指纹之外的缓存键。
-		{
-			const SceneCacheKey key = MakeSceneCacheKey();
-			if (key.viewMin != m_sceneKey.viewMin || key.viewMax != m_sceneKey.viewMax ||
-			    key.laneScroll != m_sceneKey.laneScroll || key.laneCount != m_sceneKey.laneCount ||
-			    key.areaX != m_sceneKey.areaX || key.areaY != m_sceneKey.areaY ||
-			    key.areaW != m_sceneKey.areaW || key.areaH != m_sceneKey.areaH ||
-			    key.scale != m_sceneKey.scale || key.haloFile != m_sceneKey.haloFile ||
-			    key.haloSignal != m_sceneKey.haloSignal)
-			{
-				return false;
-			}
-		}
-
-		std::vector<std::vector<SceneStyleEntry>> current;
-		CollectSceneStyles(current);
-		if (current.size() != m_sceneStyles.size())
-		{
-			return false;
-		}
-
-		// 叠加预览曲线（均值滤波 / 中心轴 / 弱峰调整）的参数变化同样只需局部重画。
-		std::vector<SceneDerivedEntry> currentDerived;
-		CollectSceneDerived(currentDerived);
-		const bool derivedComparable = (currentDerived.size() == m_sceneDerived.size());
-
-		for (std::size_t laneIndex = 0; laneIndex < current.size(); ++laneIndex)
-		{
-			const std::vector<SceneStyleEntry>& now = current[laneIndex];
-			const std::vector<SceneStyleEntry>& before = m_sceneStyles[laneIndex];
-			if (now.size() != before.size())
-			{
-				return false;
-			}
-			bool differs = false;
-			for (std::size_t index = 0; index < now.size() && !differs; ++index)
-			{
-				differs = (now[index].color != before[index].color) ||
-				          (now[index].opacity != before[index].opacity) ||
-				          (now[index].lineWidth != before[index].lineWidth) ||
-				          (now[index].mode != before[index].mode);
-			}
-			if (!differs && derivedComparable)
-			{
-				const SceneDerivedEntry& nowDerived = currentDerived[laneIndex];
-				const SceneDerivedEntry& beforeDerived = m_sceneDerived[laneIndex];
-				differs = (nowDerived.edgeCenter != beforeDerived.edgeCenter) ||
-				          (nowDerived.meanFilter != beforeDerived.meanFilter) ||
-				          (nowDerived.weakPeak != beforeDerived.weakPeak) ||
-				          (nowDerived.edgeCenterItems != beforeDerived.edgeCenterItems) ||
-				          (nowDerived.meanFilterItems != beforeDerived.meanFilterItems) ||
-				          (nowDerived.weakPeakItems != beforeDerived.weakPeakItems);
-			}
-			if (differs)
-			{
-				lanes.push_back(static_cast<int>(laneIndex));
-			}
-		}
-		return !lanes.empty();
-	}
-
-	void PlotView::CollectSceneDerived(std::vector<SceneDerivedEntry>& out) const
-	{
-		out.clear();
-		out.resize(m_lanes.size());
-		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
-		{
-			const Lane& lane = Tab().Lanes()[laneIndex];
-			SceneDerivedEntry entry;
-			entry.edgeCenter = lane.edgeCenter ? 1 : 0;
-			entry.meanFilter = lane.meanFilter ? 1 : 0;
-			entry.weakPeak = lane.weakPeak ? 1 : 0;
-			const auto flatten = [](const auto& items, std::vector<int>& target, auto valueOf)
-			{
-				target.clear();
-				target.reserve(items.size() * 4);
-				for (const auto& item : items)
-				{
-					target.push_back(item.ref.groupIndex);
-					target.push_back(item.ref.signalIndex);
-					// 均值滤波/中心轴取 points，弱峰调整取 amountPercent（由 `valueOf` 决定）。
-					target.push_back(static_cast<int>(valueOf(item)));
-					target.push_back(item.iterations);
-				}
-			};
-			flatten(lane.edgeCenterItems, entry.edgeCenterItems,
-			        [](const Lane::EdgeCenterItem& item) { return item.points; });
-			flatten(lane.meanFilterItems, entry.meanFilterItems,
-			        [](const Lane::MeanFilterItem& item) { return item.points; });
-			flatten(lane.weakPeakItems, entry.weakPeakItems,
-			        [](const Lane::WeakPeakItem& item) { return item.amountPercent; });
-			out[laneIndex] = std::move(entry);
-		}
-	}
-
-	void PlotView::RepaintSceneCachePatch(gd::Graphics& g, const std::vector<int>& lanes)
-	{
-		if (lanes.empty() || m_sceneDc == nullptr)
-		{
-			return;
-		}
-
-		// 重画范围 = 受影响网格与绘图区的交集（并且不超出缓存区域）。
-		float top = 1.0e9f;
-		float bottom = -1.0e9f;
-		for (const int laneIndex : lanes)
-		{
-			if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-			{
-				continue;
-			}
-			const gd::RectF& rect = m_lanes[static_cast<std::size_t>(laneIndex)].rect;
-			top = std::min(top, rect.Y);
-			bottom = std::max(bottom, rect.Y + rect.Height);
-		}
-		if (bottom <= top)
-		{
-			return;
-		}
-		top = std::max(top, m_plotRect.Y);
-		bottom = std::min(bottom, m_plotRect.Y + m_plotRect.Height);
-		if (bottom <= top)
-		{
-			return;
-		}
-
-		// ⚠️ 补丁矩形必须**向内**对齐到整数像素（ceil 上边界、floor 下边界）：
-		// 网格矩形是浮点数，而 GDI `FillRect`/`BitBlt` 会按 floor/ceil 向外取整，
-		// "向外"会多擦掉/多写回一整行，那一行属于相邻网格（例如它的分界线），
-		// 于是补丁边界上会留下一像素接缝。向内对齐后，边界外的行一律由缓存提供
-		// （缓存内容与整幅重绘逐像素一致，已由对照帧验证）。
-		const int x0 = std::max(static_cast<int>(std::ceil(m_area.X)), static_cast<int>(std::ceil(m_area.X)));
-		const int y0 = std::max(static_cast<int>(std::ceil(top)), static_cast<int>(std::ceil(m_area.Y)));
-		const int x1 = std::min(static_cast<int>(std::floor(m_area.X + m_area.Width)),
-		                        static_cast<int>(std::floor(m_area.X + m_area.Width)));
-		const int y1 = std::min(static_cast<int>(std::floor(bottom)),
-		                        static_cast<int>(std::floor(m_area.Y + m_area.Height)));
-		if (x1 <= x0 || y1 <= y0)
-		{
-			return;
-		}
-
-		const gd::RectF patch(static_cast<float>(x0), static_cast<float>(y0),
-		                      static_cast<float>(x1 - x0), static_cast<float>(y1 - y0));
-
-		// 补丁区域必须被**完整**重画：凡是与它相交的网格都要重画一遍
-		// （补丁已向内对齐，正常只会命中受影响的那几个网格）。
-		std::vector<int> repaint;
-		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
-		{
-			const gd::RectF& rect = m_lanes[laneIndex].rect;
-			if (rect.Y < static_cast<float>(y1) && rect.Y + rect.Height > static_cast<float>(y0))
-			{
-				repaint.push_back(static_cast<int>(laneIndex));
-			}
-		}
-		if (repaint.empty())
-		{
-			return;
-		}
-
-		// 与整幅重绘保持完全相同的绘制顺序：底色 → 逐网格内容（PaintLane 会与当前裁剪区求交）。
-		{
-			const int saveState = g.Save();
-			g.SetClip(patch, gd::CombineModeIntersect);
-			// ⚠️ 底色填充必须**按补丁矩形本身**填充，不能用 m_area / m_plotRect：
-			// `UiFillRect` 对大面积不透明矩形会走 GDI `FillRect` 快路径，而 GDI 绘制
-			// **不受 GDI+ 裁剪区约束**，会把已经贴好的缓存内容整片覆盖掉。
-			UiFillRect(g, patch, m_theme->plotBg);
-			const float cardTop = std::max(patch.Y, m_plotRect.Y);
-			const float cardBottom = std::min(patch.Y + patch.Height, m_plotRect.Y + m_plotRect.Height);
-			if (cardBottom > cardTop)
-			{
-				UiFillRect(g, gd::RectF(patch.X, cardTop, patch.Width, cardBottom - cardTop),
-				           m_theme->cardBg);
-			}
-
-			const double viewMin = Tab().ViewMin();
-			const double viewMax = Tab().ViewMax();
-			const double span = viewMax - viewMin;
-			const double timeStep = NiceStep((span > 0.0) ? span : 1.0, kTimeTickTarget);
-			std::vector<double> timeTicks;
-			BuildTicks(viewMin, viewMax, timeStep, timeTicks);
-
-			// ⚠️ **补丁必须就地绘制装饰**（而不是"跳过装饰"）：补丁范围覆盖整个受影响网格
-			// （含网格左缘的 Y 轴胶囊与图例），若跳过绘制，这部分像素会被网格底色/波形覆盖，
-			// 而补丁结果还会写回场景缓存 —— 表现为"改样式时图例/Y 轴读数闪掉一下"。
-			const bool savedUseDecorCache = m_useDecorCache;
-			m_useDecorCache = false;
-			for (const int laneIndex : repaint)
-			{
-				if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()))
-				{
-					PaintLane(g, laneIndex, m_lanes[static_cast<std::size_t>(laneIndex)], timeTicks);
-				}
-			}
-			m_useDecorCache = savedUseDecorCache;
-			g.Restore(saveState);
-		}
-
-		// 把重画结果写回缓存位图，使缓存与当前样式一致（下一帧即回到"完全命中"快路径）。
-		{
-			HDC target = g.GetHDC();
-			if (target != nullptr)
-			{
-				BitBlt(m_sceneDc, x0 - m_sceneX, y0 - m_sceneY, x1 - x0, y1 - y0, target, x0, y0, SRCCOPY);
-				g.ReleaseHDC(target);
-			}
-		}
-
-		m_sceneKey = MakeSceneCacheKey();
-		m_sceneGeometryHash = SceneGeometryHash();
-		CollectSceneStyles(m_sceneStyles);
-		CollectSceneDerived(m_sceneDerived);
-		m_sceneDegraded = m_sceneDegraded || m_fastFrame;
-	}
-
-	gd::RectF PlotView::LaneBadgeRect(int laneIndex) const
-	{
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return gd::RectF();
-		}
-		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
-		const gd::RectF legendBand(lane.rect.X + kLegendPad * m_scale, lane.rect.Y + kLegendPad * m_scale,
-		                           lane.rect.Width, kLegendHeight * m_scale);
-		// 网格被滚动出可视区时没有徽标可点。
-		const float visibleTop = std::max(lane.rect.Y, m_plotRect.Y);
-		const float visibleBottom =
-		    std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height);
-		if (!IsFullyVisible(legendBand, visibleTop, visibleBottom))
-		{
-			return gd::RectF();
-		}
-
-		const float height = kLegendHeight * m_scale;
-		const float badgeHeight = kLaneBadgeHeight * m_scale;
-		return gd::RectF(legendBand.X, legendBand.Y + (height - badgeHeight) * 0.5f,
-		                 kLaneBadgeWidth * m_scale, badgeHeight);
-	}
-
-	int PlotView::LaneBadgeAtPoint(int x, int y) const
-	{
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			const gd::RectF badge = LaneBadgeRect(static_cast<int>(index));
-			if (badge.Width > 0.0f && UiPointInRect(badge, fx, fy))
-			{
-				return static_cast<int>(index);
-			}
-		}
-		return -1;
-	}
-
-	float PlotView::LaneDragOffset(int laneIndex) const
-	{
-		if (m_dragMode != PlotDragMode::LANE_REORDER || m_laneDragFrom < 0 ||
-		    laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return 0.0f;
-		}
-
-		const float laneHeight = m_lanes[static_cast<std::size_t>(m_laneDragFrom)].rect.Height;
-		if (laneIndex == m_laneDragFrom)
-		{
-			// 被拖拽的网格自由跟随鼠标（整体绘制区域跟着走）。
-			const float baseTop = m_lanes[static_cast<std::size_t>(laneIndex)].rect.Y;
-			return static_cast<float>(m_laneDragMouseY) - m_laneDragGrabOffset - baseTop;
-		}
-
-		const int target = (m_laneDragTarget >= 0) ? m_laneDragTarget : m_laneDragFrom;
-		if (target > m_laneDragFrom && laneIndex > m_laneDragFrom && laneIndex < target)
-		{
-			// 向下拖：被跨越的网格整体上移一格让出位置（大小不变）。
-			// 移动到插入位置 target 的结果是 [1,2,...,A,target,...]，
-			// 因此需要上移的是 (from, target) 区间内的网格，不含 target 本身。
-			return -laneHeight;
-		}
-		if (target < m_laneDragFrom && laneIndex >= target && laneIndex < m_laneDragFrom)
-		{
-			// 向上拖：中间的网格整体下移一格。
-			return laneHeight;
-		}
-		return 0.0f;
-	}
-
-	int PlotView::LaneDragTargetAt(int mouseY) const
-	{
-		if (m_lanes.empty())
-		{
-			return 0;
-		}
-		const int count = static_cast<int>(m_lanes.size());
-		const float laneHeight = m_lanes.front().rect.Height;
-		if (!(laneHeight > 0.0f))
-		{
-			return m_laneDragFrom;
-		}
-
-		// 判据 = **被拖网格自己的上下边界**（用户明确要求）：
-		//   * 上边界越过"上方第 m 个网格"的中心水平线 → 让位 m 个位置（插入位置 = from - m）；
-		//   * 下边界越过"下方第 m 个网格"的中心水平线 → 让位 m 个位置（插入位置 = from + m + 1，
-		//     因为被拖网格会先从原位置摘除，越过后应落在该网格之后）。
-		//
-		// ⚠️ 旧判据只看**鼠标指针**落在哪个网格的哪一半。因为被拖网格整体跟随指针，而指针通常
-		// 按在网格上沿的 GX 徽标上，于是"向下拖必须把整个网格拖过下方网格才吸附、
-		// 向上拖只要半个网格" —— 上下不对称（用户报告）。改用网格边界后上下完全对称。
-		//
-		// 数学：令 shift = 被拖网格相对原槽位的位移，H = 网格高。
-		//   上边界 = baseTop + shift，上方第 m 个网格的中心线 = baseTop - (m - 0.5)H
-		//   ⇒ 满足 shift < (0.5 - m)H 的最大 m 即让位格数（m < 0.5 - shift/H）；
-		//   下边界 = baseTop + shift + H，下方第 m 个网格的中心线 = baseTop + (m + 0.5)H
-		//   ⇒ 满足 shift > (m - 0.5)H 的最大 m（m < shift/H + 0.5）。
-		// ⚠️ 两侧条件互斥（不可能同时成立），因此最多只会向一侧吸附。
-		const float baseTop = m_lanes[static_cast<std::size_t>(m_laneDragFrom)].rect.Y;
-		const float shift =
-		    static_cast<float>(mouseY) - m_laneDragGrabOffset - baseTop;
-		const float upRatio = 0.5f - shift / laneHeight;		// m < upRatio
-		const float downRatio = shift / laneHeight + 0.5f;		// m < downRatio
-		// "严格小于" ⇒ 最大整数 m = ceil(ratio) - 1。
-		int up = static_cast<int>(std::ceil(upRatio)) - 1;
-		int down = static_cast<int>(std::ceil(downRatio)) - 1;
-		up = std::max(0, std::min(up, m_laneDragFrom));
-		down = std::max(0, std::min(down, count - 1 - m_laneDragFrom));
-		if (up > 0)
-		{
-			return m_laneDragFrom - up;
-		}
-		if (down > 0)
-		{
-			return m_laneDragFrom + down + 1;
-		}
-		return m_laneDragFrom;
-	}
-
-	void PlotView::FinishLaneReorder()
-	{
-		const int from = m_laneDragFrom;
-		const int target = m_laneDragTarget;
-		m_laneDragFrom = -1;
-		m_laneDragTarget = -1;
-		m_laneDragGrabOffset = 0.0f;
-		m_dragMode = PlotDragMode::NONE;
-
-		if (m_tab == nullptr || from < 0 || target < 0)
-		{
-			return;
-		}
-		if (!m_tab->MoveLane(from, target))
-		{
-			return;
-		}
-		// 网格次序变化 → 几何、派生缓存与静态场景缓存全部失效。
-		BuildLaneVisuals();
-		InvalidateDerivedCaches();
-	}
-
-	void PlotView::PaintLaneReorder(gd::Graphics& g)
-	{
-		if (m_dragMode != PlotDragMode::LANE_REORDER || m_laneDragFrom < 0 || m_sceneDc == nullptr ||
-		    m_lanes.empty())
-		{
-			return;
-		}
-
-		const float laneHeight = m_lanes.front().rect.Height;
-		if (!(laneHeight > 0.0f))
-		{
-			return;
-		}
-
-		// 1) 先把整个绘图区（含时间轴）从静态场景缓存贴回：网格次序拖拽只改变网格内部的
-		//    条带位置，时间轴/边框等内容必须原样保留，否则鼠标拖到工具栏或时间轴上时
-		//    那一区域会残留上一帧的内容。
-		if (!BlitSceneCache(g))
-		{
-			return;
-		}
-
-		// 2) 把"网格区域"整片铺成绘图区底色：让位留下的空档就是它的原色，
-		//    网格线/波形随后按各自位移贴回。
-		UiFillRect(g, m_plotRect, m_theme->cardBg);
-
-		HDC target = g.GetHDC();
-		if (target == nullptr)
-		{
-			return;
-		}
-
-		// 逐网格把缓存中该网格的横向条带按位移贴到屏幕上（非常廉价，整幅波形不必重绘）。
-		// 被拖拽的网格最后贴，因此始终压在最上层，形成"被拎起来"的观感。
-		std::vector<int> laneOrder;
-		for (int index = 0; index < static_cast<int>(m_lanes.size()); ++index)
-		{
-			if (index != m_laneDragFrom)
-			{
-				laneOrder.push_back(index);
-			}
-		}
-		if (m_laneDragFrom < static_cast<int>(m_lanes.size()))
-		{
-			laneOrder.push_back(m_laneDragFrom);
-		}
-
-		for (const int index : laneOrder)
-		{
-			const gd::RectF& rect = m_lanes[static_cast<std::size_t>(index)].rect;
-			const float offset = LaneDragOffset(index);
-			// 源：缓存中该网格的条带；目标：屏幕上的同一条带平移 offset。
-			const float sourceTop = rect.Y;
-			const float destTop = rect.Y + offset;
-			// 与绘图区求交（并夹进缓存区域），避免把波形贴到工具栏或时间轴上。
-			const float clipTop = std::max(std::max(destTop, m_plotRect.Y), m_plotRect.Y);
-			const float clipBottom =
-			    std::min(std::min(destTop + rect.Height, m_plotRect.Y + m_plotRect.Height),
-			             m_plotRect.Y + m_plotRect.Height);
-			if (clipBottom - clipTop < 1.0f)
-			{
-				continue;
-			}
-
-			const int x = static_cast<int>(std::floor(rect.X));
-			const int width = static_cast<int>(std::ceil(rect.X + rect.Width)) - x;
-			const int y0 = static_cast<int>(std::ceil(clipTop));
-			const int y1 = static_cast<int>(std::floor(clipBottom));
-			if (y1 <= y0 || width <= 0)
-			{
-				continue;
-			}
-
-			const int sourceY = static_cast<int>(std::lround(sourceTop + (static_cast<float>(y0) - destTop)));
-			BitBlt(target, x, y0, width, y1 - y0, m_sceneDc, x - m_sceneX, sourceY - m_sceneY, SRCCOPY);
-		}
-		g.ReleaseHDC(target);
-
-		// 3) 目标位置的高亮提示与被拖网格的轮廓都**必须夹在网格区域内**绘制：
-		//    鼠标拖到工具栏/时间轴上时，若不裁剪，强调色边框会画到那些区域上。
-		{
-			const int clipState = g.Save();
-			g.SetClip(m_plotRect, gd::CombineModeIntersect);
-
-			// 目标位置的高亮提示（吸附提示）：在被拖网格将要落到的槽位上画一层强调色底 + 边框。
-			const int dropSlot = (m_laneDragTarget >= 0) ? m_laneDragTarget : m_laneDragFrom;
-			float slotTop = m_lanes.front().rect.Y + static_cast<float>(dropSlot) * laneHeight;
-			if (dropSlot > m_laneDragFrom)
-			{
-				slotTop -= laneHeight;
-			}
-			const gd::RectF slot(m_plotRect.X, slotTop, m_plotRect.Width, laneHeight);
-			if (slot.Height > 0.0f)
-			{
-				UiFillRect(g, slot, WithAlpha(m_theme->accent, 0x1E));
-				UiDrawRoundRect(g, gd::RectF(slot.X + 1.0f * m_scale, slot.Y + 1.0f * m_scale,
-				                             slot.Width - 2.0f * m_scale, slot.Height - 2.0f * m_scale),
-				                3.0f * m_scale, m_theme->accent, 1.6f * m_scale);
-			}
-
-			// 被拖网格的轮廓：加强"整块网格被拎起"的观感。
-			const gd::RectF& dragged = m_lanes[static_cast<std::size_t>(m_laneDragFrom)].rect;
-			const float destTop = dragged.Y + LaneDragOffset(m_laneDragFrom);
-			const gd::RectF outline(dragged.X + 1.0f * m_scale, destTop + 1.0f * m_scale,
-			                        dragged.Width - 2.0f * m_scale, dragged.Height - 2.0f * m_scale);
-			UiFillRoundRect(g, gd::RectF(outline.X + 2.0f * m_scale, outline.Y + 3.0f * m_scale,
-			                             outline.Width, outline.Height),
-			                3.0f * m_scale, 0x22000000u);
-			UiDrawRoundRect(g, outline, 3.0f * m_scale, m_theme->accent, 1.8f * m_scale);
-			g.Restore(clipState);
-		}
-	}
-
-	bool PlotView::EnsureSceneCache(int width, int height)
-	{
-		if (width <= 0 || height <= 0)
-		{
-			return false;
-		}
-		// 位图尺寸必须与当前缓存区域**严格一致**：贴图时按位图尺寸整块拷贝，
-		// 若沿用更大的旧位图，缩小窗口后会把旧像素画到绘图区之外。
-		if (m_sceneDc != nullptr && m_sceneWidth == width && m_sceneHeight == height)
-		{
-			return true;
-		}
-
-		ReleaseSceneCache();
-		// 场景位图重建 → 面板图层里缓存的"面板背后的场景"随之失效。
-		m_panelValid = false;
-
-		HDC screen = GetDC(nullptr);
-		if (screen == nullptr)
-		{
-			return false;
-		}
-		m_sceneDc = CreateCompatibleDC(screen);
-		m_sceneBitmap = CreateCompatibleBitmap(screen, width, height);
-		ReleaseDC(nullptr, screen);
-
-		if (m_sceneDc == nullptr || m_sceneBitmap == nullptr)
-		{
-			ReleaseSceneCache();
-			return false;
-		}
-		m_sceneOldBitmap = SelectObject(m_sceneDc, m_sceneBitmap);
-		m_sceneWidth = width;
-		m_sceneHeight = height;
-		return true;
-	}
-
-	bool PlotView::CaptureSceneCache(gd::Graphics& g)
-	{
-		// 缓存区域严格限定为绘图区本身（m_area）：工具栏/标签栏/面板由宿主每帧绘制，
-		// 因为它们各自带有悬停态；绘图区的波形才是真正昂贵的部分（大文件约 80ms/帧）。
-		const int x = static_cast<int>(std::floor(m_area.X));
-		const int y = static_cast<int>(std::floor(m_area.Y));
-		const int right = static_cast<int>(std::ceil(m_area.X + m_area.Width));
-		const int bottom = static_cast<int>(std::ceil(m_area.Y + m_area.Height));
-		const int width = right - x;
-		const int height = bottom - y;
-		if (width <= 0 || height <= 0)
-		{
-			m_sceneValid = false;
-			return false;
-		}
-
-		m_sceneX = x;
-		m_sceneY = y;
-
-		if (!EnsureSceneCache(width, height))
-		{
-			m_sceneValid = false;
-			return false;
-		}
-
-		HDC source = g.GetHDC();
-		if (source == nullptr)
-		{
-			m_sceneValid = false;
-			return false;
-		}
-		const BOOL ok = BitBlt(m_sceneDc, 0, 0, width, height, source, m_sceneX, m_sceneY, SRCCOPY);
-		g.ReleaseHDC(source);
-
-		if (ok == FALSE)
-		{
-			m_sceneValid = false;
-			return false;
-		}
-
-		m_sceneKey = MakeSceneCacheKey();
-		m_sceneGeometryHash = SceneGeometryHash();
-		CollectSceneStyles(m_sceneStyles);
-		CollectSceneDerived(m_sceneDerived);
-		m_sceneDegraded = false;
-		m_sceneValid = true;
-		return true;
-	}
-
-	bool PlotView::BlitSceneCache(gd::Graphics& g)
-	{
-		if (!m_sceneValid || m_sceneDc == nullptr)
-		{
-			return false;
-		}
-
-		HDC target = g.GetHDC();
-		if (target == nullptr)
-		{
-			return false;
-		}
-		const BOOL ok = BitBlt(target, m_sceneX, m_sceneY, m_sceneWidth, m_sceneHeight, m_sceneDc, 0, 0,
-		                       SRCCOPY);
-		g.ReleaseHDC(target);
-		return ok != FALSE;
-	}
-
-	void PlotView::InvalidateSceneCache()
-	{
-		m_sceneValid = false;
-		m_sceneStyles.clear();
-		m_sceneDerived.clear();
-		m_sceneDegraded = false;
-		m_sceneGeometryHash = 0;
-		// 面板像素图层与场景缓存同源（面板像素里含"面板背后的场景"）：
-		// 信号增删、重命名、参数变化等一律连带作废，避免面板里残留旧波形。
-		m_panelValid = false;
-	}
-
-	void PlotView::ReleaseSceneCache()
-	{
-		m_sceneValid = false;
-		if (m_sceneDc != nullptr)
-		{
-			if (m_sceneOldBitmap != nullptr)
-			{
-				SelectObject(m_sceneDc, m_sceneOldBitmap);
-				m_sceneOldBitmap = nullptr;
-			}
-			DeleteDC(m_sceneDc);
-			m_sceneDc = nullptr;
-		}
-		if (m_sceneBitmap != nullptr)
-		{
-			DeleteObject(m_sceneBitmap);
-			m_sceneBitmap = nullptr;
-		}
-		m_sceneWidth = 0;
-		m_sceneHeight = 0;
-	}
-
-	bool PlotView::EnsureDecorCache(int width, int height)
-	{
-		if (width <= 0 || height <= 0)
-		{
-			return false;
-		}
-		if (m_decorDc != nullptr && m_decorBits != nullptr && m_decorW == width && m_decorH == height)
-		{
-			return true;
-		}
-		ReleaseDecorCache();
-		HDC screen = GetDC(nullptr);
-		if (screen == nullptr)
-		{
-			return false;
-		}
-		// ⚠️ **必须用 32bpp DIB 段**（而不是 `CreateCompatibleBitmap`）：
-		// 装饰要带真 alpha（圆角之外全透明），才能用 `AlphaBlend` 合成到波形之上；
-		// 同时 DIB 段的像素可直接写（用于 alpha 修补与清空）。
-		BITMAPINFO info = {};
-		info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-		info.bmiHeader.biWidth = width;
-		info.bmiHeader.biHeight = -height;		// 自上而下
-		info.bmiHeader.biPlanes = 1;
-		info.bmiHeader.biBitCount = 32;
-		info.bmiHeader.biCompression = BI_RGB;
-		void* bits = nullptr;
-		HBITMAP dib = CreateDIBSection(screen, &info, DIB_RGB_COLORS, &bits, nullptr, 0);
-		ReleaseDC(nullptr, screen);
-		if (dib == nullptr || bits == nullptr)
-		{
-			if (dib != nullptr)
-			{
-				DeleteObject(dib);
-			}
-			return false;
-		}
-		HDC dc = CreateCompatibleDC(nullptr);
-		if (dc == nullptr)
-		{
-			DeleteObject(dib);
-			return false;
-		}
-		m_decorOldBitmap = SelectObject(dc, dib);
-		m_decorDc = dc;
-		m_decorBitmap = dib;
-		m_decorBits = bits;
-		m_decorW = width;
-		m_decorH = height;
-		return true;
-	}
-
-	void PlotView::ReleaseDecorCache()
-	{
-		m_decorValid = false;
-		m_decorCapturedRects.clear();
-		if (m_decorDc != nullptr)
-		{
-			if (m_decorOldBitmap != nullptr)
-			{
-				SelectObject(m_decorDc, m_decorOldBitmap);
-				m_decorOldBitmap = nullptr;
-			}
-			DeleteDC(m_decorDc);
-			m_decorDc = nullptr;
-		}
-		if (m_decorBitmap != nullptr)
-		{
-			DeleteObject(m_decorBitmap);
-			m_decorBitmap = nullptr;
-		}
-		m_decorBits = nullptr;
-		m_decorW = 0;
-		m_decorH = 0;
-	}
-
-	void* PlotView::ResolveAlphaBlend()
-	{
-		// `AlphaBlend` 由 msimg32 导出、并由 gdi32 的 `GdiAlphaBlend` 实现；
-		// 两个来源都试一遍，取到即缓存（静态局部变量，仅解析一次）。
-		static void* cached = nullptr;
-		static bool resolved = false;
-		if (resolved)
-		{
-			return cached;
-		}
-		resolved = true;
-		HMODULE gdi = GetModuleHandleW(L"gdi32.dll");
-		if (gdi != nullptr)
-		{
-			cached = reinterpret_cast<void*>(GetProcAddress(gdi, "GdiAlphaBlend"));
-		}
-		if (cached == nullptr)
-		{
-			HMODULE msimg = LoadLibraryW(L"msimg32.dll");
-			if (msimg != nullptr)
-			{
-				cached = reinterpret_cast<void*>(GetProcAddress(msimg, "AlphaBlend"));
-			}
-		}
-		return cached;
-	}
-
-	bool PlotView::RenderDecorCache()
-	{
-		m_decorValid = false;
-		if (m_theme == nullptr || m_fonts == nullptr || m_lanes.empty())
-		{
-			return false;
-		}
-		// 位图覆盖「客户区原点 → 绘图区右下角」：绘制坐标与正常绘制完全一致，
-		// 不需要任何平移（GDI 文本不认 GDI+ 变换，平移会让文字错位）。
-		const int width = static_cast<int>(std::ceil(m_area.X + m_area.Width));
-		const int height = static_cast<int>(std::ceil(m_area.Y + m_area.Height));
-		if (!EnsureDecorCache(width, height))
-		{
-			return false;
-		}
-		// 清空为全透明（圆角之外必须保持透明，贴回时才不会盖住波形）。
-		std::memset(m_decorBits, 0, static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * 4u);
-
-		m_decorRects.clear();
-		{
-			gd::Graphics g(m_decorDc);
-			g.SetSmoothingMode(gd::SmoothingModeAntiAlias);
-			g.SetPixelOffsetMode(gd::PixelOffsetModeHalf);
-			g.SetTextRenderingHint(gd::TextRenderingHintClearTypeGridFit);
-
-			const bool savedUse = m_useDecorCache;
-			m_useDecorCache = false;		// 本次是"真正绘制"：不允许走"跳过绘制"的分支
-			m_renderDecorOnly = true;		// 只画装饰（跳过网格线与波形）
-			const std::vector<double> noTicks;
-			for (std::size_t index = 0; index < m_lanes.size(); ++index)
-			{
-				PaintLane(g, static_cast<int>(index), m_lanes[index], noTicks);
-			}
-			m_renderDecorOnly = false;
-			m_useDecorCache = savedUse;
-		}
-
-		// ⚠️ **alpha 修补**：GDI 的文本绘制（`DrawTextW`）会把它写入的像素 alpha 清成 0
-		// （GDI 不维护 alpha），若原样保留，贴上后文字位置会变成"透明洞"（透出波形）。
-		// 在这里把装饰矩形内"有颜色但 alpha 为 0"的像素还原为不透明即可 —— 装饰本身
-		// 是画在不透明底板上的，这些像素本来就该不透明。
-		for (const gd::RectF& rect : m_decorRects)
-		{
-			const int x0 = std::max(0, static_cast<int>(std::floor(rect.X)));
-			const int y0 = std::max(0, static_cast<int>(std::floor(rect.Y)));
-			const int x1 = std::min(width, static_cast<int>(std::ceil(rect.X + rect.Width)));
-			const int y1 = std::min(height, static_cast<int>(std::ceil(rect.Y + rect.Height)));
-			for (int y = y0; y < y1; ++y)
-			{
-				unsigned char* row = static_cast<unsigned char*>(m_decorBits) +
-				                     (static_cast<std::size_t>(y) * static_cast<std::size_t>(width)) * 4u;
-				for (int x = x0; x < x1; ++x)
-				{
-					unsigned char* p = row + static_cast<std::size_t>(x) * 4u;
-					if (p[3] == 0 && (p[0] | p[1] | p[2]) != 0)
-					{
-						p[3] = 255;
-					}
-				}
-			}
-		}
-
-		m_decorCapturedRects = m_decorRects;
-		m_decorValid = true;
-		return true;
-	}
-
-	bool PlotView::BlitDecorCache(gd::Graphics& g)
-	{
-		if (!m_decorValid || m_decorDc == nullptr || m_decorCapturedRects.empty())
-		{
-			return false;
-		}
-		void* proc = ResolveAlphaBlend();
-		if (proc == nullptr)
-		{
-			return false;		// 极小概率：系统不提供 AlphaBlend（贴回会带透明洞，故直接放弃）
-		}
-		using AlphaBlendFn = BOOL(WINAPI*)(HDC, int, int, int, int, HDC, int, int, int, int, BLENDFUNCTION);
-		AlphaBlendFn blend = reinterpret_cast<AlphaBlendFn>(proc);
-		HDC target = g.GetHDC();
-		if (target == nullptr)
-		{
-			return false;
-		}
-		// 装饰位图原点 = 客户区 (0,0)：源坐标与目标坐标**相同**。
-		BLENDFUNCTION fn = {};
-		fn.BlendOp = AC_SRC_OVER;
-		fn.SourceConstantAlpha = 255;
-		fn.AlphaFormat = AC_SRC_ALPHA;		// 源为**预乘** alpha（GDI+ 写入 DIB 段即预乘）
-		bool any = false;
-		for (const gd::RectF& rect : m_decorCapturedRects)
-		{
-			const int x = static_cast<int>(std::floor(rect.X));
-			const int y = static_cast<int>(std::floor(rect.Y));
-			const int w = static_cast<int>(std::ceil(rect.X + rect.Width)) - x;
-			const int h = static_cast<int>(std::ceil(rect.Y + rect.Height)) - y;
-			if (w <= 0 || h <= 0)
-			{
-				continue;
-			}
-			if (blend(target, x, y, w, h, m_decorDc, x, y, w, h, fn) != FALSE)
-			{
-				any = true;
-			}
-		}
-		g.ReleaseHDC(target);
-		return any;
-	}
-
-	bool PlotView::EnsureLaneLayer(LaneLayer& layer, int width, int height)
-	{
-		if (width <= 0 || height <= 0)
-		{
-			return false;
-		}
-		if (layer.dc != nullptr && layer.width == width && layer.height == height)
-		{
-			return true;
-		}
-		ReleaseLaneLayer(layer);
-		HDC screen = GetDC(nullptr);
-		if (screen == nullptr)
-		{
-			return false;
-		}
-		layer.dc = CreateCompatibleDC(screen);
-		layer.bitmap = CreateCompatibleBitmap(screen, width, height);
-		ReleaseDC(nullptr, screen);
-		if (layer.dc == nullptr || layer.bitmap == nullptr)
-		{
-			ReleaseLaneLayer(layer);
-			return false;
-		}
-		layer.oldBitmap = SelectObject(layer.dc, layer.bitmap);
-		layer.width = width;
-		layer.height = height;
-		layer.valid = false;
-		return true;
-	}
-
-	void PlotView::ReleaseLaneLayer(LaneLayer& layer)
-	{
-		layer.valid = false;
-		if (layer.dc != nullptr)
-		{
-			if (layer.oldBitmap != nullptr)
-			{
-				SelectObject(layer.dc, layer.oldBitmap);
-				layer.oldBitmap = nullptr;
-			}
-			DeleteDC(layer.dc);
-			layer.dc = nullptr;
-		}
-		if (layer.bitmap != nullptr)
-		{
-			DeleteObject(layer.bitmap);
-			layer.bitmap = nullptr;
-		}
-		layer.width = 0;
-		layer.height = 0;
-	}
-
-	void PlotView::ReleaseWideBuffer()
-	{
-		std::lock_guard<std::mutex> lock(m_layerMutex);
-		for (LaneLayer& layer : m_layerFront)
-		{
-			ReleaseLaneLayer(layer);
-		}
-		m_layerFront.clear();
-		m_layerRebuildPending.clear();
-	}
-
-	void PlotView::InvalidateWideBuffer()
-	{
-		std::lock_guard<std::mutex> lock(m_layerMutex);
-		for (LaneLayer& layer : m_layerFront)
-		{
-			layer.valid = false;
-		}
-		m_layerRebuildPending.clear();
-	}
-
-	std::uint64_t PlotView::LaneLayerKey(int laneIndex) const
-	{
-		// 图层只含基底（不含派生曲线与装饰），因此指纹 = **该网格自己的内容**
-		// ⊕ 网格下标 ⊕ 视界跨度 ⊕ 绘图区宽度（决定像素/时间与位图尺寸）。
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		std::uint64_t key = LaneLayerHash(laneIndex);
-		key ^= static_cast<std::uint64_t>(laneIndex + 1) * 1315423911ull;
-		key *= 1099511628211ull;
-		key ^= static_cast<std::uint64_t>(std::llround(span * 1.0e6));
-		key *= 1099511628211ull;
-		key ^= static_cast<std::uint64_t>(std::llround(m_plotRect.Width));
-		return key;
-	}
-
-	std::uint64_t PlotView::LaneLayerHash(int laneIndex) const
-	{
-		// 单个网格图层的内容 = 位图高度（= 网格高度）+ 幅值**跨度** + 本网格各信号的
-		// 可见性与外观 + 图例文案（图例不在图层里，但一起计入无妨且更安全）。
-		//
-		// ⚠️ **只计跨度、不计幅值的绝对范围**：图层的纵向锚点（`anchorYMax`）与 `wideMin`
-		// 一样是"贴图偏移"的来源，幅值整体平移不改变图层内容（只是贴图时纵向偏移若干像素），
-		// 因此纵向拖动不会让图层失效。真正改变内容的是**跨度**（决定像素/数值与刻度步长）。
-		std::uint64_t hash = 1469598103934665603ull;
-		const auto mix = [&hash](std::uint64_t value)
-		{
-			hash ^= value;
-			hash *= 1099511628211ull;
-		};
-		const auto mixFloat = [&mix](float value)
-		{
-			std::uint32_t bits = 0;
-			std::memcpy(&bits, &value, sizeof(bits));
-			mix(bits);
-		};
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return hash;
-		}
-		const LaneVisual& visual = m_lanes[static_cast<std::size_t>(laneIndex)];
-		mixFloat(visual.rect.Height);
-		mixFloat(static_cast<float>(visual.yMax - visual.yMin));
-		const std::vector<SignalRef>& signals = Tab().Lanes()[static_cast<std::size_t>(laneIndex)].signals;
-		mix(signals.size());
-		for (const SignalRef& ref : signals)
-		{
-			const ResolvedSignal resolved = ResolveSignal(ref);
-			mix(static_cast<std::uint64_t>(ref.groupIndex));
-			mix(static_cast<std::uint64_t>(ref.signalIndex));
-			mix(resolved.visible ? 1ull : 0ull);
-			if (resolved.data == nullptr || resolved.style == nullptr)
-			{
-				continue;
-			}
-			mix(static_cast<std::uint64_t>(resolved.style->color));
-			mixFloat(resolved.style->opacity);
-			mixFloat(resolved.style->lineWidth);
-			mix(static_cast<std::uint64_t>(resolved.style->mode));
-			// 「调整」变换会改变图层里的波形，也必须让图层失效
-			//（否则贴回的旧像素会与当前样式不一致）。
-			mixFloat(resolved.style->gain);
-			mix(resolved.style->absolute ? 1ull : 0ull);
-			mix(resolved.style->mirrorVertical ? 1ull : 0ull);
-			mix(resolved.style->mirrorHorizontal ? 1ull : 0ull);
-			mixFloat(resolved.style->offsetY);
-			mixFloat(static_cast<float>(resolved.style->offsetTime));
-		}
-		return hash;
-	}
-
-	int PlotView::LayerMarginX() const
-	{
-		const int width = static_cast<int>(std::lround(m_plotRect.Width));
-		return std::max(1, width / 2);		// 左右各半屏
-	}
-
-	int PlotView::LayerMarginY(float laneHeight) const
-	{
-		// 上下各半个网格高：一整屏的额外内容已足够覆盖实际拖拽范围，
-		// 又不至于让每个横向补条 / 整块重画按三倍高度放大（横向平移因此不受影响）。
-		const int half = static_cast<int>(std::lround(static_cast<double>(laneHeight) * 0.5));
-		return std::max(1, half);
-	}
-
-	double PlotView::LayerDefaultWideMin() const
-	{
-		// 以当前视界为中心：位图左右各留半个视界宽，因此可向两侧平移 ±半屏。
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		const int width = static_cast<int>(std::lround(m_plotRect.Width));
-		if (!(span > 0.0) || width <= 0)
-		{
-			return Tab().ViewMin();
-		}
-		const double scale = static_cast<double>(width) / span;
-		return Tab().ViewMin() - static_cast<double>(LayerMarginX()) / scale;
-	}
-
-	bool PlotView::LayersStructurallyReady() const
-	{
-		std::lock_guard<std::mutex> lock(m_layerMutex);
-		if (m_layerFront.size() != m_lanes.size() || m_layerFront.empty())
-		{
-			return false;
-		}
-		const float plotWidth = m_plotRect.Width;
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(plotWidth > 8.0f) || !(span > 0.0))
-		{
-			return false;
-		}
-		const int width = static_cast<int>(std::lround(plotWidth));
-		const int bitmapWidth = width + 2 * LayerMarginX();
-		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
-		{
-			const LaneLayer& layer = m_layerFront[index];
-			if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth)
-			{
-				return false;
-			}
-			// 跨度必须一致：跨度变了像素/时间的映射就不同，旧像素不能再当“坐标偏移”用。
-			if (std::fabs(span - layer.span) > 1.0e-12)
-			{
-				return false;
-			}
-			// 高度也要一致：网格高度变化会让贴图纵向错位（含上下预渲染余量）。
-			const float laneHeight = m_lanes[index].rect.Height;
-			const int bitmapHeight =
-			    static_cast<int>(std::ceil(laneHeight)) + 2 * LayerMarginY(laneHeight);
-			if (layer.height != bitmapHeight)
-			{
-				return false;
-			}
-		}
-		return true;
-	}
-
-	bool PlotView::LayersAllocated() const
-	{
-		std::lock_guard<std::mutex> lock(m_layerMutex);
-		return !m_layerFront.empty() && m_layerFront.size() == m_lanes.size();
-	}
-
-	bool PlotView::LaneLayerReady(int laneIndex) const
-	{
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return false;
-		}
-		std::lock_guard<std::mutex> lock(m_layerMutex);
-		if (laneIndex >= static_cast<int>(m_layerFront.size()))
-		{
-			return false;
-		}
-		const LaneLayer& layer = m_layerFront[static_cast<std::size_t>(laneIndex)];
-		const float plotWidth = m_plotRect.Width;
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(plotWidth > 8.0f) || !(span > 0.0))
-		{
-			return false;
-		}
-		const int width = static_cast<int>(std::lround(plotWidth));
-		const int bitmapWidth = width + 2 * LayerMarginX();
-		const float laneHeight = m_lanes[static_cast<std::size_t>(laneIndex)].rect.Height;
-		const int bitmapHeight = static_cast<int>(std::ceil(laneHeight)) + 2 * LayerMarginY(laneHeight);
-		if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth ||
-		    layer.height != bitmapHeight || std::fabs(layer.span - span) > 1.0e-12)
-		{
-			return false;
-		}
-		return layer.key == LaneLayerKey(laneIndex);
-	}
-
-	bool PlotView::LanesAllReadyForView() const
-	{
-		if (m_lanes.empty())
-		{
-			return false;
-		}
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			if (!LaneLayerReady(static_cast<int>(index)))
-			{
-				return false;
-			}
-		}
-		return true;
-	}
-
-	void PlotView::QueueLaneRebuild(int laneIndex)
-	{
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return;
-		}
-		for (const int existing : m_layerRebuildPending)
-		{
-			if (existing == laneIndex)
-			{
-				return;		// 已经在队列里
-			}
-		}
-		m_layerRebuildPending.push_back(laneIndex);
-	}
-
-	bool PlotView::RenderPendingLaneRebuilds(int budget)
-	{
-		if (m_layerRebuildPending.empty() || budget <= 0)
-		{
-			return !m_layerRebuildPending.empty();
-		}
-		const double defaultWideMin = LayerDefaultWideMin();
-		// 本批要重画的网格：`budget` 足够大时一次取完（视界已停时调用方会传很大的预算）。
-		const int available = static_cast<int>(m_layerRebuildPending.size());
-		const int take = std::min(budget, available);
-		std::vector<int> batch;
-		batch.reserve(static_cast<std::size_t>(take));
-		for (int index = 0; index < take; ++index)
-		{
-			const int laneIndex = m_layerRebuildPending[static_cast<std::size_t>(index)];
-			if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()))
-			{
-				batch.push_back(laneIndex);
-			}
-		}
-		m_layerRebuildPending.erase(m_layerRebuildPending.begin(),
-		                            m_layerRebuildPending.begin() + take);
-
-		if (batch.size() > 1)
-		{
-			// **多网格一次补齐**：并行渲染（各网格用隔离上下文），比"一帧只补 1 个"收敛快 N 倍。
-			RebuildLaneLayersParallel(batch, defaultWideMin);
-		}
-		else
-		{
-			for (const int laneIndex : batch)
-			{
-				// 加锁顺序与前台一致：先 `m_renderMutex` 再 `m_layerMutex`。
-				std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-				std::lock_guard<std::mutex> layerLock(m_layerMutex);
-				if (m_layerFront.size() != m_lanes.size())
-				{
-					break;
-				}
-				LaneLayer& layer = m_layerFront[static_cast<std::size_t>(laneIndex)];
-				// ⚠️ **跨度过期（缩放瞬间）也在这里就地整块重画**（按**新跨度**）。
-				// 旧实现遇到跨度不符就 `continue`（把该网格推给"下一次整批重建"），
-				// 而"整批重建"正是那个 70~80ms 的同步卡顿源；现在改为一帧补一个网格，
-				// 其余网格由 `BlitWideBuffer` 的占位拉伸顶着 → 前台永不因图层未就绪而滞后。
-				// 整块重画：整个图层都对齐到"当前 `yMax`"（锚点 = 当前 yMax）。
-				if (!RenderLaneLayerRegion(laneIndex, layer, 0, 0, 0, 0, defaultWideMin,
-				                           m_lanes[static_cast<std::size_t>(laneIndex)].yMax))
-				{
-					continue;
-				}
-			}
-		}
-		return !m_layerRebuildPending.empty();
-	}
-
-	void PlotView::EnsureLayerWorkers()
-	{
-		unsigned int hardware = std::thread::hardware_concurrency();
-		const int want = std::max(1, std::min(static_cast<int>(hardware == 0 ? 2u : hardware), 4));
-		if (m_layerWorkerCount == want && static_cast<int>(m_layerWorkers.size()) == want)
-		{
-			// 字体 / 主题 / 缩放 / 数据源可能已变化：刷新一次绑定（不重建线程上下文）。
-			for (int index = 0; index < want; ++index)
-			{
-				m_layerWorkers[static_cast<std::size_t>(index)]->Setup(m_fonts, m_theme);
-				m_layerWorkers[static_cast<std::size_t>(index)]->SetScale(m_scale);
-				m_layerWorkers[static_cast<std::size_t>(index)]->m_dataSet = m_dataSet;
-				m_layerWorkers[static_cast<std::size_t>(index)]->m_dataSetWritable = m_dataSetWritable;
-			}
-			return;
-		}
-		ReleaseLayerWorkers();
-		m_layerWorkers.reserve(static_cast<std::size_t>(want));
-		for (int index = 0; index < want; ++index)
-		{
-			auto worker = std::make_unique<PlotView>();
-			worker->Setup(m_fonts, m_theme);
-			worker->SetScale(m_scale);
-			// ⚠️ `m_tab` 置空 → worker 的 `Tab()` 返回它**自带的** `m_localTab` 副本，
-			// 于是它改写视界 / 网格矩形时不会碰到共享的标签页配置（安全并行的前提）。
-			worker->m_dataSet = m_dataSet;
-			worker->m_dataSetWritable = m_dataSetWritable;
-			// ⚠️ `m_tab` **必须非空**（`BuildLaneVisuals()` 在空时会清空 `m_lanes`）；
-			// 指向 worker **自有**的 `m_workerTab`，这样它改写视界 / 网格矩形时不会碰到共享标签页。
-			worker->m_tab = &worker->m_workerTab;
-			worker->RefreshLanes();
-			m_layerWorkers.push_back(std::move(worker));
-		}
-		m_layerWorkerCount = want;
-	}
-
-	void PlotView::ReleaseLayerWorkers()
-	{
-		m_layerWorkers.clear();
-		m_layerWorkerCount = 0;
-	}
-
-	void PlotView::RebuildLaneLayersParallel(const std::vector<int>& laneIndices, double wideMin)
-	{
-		if (laneIndices.empty() || m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-		// 单网格 / 单核：直接顺序走既有路径（避免线程开销）。
-		unsigned int hardware = std::thread::hardware_concurrency();
-		if (laneIndices.size() <= 1 || (hardware == 0 ? 2u : hardware) <= 1)
-		{
-			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-			std::lock_guard<std::mutex> layerLock(m_layerMutex);
-			if (m_layerFront.size() != m_lanes.size())
-			{
-				return;
-			}
-			for (const int laneIndex : laneIndices)
-			{
-				if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-				{
-					continue;
-				}
-				RenderLaneLayerRegion(laneIndex, m_layerFront[static_cast<std::size_t>(laneIndex)], 0, 0, 0,
-				                      0, wideMin, m_lanes[static_cast<std::size_t>(laneIndex)].yMax);
-			}
-			return;
-		}
-
-		{
-			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-			std::lock_guard<std::mutex> layerLock(m_layerMutex);
-			if (m_layerFront.size() != m_lanes.size())
-			{
-				return;
-			}
-		}
-		EnsureLayerWorkers();
-		if (m_layerWorkerCount <= 1)
-		{
-			return;	// 保守回退：让调用方走顺序路径
-		}
-
-		// 主线程**先快照**工作线程需要的一切（之后它们只读，不再触碰共享状态）。
-		const TabConfig tabSnapshot = *m_tab;
-		const gd::RectF plotRectSnapshot = m_plotRect;
-		const gd::RectF areaSnapshot = m_area;
-		const float scaleSnapshot = m_scale;
-		const std::vector<LaneVisual> laneSnapshot = m_lanes;
-		// 目标图层位图数组（已确认尺寸与网格数一致，线程内不会扩容）。
-		std::vector<LaneLayer>* const front = &m_layerFront;
-
-		const int workerCount = m_layerWorkerCount;
-		std::atomic<std::size_t> next{0};
-		std::vector<std::thread> threads;
-		threads.reserve(static_cast<std::size_t>(workerCount));
-		for (int workerIndex = 0; workerIndex < workerCount; ++workerIndex)
-		{
-			threads.emplace_back([&, workerIndex]()
-			{
-				PlotView* worker = m_layerWorkers[static_cast<std::size_t>(workerIndex)].get();
-				for (;;)
-				{
-					const std::size_t slot = next.fetch_add(1, std::memory_order_relaxed);
-					if (slot >= laneIndices.size())
-					{
-						break;
-					}
-					const int laneIndex = laneIndices[slot];
-					if (laneIndex < 0 || laneIndex >= static_cast<int>(laneSnapshot.size()) ||
-					    laneIndex >= static_cast<int>(tabSnapshot.Lanes().size()))
-					{
-						continue;
-					}
-					// 隔离上下文：自带标签页副本 + 只含该网格 + 只读的数据源 / 字体 / 主题。
-					worker->m_workerTab = tabSnapshot;
-					worker->m_workerTab.Lanes() = {tabSnapshot.Lanes()[static_cast<std::size_t>(laneIndex)]};
-					worker->m_tab = &worker->m_workerTab;
-					worker->m_fonts = m_fonts;
-					worker->m_theme = m_theme;
-					worker->m_scale = scaleSnapshot;
-					worker->m_dataSet = m_dataSet;
-					worker->m_dataSetWritable = m_dataSetWritable;
-					worker->m_area = areaSnapshot;
-					worker->m_plotRect = plotRectSnapshot;
-					worker->m_lanes = {laneSnapshot[static_cast<std::size_t>(laneIndex)]};
-					// ⚠️ 工作线程用**自己的** `m_workerTab` / `m_area` / `m_plotRect` / `m_lanes` 渲染，
-					// 因此不会与 UI 线程或其它工作线程互相覆盖渲染状态（这正是 2026-10-12 移除
-					// "后台图层线程"的根因）。目标图层位图按 `laneIndex` 各自不同，可并发写入。
-					worker->RenderLaneLayerRegion(0, (*front)[static_cast<std::size_t>(laneIndex)], 0, 0, 0, 0,
-					                              wideMin,
-					                              laneSnapshot[static_cast<std::size_t>(laneIndex)].yMax);
-				}
-			});
-		}
-		for (std::thread& thread : threads)
-		{
-			if (thread.joinable())
-			{
-				thread.join();
-			}
-		}
-
-		// 合并（主线程）：工作线程内部以 `laneIndex = 0` 渲染，因此图层内容指纹要按**真实网格下标**重算。
-		std::lock_guard<std::mutex> layerLock(m_layerMutex);
-		if (m_layerFront.size() != m_lanes.size())
-		{
-			return;
-		}
-		std::uint64_t rendered = 0;
-		for (const int laneIndex : laneIndices)
-		{
-			if (laneIndex < 0 || laneIndex >= static_cast<int>(m_layerFront.size()))
-			{
-				continue;
-			}
-			LaneLayer& target = m_layerFront[static_cast<std::size_t>(laneIndex)];
-			if (!target.valid)
-			{
-				continue;
-			}
-			target.key = LaneLayerKey(laneIndex);
-			++rendered;
-		}
-		m_layerRenderCount.fetch_add(rendered, std::memory_order_relaxed);
-	}
-
-	bool PlotView::RenderLaneLayerRegion(int laneIndex, LaneLayer& layer, int stripX, int stripW,
-	                                     int stripY, int stripH, double wideMin, double anchorYMax)
-	{
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return false;
-		}
-		std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-
-		const float plotWidth = m_plotRect.Width;
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(plotWidth > 8.0f) || !(span > 0.0))
-		{
-			layer.valid = false;
-			return false;
-		}
-
-		const int width = static_cast<int>(std::lround(plotWidth));
-		const int margin = LayerMarginX();		// 左右各半屏 → 可平移 ±半屏
-		const int bitmapWidth = width + 2 * margin;
-		const float laneHeight = m_lanes[static_cast<std::size_t>(laneIndex)].rect.Height;
-		const int lanePixelHeight = static_cast<int>(std::ceil(laneHeight));
-		const int marginY = LayerMarginY(laneHeight);	// 上下各半个网格高 → 幅值可平移 ±半个网格高
-		const int bitmapHeight = lanePixelHeight + 2 * marginY;
-		if (bitmapHeight <= 0 || !EnsureLaneLayer(layer, bitmapWidth, bitmapHeight))
-		{
-			return false;
-		}
-
-		const double scale = static_cast<double>(width) / span;		// 像素 / 时间
-		const double laneSpan = m_lanes[static_cast<std::size_t>(laneIndex)].yMax -
-		                        m_lanes[static_cast<std::size_t>(laneIndex)].yMin;
-		const double pxPerValue = (laneSpan > 0.0) ? static_cast<double>(laneHeight) / laneSpan : 0.0;
-
-		if (stripW <= 0 || stripX < 0 || stripX + stripW > bitmapWidth)
-		{
-			stripX = 0;
-			stripW = bitmapWidth;
-		}
-		// 纵向同理：`stripH <= 0` 表示纵向整块（横向滚动的细条就是这种情形）。
-		if (stripH <= 0 || stripY < 0 || stripY + stripH > bitmapHeight)
-		{
-			stripY = 0;
-			stripH = bitmapHeight;
-		}
-
-		// 保存当前布局 / 视图 / 网格，临时切换到"宽窗口"映射后离屏渲染，再恢复。
-		const gd::RectF savedArea = m_area;
-		const gd::RectF savedPlot = m_plotRect;
-		const double savedViewMin = Tab().ViewMin();
-		const double savedViewMax = Tab().ViewMax();
-		const std::vector<LaneVisual> savedLanes = m_lanes;
-		const bool savedFastFrame = m_fastFrame;
-		const bool savedRenderWide = m_renderWide;
-		const float savedScroll = Tab().LaneScroll();
-		const double savedWideTickSpan = m_wideTickSpan;
-		const float savedWideTickHeight = m_wideTickHeight;
-		const double savedRenderTimeStep = m_renderTimeStep;
-
-		m_plotRect = gd::RectF(0.0f, 0.0f, static_cast<float>(bitmapWidth),
-		                       static_cast<float>(bitmapHeight));
-		// 只把 `m_area` 限为待渲染的那一段 x 区间，使 GDI/GDI+ 的裁剪只落在它上面；
-		// x 坐标仍用**整条宽窗口**的映射（`m_plotRect` 为完整宽图），因此网格线位置与整块图层一致。
-		m_area = gd::RectF(static_cast<float>(stripX), static_cast<float>(stripY),
-		                   static_cast<float>(stripW), static_cast<float>(stripH));
-		// 横向补条（窄竖带）：把折线的构建与描边裁剪到条带的 x 范围（见 `m_stripRenderActive`）。
-		// 纵向补条（整宽 × 窄 y）不裁剪 x —— 那一方向本来就需要整条折线的顶点。
-		const bool stripIsHorizontalBand = (static_cast<float>(stripW) < static_cast<float>(bitmapWidth) - 0.5f);
-		const bool savedStripActive = m_stripRenderActive;
-		const float savedStripX0 = m_stripX0;
-		const float savedStripX1 = m_stripX1;
-		m_stripRenderActive = stripIsHorizontalBand;
-		m_stripX0 = static_cast<float>(stripX);
-		m_stripX1 = static_cast<float>(stripX + stripW);
-		Tab().ViewMin() = wideMin;
-		Tab().ViewMax() = wideMin + static_cast<double>(bitmapWidth) / scale;
-
-		m_renderWide = true;		// 图层只含基底：跳过派生曲线与装饰
-		// 图层必须与"同一视界的整幅渲染"**逐像素同源**：强制全质量抗锯齿（不受拖拽快速帧影响）。
-		m_fastFrame = false;
-		// 幅值刻度的参考跨度 / 参考高度取**前台可见网格**的值（而不是含上下余量的画布值）：
-		// 这样图层里的横向网格线步长与前台一致，纵向平移才是纯粹的像素平移。
-		m_wideTickSpan = laneSpan;
-		m_wideTickHeight = laneHeight;
-		BuildLaneVisuals();
-		// 沿用**当前视界**的 Y 轴范围，否则幅值映射与前台不一致。
-		for (std::size_t i = 0; i < m_lanes.size() && i < savedLanes.size(); ++i)
-		{
-			m_lanes[i].yMin = savedLanes[i].yMin;
-			m_lanes[i].yMax = savedLanes[i].yMax;
-		}
-		// ⚠️ **该网格的幅值映射必须以本次渲染的纵向锚点为准**（而不是"当前 `yMax`"）：
-		//  - 整块重画 / 纵向补条：锚点就是当前 `yMax`（纵向补条是滚动后的值），二者一致；
-		//  - **横向补细条**：只重画一条竖带，其余像素仍在**原锚点**上；若这里用当前 `yMax`
-		//    渲染，竖带与其余像素的纵向映射就不同源，贴图后出现撕裂/错位。
-		// 详见 `RenderLaneLayerRegion` 的 `anchorYMax` 形参说明。
-		m_lanes[static_cast<std::size_t>(laneIndex)].yMax = anchorYMax;
-		m_lanes[static_cast<std::size_t>(laneIndex)].yMin = anchorYMax - laneSpan;
-		// 该网格在本图层中的位置：横向铺满整条宽图，纵向铺满整张画布。
-		// 画布 = 「可见网格 + 上下各 `marginY` 行余量」。**上下扩展量按"像素行"精确换算**
-		//（而不是上下各扩展固定的数值量）：位图高度是整数（`ceil(laneHeight) + 2*marginY`），
-		// 只有当「扩展后总跨度 / 画布行数」严格等于前台的 px/数值 时，可见网格在画布里的映射
-		// 才与前台整幅渲染**逐像素同源**（否则会差一个 <1px 的纵向缩放误差，
-		// 让拖拽期间的像素残差明显变大）。
-		if (pxPerValue > 0.0)
-		{
-			const double topExtend = static_cast<double>(marginY) / pxPerValue;
-			const double bottomRows =
-			    static_cast<double>(bitmapHeight - marginY) - static_cast<double>(laneHeight);
-			const double bottomExtend = std::max(0.0, bottomRows) / pxPerValue;
-			m_lanes[static_cast<std::size_t>(laneIndex)].yMin -= bottomExtend;
-			m_lanes[static_cast<std::size_t>(laneIndex)].yMax += topExtend;
-		}
-		m_lanes[static_cast<std::size_t>(laneIndex)].rect =
-		    gd::RectF(0.0f, 0.0f, static_cast<float>(bitmapWidth), static_cast<float>(bitmapHeight));
-		{
-			gd::Graphics g(layer.dc);
-			g.SetSmoothingMode(gd::SmoothingModeAntiAlias);
-			g.SetPixelOffsetMode(gd::PixelOffsetModeHalf);
-			g.SetTextRenderingHint(gd::TextRenderingHintClearTypeGridFit);
-
-			UiFillRect(g, m_area, m_theme->plotBg);
-			UiFillRect(g, m_area, m_theme->cardBg);
-
-			// 竖向网格刻度沿用**前台视界跨度**（而非宽窗口的跨度），否则竖网格线会只有一半。
-			// ⚠️ 同时把它作为竖向网格的**主刻步长**传给 `PaintLane`（见 `m_renderTimeStep`）：
-			// 不传就会让图层用宽窗口跨度重算步长 → 竖向网格线与前台错位、部分整条丢失。
-			const double fgSpan = savedViewMax - savedViewMin;
-			const double timeStep = NiceStep((fgSpan > 0.0) ? fgSpan : 1.0, kTimeTickTarget);
-			m_renderTimeStep = timeStep;
-			std::vector<double> timeTicks;
-			BuildTicks(Tab().ViewMin(), Tab().ViewMax(), timeStep, timeTicks);
-			PaintLane(g, laneIndex, m_lanes[static_cast<std::size_t>(laneIndex)], timeTicks);
-			m_renderTimeStep = 0.0;
-		}
-		m_fastFrame = savedFastFrame;
-		m_renderWide = savedRenderWide;
-		m_wideTickSpan = savedWideTickSpan;
-		m_wideTickHeight = savedWideTickHeight;
-		m_renderTimeStep = savedRenderTimeStep;
-		m_stripRenderActive = savedStripActive;
-		m_stripX0 = savedStripX0;
-		m_stripX1 = savedStripX1;
-
-		// 恢复布局 / 视图 / 网格。
-		// ⚠️ **必须调用 `BuildLaneVisuals()`**（而不是只把 `m_lanes` 拷回去）：它会按正常布局
-		// 重算 `m_laneContentHeight`。该值参与内容指纹（`LaneLayerKey`），若残留上面"宽窗口"
-		// 布局算出的值，算出的图层指纹就与实际渲染不符 → 每帧都判定图层"过期"重画，白白耗性能。
-		m_area = savedArea;
-		m_plotRect = savedPlot;
-		Tab().ViewMin() = savedViewMin;
-		Tab().ViewMax() = savedViewMax;
-		BuildLaneVisuals();
-		// `BuildLaneVisuals()` 内部会 `ClampLaneScroll()`，用宽窗口布局可能夹出不同的滚动量，
-		// 因此把滚动量与各网格幅值范围一并还原回进入本函数前的状态。
-		Tab().LaneScroll() = savedScroll;
-		for (std::size_t i = 0; i < m_lanes.size() && i < savedLanes.size(); ++i)
-		{
-			m_lanes[i].yMin = savedLanes[i].yMin;
-			m_lanes[i].yMax = savedLanes[i].yMax;
-		}
-		// 恢复该网格的矩形（`BuildLaneVisuals` 已按正常布局给出，这里只为稳妥保持一致）。
-		if (laneIndex < static_cast<int>(m_lanes.size()) && laneIndex < static_cast<int>(savedLanes.size()))
-		{
-			m_lanes[static_cast<std::size_t>(laneIndex)] = savedLanes[static_cast<std::size_t>(laneIndex)];
-		}
-
-		layer.wideMin = wideMin;
-		layer.span = span;
-		layer.marginY = marginY;
-		// 纵向锚点 = 本次渲染的像素所对应的 `yMax`（由调用方按"改动了哪部分像素"决定；
-		// 横向补细条必须沿用图层原锚点，否则残余的纵向偏移会被静默清零 —— 见函数说明）。
-		layer.anchorYMax = anchorYMax;
-		layer.pxPerValue = pxPerValue;
-		layer.key = LaneLayerKey(laneIndex);
-		layer.valid = true;
-		m_layerRenderCount.fetch_add(1, std::memory_order_relaxed);
-		return true;
-	}
-
-	bool PlotView::RebuildWideBuffer()
-	{
-		const float plotWidth = m_plotRect.Width;
-		const float areaHeight = m_area.Height;
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(plotWidth > 8.0f) || !(areaHeight > 8.0f) || !(span > 0.0) || m_lanes.empty())
-		{
-			InvalidateWideBuffer();
-			return false;
-		}
-
-		// 只在**扩容 + 清空待重画队列**这一段持有 `m_layerMutex`；
-		// 随后释放，`RebuildLaneLayersParallel` 会各自重新获取（它内部还会取 `m_renderMutex`）。
-		// ⚠️ 如果这里一直持有 `m_layerMutex`，而并行重建内部再取一次 → `std::mutex` 不可重入 → 死锁。
-		{
-			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-			std::lock_guard<std::mutex> layerLock(m_layerMutex);
-			m_layerFront.resize(m_lanes.size());
-			m_layerRebuildPending.clear();
-		}
-
-		// 全部网格统一用"当前视界居中"的映射（与 `BlitWideBuffer` 的逐网格 `wideMin` 相容）。
-		const double wideMin = LayerDefaultWideMin();
-		std::vector<int> allLanes;
-		allLanes.reserve(m_lanes.size());
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			allLanes.push_back(static_cast<int>(index));
-		}
-		// **并行**重建全部网格（各网格用隔离上下文，多核时约等于一块网格的耗时）。
-		RebuildLaneLayersParallel(allLanes, wideMin);
-		std::lock_guard<std::mutex> layerLock(m_layerMutex);
-		bool ok = true;
-		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
-		{
-			if (!m_layerFront[index].valid)
-			{
-				ok = false;
-			}
-		}
-		return ok;
-	}
-
-	void PlotView::WarmLaneLayersStep()
-	{
-		if (m_dragMode != PlotDragMode::NONE || m_lanes.empty() || m_fonts == nullptr)
-		{
-			return;
-		}
-		if (!(m_plotRect.Width > 8.0f) || !(Tab().ViewMax() - Tab().ViewMin() > 0.0))
-		{
-			return;
-		}
-		{
-			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-			std::lock_guard<std::mutex> layerLock(m_layerMutex);
-			if (m_layerFront.size() > m_lanes.size())
-			{
-				// 网格变少：先把多出来的图层位图释放掉（`resize` 不会调用 `ReleaseLaneLayer`）。
-				for (std::size_t index = m_lanes.size(); index < m_layerFront.size(); ++index)
-				{
-					ReleaseLaneLayer(m_layerFront[index]);
-				}
-			}
-			if (m_layerFront.size() != m_lanes.size())
-			{
-				m_layerFront.resize(m_lanes.size());
-			}
-		}
-		// 登记"跨度 / 内容不一致"的网格。空闲时视界未变 ⇒ `RollWideBuffer` 只登记、不做滚动，
-		// 也不会走"位移超出画布 → 立刻整块重画"那条分支。
-		RollWideBuffer();
-		const bool morePending = RenderPendingLaneRebuilds(1);
-		if (morePending)
-		{
-			const HWND host = m_host;
-			if (host != nullptr)
-			{
-				PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
-			}
-		}
-	}
-
-	void PlotView::RollWideBuffer()
-	{
-		const float plotWidth = m_plotRect.Width;
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(plotWidth > 8.0f) || !(span > 0.0))
-		{
-			return;
-		}
-		const int width = static_cast<int>(std::lround(plotWidth));
-		const int margin = LayerMarginX();
-		const int bitmapWidth = width + 2 * margin;
-		const double scale = static_cast<double>(width) / span;
-
-		std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
-		std::lock_guard<std::mutex> layerLock(m_layerMutex);
-		if (m_layerFront.size() != m_lanes.size() || m_layerFront.empty())
-		{
-			return;
-		}
-
-		// ⚠️ **逐网格独立滚动**：每个图层有自己的时间映射（`layer.wideMin`），
-		// 因此位移必须按各自的锚点分别计算。曾用**一个全局锚点**给所有图层算同一个位移，
-		// 结果各网格被平移了不同的真实距离 → 网格之间时间错位、贴回的像素互相矛盾，
-		// 表现为严重的绘制错误与波形抖动。
-		//
-		// ⚠️ **本函数绝不重画整块图层**：内容过期 / 锚点太远的网格只登记到待重画队列
-		//（由 `RenderPendingLaneRebuilds` 按预算在后续帧补画），本帧仍尽量用现有像素跟随视界。
-		// 这样前台**永远不会因为"图层没准备好"而做整批重绘**（那正是"拖拽时前台卡顿"的根因）。
-		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
-		{
-			LaneLayer& layer = m_layerFront[index];
-			const int laneIndex = static_cast<int>(index);
-
-			// 结构不可用（尺寸 / 跨度不符）：像素的时间映射已经不对，既不能贴也不能滚。
-			const float laneHeight = m_lanes[index].rect.Height;
-			const int bitmapHeight =
-			    static_cast<int>(std::ceil(laneHeight)) + 2 * LayerMarginY(laneHeight);
-			if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth ||
-			    layer.height != bitmapHeight || std::fabs(layer.span - span) > 1.0e-12)
-			{
-				QueueLaneRebuild(laneIndex);
-				continue;
-			}
-
-			// 视界左端当前落在该图层的哪个 x 上；期望它等于 `margin`（左右余量对称）。
-			const double desired = (Tab().ViewMin() - layer.wideMin) * scale;
-			const int shift = static_cast<int>(std::llround(desired - static_cast<double>(margin)));
-			// 内容（外观 / 网格几何 / 幅值**跨度** / 可见性…）与当前状态不一致。
-			const bool contentStale = (layer.key != LaneLayerKey(laneIndex));
-			// 纵向：幅值**平移**不改内容，只改贴图偏移（与横向同构）。
-			int vOffset = 0;
-			if (layer.pxPerValue > 0.0)
-			{
-				vOffset = static_cast<int>(
-				    std::llround((layer.anchorYMax - m_lanes[index].yMax) * layer.pxPerValue));
-			}
-
-			// ⚠️⚠️ **"距离太远"绝不允许退化成"排队等后续帧重画"**：
-			// 长距离拖拽（用户按着中键把视界移动好几个网格高、或横向拖很远）时，
-			// 每一帧的位移都会超过余量；若此时只登记待重画，就会出现
-			//   * 本帧 `BlitWideBuffer` 取不到源行 → 网格里出现**空白条带**；
-			//   * 每帧都重新入队 → 一帧只补 1 个网格 → **持续抽搐**且总是补不完。
-			// 正确做法是：
-			//   * 位移不超过画布 → **滚动**（O(1) BitBlt + 只补画暴露的细条）；
-			//   * 位移超过画布（内容整体滚出）→ 本帧**立刻整块重画并重新居中**（一次性），
-			//     等价于一次普通的整块渲染（实测 0.4ms），不会累积漂移也不会留空白。
-			// 只有**内容真的变了**（`contentStale`）才交给待重画队列（它可以等后续帧，
-			// 因为画面本身仍然是"旧内容"，不缺口）。
-			const bool fullRedraw = (std::abs(shift) >= bitmapWidth) ||
-			                        (std::abs(vOffset) >= layer.height);
-			if (fullRedraw)
-			{
-				// 两个方向都滚出画布：直接重新居中 + 整块重画（一次搞定，避免"滚动 + 巨幅补条"）。
-				if (contentStale || std::abs(shift) >= bitmapWidth)
-				{
-					QueueLaneRebuild(laneIndex);
-				}
-				// 整块重画：重新居中 + 纵向锚点取**当前** `yMax`。
-				RenderLaneLayerRegion(laneIndex, layer, 0, bitmapWidth, 0, 0, LayerDefaultWideMin(),
-				                      m_lanes[static_cast<std::size_t>(laneIndex)].yMax);
-				continue;
-			}
-			if (contentStale)
-			{
-				QueueLaneRebuild(laneIndex);
-			}
-
-			// ------------------------------------------------------------------
-			// 纵向（幅值）滚动：与横向**完全同构**——内容整体上下移动若干行，
-			// 再只补画新暴露的那一条（整宽 × 行数）。
-			//
-			// ⚠️ **必须先做纵向再做横向**：横向补条由 `RenderLaneLayerRegion` 渲染，
-			// 而该函数按传入的**纵向锚点**渲染细条；若先补横向，那时锚点还没跟上，
-			// 补出来的细条会带着一个错的纵向偏移（贴图后表现为波形错位/撕裂）。
-			// ⚠️ 没有这一步时：幅值一变就超出余量 → 每帧都排队**整块重画**（画布比可见网格高
-			// 3 倍，代价很大）→ 拖动时"抽搐"；而且在重画完成前，`BlitWideBuffer` 只能贴出部分
-			// 行（其余留空）→ 网格内出现**空白条带**（用户报告的"绘制异常"）。
-			//
-			// ⚠️ **滚动量必须量化**（`kLayerRollQuantum`）：不足一个量子的偏移**不滚**，
-			// 交给贴图时的纵向偏移（`srcY`）处理。这样图层的画布映射在拖动过程中**保持稳定**，
-			// 折线缓存（键含幅值映射）得以命中；否则每帧滚 1~30 行会让折线每帧重算
-			// （实测同样的拖动：量化前 3~4ms 的滚动 + 10~14ms 整帧，量化后回到 ~5ms 量级）。
-			// 余量足够大（上下各 `marginY`），因此"不滚只偏移"绝不会超出画布。
-			// 上面已保证 |vOffset| < 画布高，所以这里的 BitBlt 高度恒为正。
-			// ------------------------------------------------------------------
-			if (std::abs(vOffset) >= kLayerRollQuantum)
-			{
-				const int roll = vOffset;		// 正 = 内容整体上移 roll 行（窗口向下移动）
-				int stripY = 0;
-				int stripH = 0;
-				if (roll > 0)
-				{
-					// 内容上移：new[y] = old[y + roll]，底部暴露 roll 行。
-					BitBlt(layer.dc, 0, 0, bitmapWidth, layer.height - roll, layer.dc, 0, roll, SRCCOPY);
-					stripY = layer.height - roll;
-					stripH = roll;
-				}
-				else
-				{
-					const int amount = -roll;
-					// 内容下移：new[y] = old[y - amount]，顶部暴露 amount 行。
-					BitBlt(layer.dc, 0, amount, bitmapWidth, layer.height - amount, layer.dc, 0, 0,
-					       SRCCOPY);
-					stripY = 0;
-					stripH = amount;
-				}
-				// 锚点随之移动（与横向 `layer.wideMin += shift / scale` 同一套记账方式）。
-				layer.anchorYMax -= static_cast<double>(roll) / layer.pxPerValue;
-				// 补画暴露的那一条（整宽）。锚点用**滚动后**的值 —— 该条与已滚动的像素同一映射。
-				RenderLaneLayerRegion(laneIndex, layer, 0, bitmapWidth, stripY, stripH, layer.wideMin,
-				                      layer.anchorYMax);
-			}
-
-			if (shift == 0)
-			{
-				continue;
-			}
-
-			// 整数像素自贴图平移：内容整体移动 `shift` 像素。
-			if (shift > 0)
-			{
-				// 内容整体左移 shift：new[x] = old[x + shift]，右侧暴露 shift 列。
-				BitBlt(layer.dc, 0, 0, bitmapWidth - shift, layer.height, layer.dc, shift, 0, SRCCOPY);
-			}
-			else
-			{
-				const int amount = -shift;
-				BitBlt(layer.dc, amount, 0, bitmapWidth - amount, layer.height, layer.dc, 0, 0, SRCCOPY);
-			}
-			layer.wideMin += static_cast<double>(shift) / scale;
-
-			// 只补画新暴露的细条（每帧代价恒为 O(细条)）。
-			// ⚠️ 细条必须用**该图层更新后的映射**渲染（传 `layer.wideMin`）；若改用"当前视界"
-			// 的映射，细条与已平移的旧像素之间会有 ≤0.5px 的错位接缝 → 拖动时看起来在抖动。
-			// ⚠️ **纵向锚点必须沿用 `layer.anchorYMax`**（不能传当前 `yMax`）：横向补条只改一条
-			// 竖带，其余像素仍在原锚点上；同时该函数按锚点渲染这条竖带，因此竖带与其余像素
-			// 纵向同源。若在这里把锚点重置为当前 `yMax`，残余的纵向偏移会被静默清零、而像素
-			// 并未上移 → 整个网格的波形纵向错位（"垂直拖动后再横向平移出现纵向跳变"）。
-			const int stripWidth = std::min(std::abs(shift), bitmapWidth);
-			const int stripX = (shift > 0) ? (bitmapWidth - stripWidth) : 0;
-			RenderLaneLayerRegion(laneIndex, layer, stripX, stripWidth, 0, 0, layer.wideMin,
-			                      layer.anchorYMax);
-		}
-	}
-
-	bool PlotView::BlitWideBuffer(gd::Graphics& g) const
-	{
-		const float plotWidth = m_plotRect.Width;
-		const double span = Tab().ViewMax() - Tab().ViewMin();
-		if (!(plotWidth > 8.0f) || !(span > 0.0))
-		{
-			return false;
-		}
-		const int width = static_cast<int>(std::lround(plotWidth));
-		const int margin = LayerMarginX();
-		const int bitmapWidth = width + 2 * margin;
-		const double scale = static_cast<double>(width) / span;
-
-		std::lock_guard<std::mutex> lock(m_layerMutex);
-		if (m_layerFront.size() != m_lanes.size())
-		{
-			return false;
-		}
-		HDC target = g.GetHDC();
-		if (target == nullptr)
-		{
-			return false;
-		}
-		bool any = false;
-		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
-		{
-			const LaneLayer& layer = m_layerFront[index];
-			if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth)
-			{
-				continue;
-			}
-			const gd::RectF& lane = m_lanes[index].rect;
-			// 纵向映射是否仍然可用：图层高度必须等于"当前网格高 + 上下预渲染余量"。
-			// 高度变了（布局变化）时像素无法映射，只能等整块重画。
-			const int expectBitmapHeight =
-			    static_cast<int>(std::ceil(lane.Height)) + 2 * LayerMarginY(lane.Height);
-			if (layer.height != expectBitmapHeight)
-			{
-				continue;
-			}
-			// ⚠️ **跨度过期 = 该图层是"旧跨度"的像素**（典型：选区放大 / 键盘缩放的瞬间）。
-			// 旧实现直接 `continue` → 整个网格在重画完成前**空白**，且触发"同步整批重建"
-			// （实测 70~80ms）把前台卡住。
-			// 现在改为把它当作**占位图**用一次 StretchBlt 拉出来：旧图层覆盖的时间段
-			// [layer.wideMin, layer.wideMin + layer.span] 重新映射到新的视界上 ——
-			// 画面略糊（低分辨率），但**立即可用**；精确像素由后续按预算重画逐个替换。
-			const bool spanStale = (std::fabs(layer.span - span) > 1.0e-12);
-			const float top = std::max(lane.Y, m_plotRect.Y);
-			const float bottom = std::min(lane.Y + lane.Height, m_plotRect.Y + m_plotRect.Height);
-			if (bottom <= top)
-			{
-				continue;	// 网格整体移出可视区
-			}
-			const int destX = static_cast<int>(std::lround(m_plotRect.X));
-			const int destY = static_cast<int>(std::lround(top));
-			int height = static_cast<int>(std::lround(bottom - top));
-			if (height <= 0)
-			{
-				continue;
-			}
-
-			// ⚠️ **纵向偏移**：图层带「上下各半个网格高」的预渲染余量，幅值平移只改这里的
-			// 源行偏移（`anchorYMax` 与当前 `yMax` 之差换算成像素），不必重画图层 ——
-			// 这就是"纵向拖动与横向拖动同样是 O(1) 贴图"的关键。
-			int srcY = 0;
-			{
-				int vOffset = 0;
-				if (layer.pxPerValue > 0.0)
-				{
-					vOffset = static_cast<int>(
-					    std::llround((layer.anchorYMax - m_lanes[index].yMax) * layer.pxPerValue));
-				}
-				srcY = static_cast<int>(std::lround(top - lane.Y)) + layer.marginY + vOffset;
-			}
-			// 超出画布的上下两端只贴**有像素的那一段**（其余由底色填充，本帧的预算内重画会补齐）。
-			int destTopOffset = 0;
-			if (srcY < 0)
-			{
-				destTopOffset = -srcY;
-				height -= destTopOffset;
-				srcY = 0;
-			}
-			if (srcY + height > layer.height)
-			{
-				height = layer.height - srcY;
-			}
-			if (height <= 0)
-			{
-				continue;
-			}
-
-			if (spanStale)
-			{
-				// 占位拉伸：旧图层的时间跨度映射到当前视界（横向）。纵向映射不变。
-				if (!(layer.span > 0.0))
-				{
-					continue;
-				}
-				const double dx0 = static_cast<double>(destX) + (layer.wideMin - Tab().ViewMin()) * scale;
-				const double dx1 = dx0 + layer.span * scale;
-				if (!(dx1 > dx0))
-				{
-					continue;
-				}
-				const double cx0 = std::max(dx0, static_cast<double>(destX));
-				const double cx1 =
-				    std::min(dx1, static_cast<double>(destX) + static_cast<double>(width));
-				if (cx1 - cx0 < 1.0)
-				{
-					continue;
-				}
-				const double sx0 = (cx0 - dx0) / (dx1 - dx0) * static_cast<double>(layer.width);
-				const double sx1 = (cx1 - dx0) / (dx1 - dx0) * static_cast<double>(layer.width);
-				const int dstX = static_cast<int>(std::lround(cx0));
-				const int dstW = std::max(1, static_cast<int>(std::lround(cx1 - cx0)));
-				const int srcX2 = static_cast<int>(std::lround(sx0));
-				const int srcW = std::max(1, static_cast<int>(std::lround(sx1 - sx0)));
-				// HALFTONE 让拉伸后的占位图明显更接近成图（下采样尤其明显）；置一次即可。
-				SetStretchBltMode(target, HALFTONE);
-				SetBrushOrgEx(target, 0, 0, nullptr);
-				StretchBlt(target, dstX, destY + destTopOffset, dstW, height, layer.dc, srcX2, srcY,
-				           srcW, height, SRCCOPY);
-				any = true;
-				continue;
-			}
-
-			// ⚠️ **局部贴图**：图层只覆盖"视界 ± 半屏"，视界可能有一部分落在图层之外。
-			// 这里只贴**有像素的那一段**（其余留给底色填充，后续帧由预算内重画补齐），
-			// 而不是整块跳过 —— 跳过会让整个网格瞬间变空（"断线 / 空白"的直接原因）。
-			const double subX = (Tab().ViewMin() - layer.wideMin) * scale;
-			int srcX = static_cast<int>(std::lround(subX));
-			int destOffset = 0;				// 从视界左端起偏移多少像素开始贴
-			int blitWidth = width;
-			if (srcX < 0)
-			{
-				destOffset = -srcX;
-				blitWidth -= destOffset;
-				srcX = 0;
-			}
-			if (srcX + blitWidth > bitmapWidth)
-			{
-				blitWidth = bitmapWidth - srcX;
-			}
-			if (blitWidth <= 0)
-			{
-				continue;	// 完全没有可用像素（该网格待重画）
-			}
-			BitBlt(target, destX + destOffset, destY + destTopOffset, blitWidth, height, layer.dc, srcX,
-			       srcY, SRCCOPY);
-			any = true;
-		}
-		g.ReleaseHDC(target);
-		return any;
-	}
-
-	void PlotView::PaintRubberBand(gd::Graphics& g)
-	{
-		if (!m_dragMoved || m_rubberRect.Width <= 0.0f || m_rubberRect.Height <= 0.0f)
-		{
-			return;
-		}
-		if (m_dragMode != PlotDragMode::RUBBER_SELECT)
-		{
-			return;
-		}
-
-		// 轴向未定时不绘制选区，避免刚按下就闪出一个奇怪的方框。
-		const bool timeMode = (m_rubberAxis == PlotRubberAxis::TIME);
-		const bool valueMode = (m_rubberAxis == PlotRubberAxis::VALUE);
-		if (!timeMode && !valueMode)
-		{
-			return;
-		}
-
-		// 选区只应出现在绘图区内：即使内部矩形意外越界（例如鼠标被捕获到工具栏 /
-		// 信号面板上），也在这里再夹一次，绝不把选区块画到绘图区之外。
-		const float clipLeft = std::max(m_rubberRect.X, m_plotRect.X);
-		const float clipTop = std::max(m_rubberRect.Y, m_plotRect.Y);
-		const float clipRight =
-		    std::min(m_rubberRect.X + m_rubberRect.Width, m_plotRect.X + m_plotRect.Width);
-		const float clipBottom =
-		    std::min(m_rubberRect.Y + m_rubberRect.Height, m_plotRect.Y + m_plotRect.Height);
-		if (clipRight <= clipLeft || clipBottom <= clipTop)
-		{
-			return;
-		}
-		const gd::RectF bandRect(clipLeft, clipTop, clipRight - clipLeft, clipBottom - clipTop);
-
-		// 两种方向的选区使用**同一种强调色**，保持视觉一致。
-		const std::uint32_t band = m_theme->accent;
-		UiFillRect(g, bandRect, WithAlpha(band, 0x28));
-		UiDrawRoundRect(g, bandRect, 2.0f * m_scale, band, 1.4f);
-
-		// 选区跨度提示（时间用秒/数值用幅度量纲），放在选区顶部。
-		std::wstring text;
-		if (timeMode)
-		{
-			text = FormatValue(std::fabs(XToTime(m_rubberRect.X + m_rubberRect.Width) -
-			                             XToTime(m_rubberRect.X)));
-		}
-		else if (m_dragLane >= 0 && m_dragLane < static_cast<int>(m_lanes.size()))
-		{
-			const LaneVisual& lane = m_lanes[static_cast<std::size_t>(m_dragLane)];
-			text = FormatValue(std::fabs(YToValue(m_rubberRect.Y + m_rubberRect.Height, lane) -
-			                             YToValue(m_rubberRect.Y, lane)));
-		}
-		if (text.empty())
-		{
-			return;
-		}
-
-		const float textWidth = UiMeasureTextWidth(m_fonts->monoSmall, text) + 12.0f * m_scale;
-		const float textHeight = 18.0f * m_scale;
-		float labelX = bandRect.X + bandRect.Width * 0.5f - textWidth * 0.5f;
-		labelX = std::max(m_plotRect.X, std::min(labelX, m_plotRect.X + m_plotRect.Width - textWidth));
-		const gd::RectF labelRect(labelX, bandRect.Y + 3.0f * m_scale, textWidth, textHeight);
-
-		UiFillRoundRect(g, labelRect, 3.0f * m_scale, band);
-		UiText(g, text, m_fonts->monoSmall, labelRect, m_theme->textOnAccent, TextAlign::CENTER);
-	}
-
-	void PlotView::PaintHint(gd::Graphics& g)
-	{
-		if (m_hintText.empty() || m_fonts == nullptr || m_fonts->ui == nullptr || m_hintShownAt == 0)
-		{
-			return;
-		}
-
-		const std::uint64_t elapsed = GetTickCount64() - m_hintShownAt;
-		// 粘滞状态下不淡出（用于"拖动过程中维持显示"）。
-		if (!m_hintSticky && elapsed >= (kHintHoldMs + kHintFadeMs))
-		{
-			return;
-		}
-		// 停留结束后在 kHintFadeMs 内线性淡出（颜色 alpha 按比例缩放）。
-		const double fade = (m_hintSticky || elapsed <= kHintHoldMs)
-		                        ? 1.0
-		                        : (1.0 - static_cast<double>(elapsed - kHintHoldMs) /
-		                                     static_cast<double>(kHintFadeMs));
-		const unsigned int alpha =
-		    static_cast<unsigned int>(std::max(0.0, std::min(1.0, fade)) * 255.0);
-
-		// 提示条贴在绘图区底部居中；时间光标的时间读数也在底部，
-		// 因此光标启用时把提示条上移一行，避免两者互相遮挡。
-		const float reserved = (m_tab != nullptr && Tab().CursorEnabled()) ? 26.0f * m_scale : 0.0f;
-		const float width = UiMeasureTextWidth(m_fonts->ui, m_hintText) + 30.0f * m_scale;
-		const float height = 30.0f * m_scale;
-		float left = m_plotRect.X + (m_plotRect.Width - width) * 0.5f;
-		left = std::max(m_plotRect.X + 2.0f * m_scale,
-		                std::min(left, m_plotRect.X + m_plotRect.Width - width - 2.0f * m_scale));
-		const gd::RectF pill(left, m_plotRect.Y + m_plotRect.Height - height - 4.0f * m_scale - reserved,
-		                     width, height);
-
-		UiFillRoundRect(g, pill, 4.0f * m_scale, ScaleAlpha(m_theme->readoutBg, alpha));
-		UiDrawRoundRect(g, pill, 4.0f * m_scale, ScaleAlpha(m_theme->borderStrong, alpha), 1.2f);
-		// 文字走 GDI（不支持 alpha 通道），因此把文字颜色向胶囊底色**混色**来实现淡出。
-		const std::uint32_t textColor =
-		    MixColor(m_theme->textStrong, m_theme->readoutBg, 1.0f - static_cast<float>(fade));
-		UiText(g, m_hintText, m_fonts->ui, pill, textColor, TextAlign::CENTER);
-	}
-
-	void PlotView::PaintLane(gd::Graphics& g, int laneIndex, const LaneVisual& lane,
-	                         const std::vector<double>& timeTicks)
-	{
-		// 网格内容必须裁剪在绘图区之内：纵向滚动时网格会部分移出可视范围，
-		// 若不与 m_plotRect 求交，波形就会溢出到工具栏与时间轴区域。
-		const float clipTop = std::max(lane.rect.Y, m_plotRect.Y);
-		const float clipBottom =
-		    std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height);
-		if (clipBottom <= clipTop)
-		{
-			return;
-		}
-
-		const int saveState = g.Save();
-		// 与当前裁剪区求交（而不是替换）：局部重画（RepaintSceneCachePatch）时
-		// 外层已经按“需要重画的网格范围”设过裁剪区，这里必须保留，否则会重画到
-		// 其他网格上。整幅重绘时外层没有裁剪区，等同于原来的行为。
-		//
-		// ⚠️ **本次调用只允许改动 `m_area`** —— 它既是"整幅渲染"的绘图区，也是
-		// "信号图层"的**条带**（横向补条 = 窄 x 区间 × 全高；纵向补条 = 全宽 × 窄 y 区间）。
-		// GDI 绘制（网格线 / 分界线）**不受 GDI+ 裁剪约束**，所以它们的裁剪矩形必须
-		// **同时**与 `m_area` 求交：否则纵向补条时横向网格线会被画到条带之外的已正确像素上、
-		// 覆盖在波形之上（"网格线盖住波形"），并**永久烘进图层**、随之后的每次平移一起移动
-		// —— 正是用户报告的"上下拖动之后，左右/上下/斜向拖动都出现绘制错误"。
-		const gd::RectF laneClip = IntersectRect(
-		    gd::RectF(m_area.X, m_area.Y, m_area.Width, m_area.Height),
-		    gd::RectF(lane.rect.X, clipTop, lane.rect.Width, clipBottom - clipTop));
-		g.SetClip(laneClip, gd::CombineModeIntersect);
-
-
-		// 幅值网格线（先画线，标尺稍后作为覆盖层绘制，避免被波形遮挡）。
-		// 刻度密度随网格高度自适应：所有网格高度相同 → 各网格的刻度数量一致，
-		// 不会出现“有的网格只有 1 条标签、有的有 3 条”的不一致观感。
-		//
-		// ⚠️ 网格线一律用 **GDI** 批量绘制：GDI+ 的 DrawLine 每条约 0.1–0.19ms，
-		// 而一张网格有几十条网格线（5 个网格就是数百条），逐条调用会让单帧多花十几毫秒
-		// —— 这正是"放大后拖动网格视界很卡"的主因。GDI 绘制不受 GDI+ 裁剪约束，
-		// 因此显式传入裁剪矩形；半透明辅助线先与网格底色混合成不透明色。
-		const gd::RectF gridClip = laneClip;
-		/** 标尺数值文本的裁剪矩形（GDI 文本需要显式裁剪，否则会越过绘图区）。 */
-		const gd::RectF clipRectForLabels = gridClip;
-		const std::uint32_t minorLineColor = UiBlendOver(m_theme->cardBg, WithAlpha(m_theme->gridWeak, kMinorLineAlpha));
-		const std::uint32_t weakLineColor = m_theme->gridWeak | 0xFF000000u;
-		const std::uint32_t strongLineColor = m_theme->gridStrong | 0xFF000000u;
-
-		int yTickTarget = static_cast<int>(std::lround(lane.rect.Height / (kYTickSpacing * m_scale)));
-		yTickTarget = std::max(kYTickTargetMin, std::min(yTickTarget, kYTickTargetMax));
-		// ⚠️ 渲染「信号图层」时，幅值刻度必须以**前台可见网格**的跨度/高度为基准：
-		// 图层画布比可见网格高（上下各留预渲染余量），若按画布高度与扩展后的跨度取刻度，
-		// 图里的网格线密度就与整幅渲染不一致 —— 贴图后拖动时网格线会跳变。
-		// 用可见跨度取步长 + 按扩展范围铺满整张画布 ⇒ 刻度落在同一批绝对值格点上，
-		// 于是"纵向平移 = 纯粹的像素平移"（逐像素同源）。
-		const double tickSpan = (m_renderWide && m_wideTickSpan > 0.0)
-		                            ? m_wideTickSpan
-		                            : (lane.yMax - lane.yMin);
-		if (m_renderWide && m_wideTickHeight > 0.0f)
-		{
-			yTickTarget = static_cast<int>(
-			    std::lround(m_wideTickHeight / (kYTickSpacing * m_scale)));
-			yTickTarget = std::max(kYTickTargetMin, std::min(yTickTarget, kYTickTargetMax));
-		}
-		const double yStep = NiceStep(tickSpan, yTickTarget);
-		std::vector<double> yTicks;
-		BuildTicks(lane.yMin, lane.yMax, yStep, yTicks);
-
-		// 五等分估读线：在相邻主刻度之间再细分，便于目视读取中间值。
-		const double yMinorStep = yStep / static_cast<double>(kMinorDivisions);
-		std::vector<double> yMinorTicks;
-		BuildTicks(lane.yMin, lane.yMax, yMinorStep, yMinorTicks);
-		std::vector<float> minorSegments;
-		std::vector<float> weakSegments;
-		std::vector<float> strongSegments;
-		minorSegments.reserve(yMinorTicks.size() * 4);
-		weakSegments.reserve(yTicks.size() * 4);
-		for (const double tick : yMinorTicks)
-		{
-			// 与主刻度重合的位置跳过（主刻度会以更重的线条绘制）。
-			const double majorIndex = tick / yStep;
-			if (std::fabs(majorIndex - std::floor(majorIndex + 0.5)) < 1.0e-6)
-			{
-				continue;
-			}
-
-			const float y = ValueToY(tick, lane);
-			if (y < lane.rect.Y - 1.0f || y > lane.rect.Y + lane.rect.Height + 1.0f)
-			{
-				continue;
-			}
-			minorSegments.insert(minorSegments.end(),
-			                     {lane.rect.X, y, lane.rect.X + lane.rect.Width, y});
-		}
-
-		for (const double tick : yTicks)
-		{
-			const float y = ValueToY(tick, lane);
-			if (y < lane.rect.Y - 1.0f || y > lane.rect.Y + lane.rect.Height + 1.0f)
-			{
-				continue;
-			}
-
-			// 零线用更重的颜色（单独一批，避免为每段颜色切换画笔）。
-			std::vector<float>& target = (tick == 0.0) ? strongSegments : weakSegments;
-			target.insert(target.end(), {lane.rect.X, y, lane.rect.X + lane.rect.Width, y});
-		}
-
-		// 时间网格线（同样补充五等分估读线）。
-		// ⚠️ 主刻步长优先取 `m_renderTimeStep`（渲染信号图层时由前台跨度给出，见该成员的说明）：
-		// 图层渲染的 `Tab().ViewMin/ViewMax` 是**宽窗口**区间，直接拿它算 `NiceStep` 会得到比前台
-		// 更大的步长（往往正好 2 倍），使图层里的竖向网格线与前台错位、部分整条丢失。
-		const double timeSpan = Tab().ViewMax() - Tab().ViewMin();
-		const double timeMajorStep =
-		    (m_renderTimeStep > 0.0) ? m_renderTimeStep
-		                             : NiceStep((timeSpan > 0.0) ? timeSpan : 1.0, kTimeTickTarget);
-		const double timeMinorStep = timeMajorStep / static_cast<double>(kMinorDivisions);
-		std::vector<double> timeMinorTicks;
-		BuildTicks(Tab().ViewMin(), Tab().ViewMax(), timeMinorStep, timeMinorTicks);
-		for (const double tick : timeMinorTicks)
-		{
-			const double majorIndex = tick / timeMajorStep;
-			if (std::fabs(majorIndex - std::floor(majorIndex + 0.5)) < 1.0e-6)
-			{
-				continue;
-			}
-
-			const float x = TimeToX(tick);
-			if (x < lane.rect.X || x > lane.rect.X + lane.rect.Width)
-			{
-				continue;
-			}
-			minorSegments.insert(minorSegments.end(),
-			                     {x, lane.rect.Y, x, lane.rect.Y + lane.rect.Height});
-		}
-
-		for (const double tick : timeTicks)
-		{
-			const float x = TimeToX(tick);
-			if (x < lane.rect.X || x > lane.rect.X + lane.rect.Width)
-			{
-				continue;
-			}
-			weakSegments.insert(weakSegments.end(), {x, lane.rect.Y, x, lane.rect.Y + lane.rect.Height});
-		}
-
-		if (!m_renderDecorOnly)
-		{
-			if (!minorSegments.empty())
-			{
-				UiDrawSolidLines(g, gridClip, minorSegments.data(), minorSegments.size() / 4, minorLineColor);
-			}
-			if (!weakSegments.empty())
-			{
-				UiDrawSolidLines(g, gridClip, weakSegments.data(), weakSegments.size() / 4, weakLineColor);
-			}
-			if (!strongSegments.empty())
-			{
-				UiDrawSolidLines(g, gridClip, strongSegments.data(), strongSegments.size() / 4, strongLineColor);
-			}
-		}
-
-		// 波形绘制。
-		const std::vector<SignalRef>& laneSignals = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals;
-		if (m_renderDecorOnly)
-		{
-			// 只画装饰：网格线与波形已由宽基底提供，这里跳过。
-		}
-		else if (laneSignals.empty())
-		{
-			const gd::RectF visibleRect(lane.rect.X, clipTop, lane.rect.Width, clipBottom - clipTop);
-			UiText(g, L"（空网格）", m_fonts->uiSmall, visibleRect, m_theme->textMuted, TextAlign::CENTER);
-		}
-		else
-		{
-			const int waveSave = g.Save();
-			g.SetClip(lane.rect, gd::CombineModeIntersect);
-
-			// 只有拖拽中的信号光晕可以进入静态场景缓存（悬停光晕见 PaintHoverHighlight）。
-			const SignalRef haloRef = SceneHaloRef();
-			// 派生预览曲线（中心轴 / 均值滤波 / 弱峰调整）在下方"第二遍"统一叠加绘制，
-			// 见 `PaintLaneDerivedOverlays`（抽出以便宽缓冲区前台路径复用）。
-
-			for (const SignalRef& ref : laneSignals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
-				{
-					continue;
-				}
-
-				const DrawMode mode = resolved.style->mode;
-				// 顶点由“几何键”缓存提供：同一视图下重复绘制不再重算全量采样。
-				const PolylineCacheEntry* cached = AcquirePolyline(ref, resolved, lane);
-				if (cached == nullptr)
-				{
-					continue;
-				}
-				const std::vector<gd::PointF>& points = cached->points;
-				const std::vector<std::size_t>& breaks = cached->breaks;
-
-				const bool drawLine = (mode != DrawMode::SCATTER);
-				const bool drawScatter = (mode == DrawMode::SCATTER || mode == DrawMode::LINE_SCATTER);
-
-				// 悬停命中的信号先画一层浅色光晕，作为“可拖拽”的视觉提示。
-				// 这里只处理拖拽中的信号（其光晕在拖拽期间不变，可以进入静态场景缓存）；
-				// 悬停光晕随鼠标变化，改由 PaintHoverHighlight 在缓存贴图之后绘制。
-				const bool highlighted = (ref == haloRef);
-				if (highlighted)
-				{
-					PaintSignalHaloFor(g, resolved, lane, *cached);
-				}
-
-				if (drawLine && !breaks.empty())
-				{
-					const std::uint32_t lineColor = StyleColor(*resolved.style);
-					if (cached->bandMode && !cached->bandBreaks.empty())
-					{
-						// 稠密包络：一次 FillPath 填充包络带。
-						// **必须显式设为缠绕填充规则**：包络带自交（相邻列上下包络交叉）时，
-						// 交替（奇偶）规则会在交叠处挖出空洞。
-						//
-						// 抗锯齿开关：几何保持不变，只在"交互期间"或"梳状带"时关闭。
-						// 梳状带（振荡周期≈像素列宽）下抗锯齿的扫描线代价暴涨而观感几乎无差别，
-						// 实测同一条 2448 顶点的路径 27.6ms → 3.2ms。
-						const int savedSmoothing = g.GetSmoothingMode();
-						if (m_fastFrame || cached->bandSpiky)
-						{
-							g.SetSmoothingMode(gd::SmoothingModeNone);
-						}
-						gd::GraphicsPath bandPath;
-						bandPath.SetFillMode(gd::FillModeWinding);
-						for (std::size_t k = 0; k < cached->bandBreaks.size(); ++k)
-						{
-							const std::size_t start = cached->bandBreaks[k];
-							const std::size_t stop = (k + 1 < cached->bandBreaks.size())
-							                             ? cached->bandBreaks[k + 1]
-							                             : cached->band.size();
-							const std::size_t total = stop - start;
-							if (total < 4 || (total % 2) != 0)
-							{
-								continue;
-							}
-							const std::size_t half = total / 2;
-							bandPath.StartFigure();
-							bandPath.AddLines(cached->band.data() + start, static_cast<INT>(half));
-							bandPath.AddLines(cached->band.data() + start + half,
-							                  static_cast<INT>(half));
-							bandPath.CloseFigure();
-						}
-						if (bandPath.GetPointCount() > 0)
-						{
-							gd::SolidBrush brush(ToGdiColor(lineColor));
-							g.FillPath(&brush, &bandPath);
-						}
-						g.SetSmoothingMode(static_cast<gd::SmoothingMode>(savedSmoothing));
-					}
-					else
-					{
-						gd::Pen pen(ToGdiColor(lineColor), resolved.style->lineWidth * m_scale);
-						pen.SetLineJoin(gd::LineJoinRound);
-						pen.SetStartCap(gd::LineCapRound);
-						pen.SetEndCap(gd::LineCapRound);
-
-						for (std::size_t k = 0; k < breaks.size(); ++k)
-						{
-							const std::size_t start = breaks[k];
-							const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
-							if (stop <= start + 1)
-							{
-								continue;
-							}
-							g.DrawLines(&pen, points.data() + start, static_cast<INT>(stop - start));
-						}
-					}
-				}
-
-				if (drawScatter && !points.empty())
-				{
-					// 散点半径随线宽线性增长（达到上限前不过早触顶），使“线宽”直观控制数据点大小。
-					const float radius = static_cast<float>(
-					    ClampDouble(static_cast<double>(resolved.style->lineWidth) * kScatterRadiusScale,
-					                kMinScatterRadius, kMaxScatterRadius) *
-					    m_scale);
-					const std::size_t scatterStride =
-					    std::max<std::size_t>(1, points.size() / kMaxScatterPoints);
-					// 所有散点合并到一条 GraphicsPath 后只调用一次 FillPath：
-					// 逐点 FillEllipse 每次都要完整走一遍 GDI+ 的状态检查与光栅化入口，
-					// 实测 2500 点需要约 51ms；合并后约 1/9（实测基准 63ms → 7ms）。
-					// **必须显式设为缠绕填充规则**：GraphicsPath 默认是交替（奇偶）规则，
-					// 两个重叠的圆在交集处会互相抵消形成空洞，表现为"数据点重叠处出现异常白边"。
-					gd::GraphicsPath scatterPath;
-					scatterPath.SetFillMode(gd::FillModeWinding);
-					for (std::size_t k = 0; k < points.size(); k += scatterStride)
-					{
-						scatterPath.AddEllipse(points[k].X - radius, points[k].Y - radius, radius * 2.0f,
-						                       radius * 2.0f);
-					}
-					gd::SolidBrush brush(ToGdiColor(StyleColor(*resolved.style)));
-					if (scatterPath.GetPointCount() > 0)
-					{
-						g.FillPath(&brush, &scatterPath);
-					}
-				}
-			}
-
-			// 第二遍：把所有**派生预览曲线**统一绘制在**本网格全部原信号之上**。
-			// 渲染「宽缓冲区」时跳过：宽缓冲只存"基底"（网格/波形，不含派生曲线与装饰），
-			// 派生曲线改由前台叠加层绘制（见 `PaintLaneDerivedOverlays`），
-			// 这样拖派生参数滑块时基底不变、可复用宽缓冲像素。
-			// ⚠️ `m_renderDecorOnly`（把装饰单独画进透明缓存位图）时**也必须跳过**：
-			// 派生曲线是"随时间视界变化"的内容，若烘进装饰位图，贴回时会把旧视界的
-			// 预览曲线永久留在画面上。
-			if (!m_renderWide && !m_renderDecorOnly)
-			{
-				PaintLaneDerivedOverlays(g, laneIndex, lane);
-			}
-
-			// g.Restore 也会还原绘制状态，此处直接恢复图形状态即可。
-			g.Restore(waveSave);
-		}
-
-		// 网格分界线：网格之间不再留间隔，改用较重的横线明确分隔相邻网格。
-		// ⚠️ **渲染信号图层时跳过**：分界线锚定在网格的**屏幕位置**（`lane.rect.Y`），
-		// 而图层会被纵向偏移贴图（幅值平移）—— 若烘进图层，纵向拖动时它会跟着波形一起跑。
-		// 因此它在整幅重绘里由这里绘制，宽基底快路径则由 `PaintLaneDividers` 补画一次。
-		const float dividerY = lane.rect.Y;
-		if (!m_renderDecorOnly && !m_renderWide && dividerY >= m_plotRect.Y - 1.0f &&
-		    dividerY <= m_plotRect.Y + m_plotRect.Height)
-		{
-			const float dividerSegments[4] = {lane.rect.X, dividerY, lane.rect.X + lane.rect.Width, dividerY};
-			const std::uint32_t dividerColor =
-			    ((laneIndex == 0) ? m_theme->axisLine : m_theme->borderStrong) | 0xFF000000u;
-			UiDrawSolidLines(g, gridClip, dividerSegments, 1, dividerColor,
-			                 (laneIndex == 0) ? 2 : static_cast<int>(kLaneDividerWidth));
-		}
-
-		// 内侧纵轴标尺作为覆盖层绘制：每个刻度数值带半透明底，保证在波形之上仍清晰可读，
-		// 同时只在数值背后遮挡波形，不牺牲波形本身的可见范围。
-		// ⚠️ 渲染「宽缓冲区」时跳过 Y 轴刻度与图例：它们锚定在网格左缘、随视界横向移动，
-		// 而宽缓冲区会被平移截取，装饰必须由前台叠加层（装饰层缓存）单独绘制。
-		if (!m_renderWide)
-		{
-			const bool showLabels = (lane.rect.Height >= 34.0f * m_scale);
-			float lastLabelY = -1.0e9f;
-
-			// 网格较矮时同步收紧标签行距，让密度随可用高度提升而不是整片被过滤掉。
-			const float labelMinGap =
-			    std::min(kYLabelMinGap * m_scale,
-			             lane.rect.Height / static_cast<float>(yTickTarget + 1));
-
-			// 先收集需要绘制的数值底板：合并成一次 FillPath（几十个小圆角矩形逐个填充
-			// 会带来明显的 GDI+ 调用开销），文字再逐个绘制（GDI 文本无法合批）。
-			std::vector<gd::RectF> pills;
-			std::vector<std::wstring> pillTexts;
-			std::vector<bool> pillZero;
-			for (const double tick : yTicks)
-			{
-				if (!showLabels)
-				{
-					break;
-				}
-
-				const float y = ValueToY(tick, lane);
-				if (y < lane.rect.Y - 1.0f || y > lane.rect.Y + lane.rect.Height + 1.0f)
-				{
-					continue;
-				}
-				if (std::fabs(y - lastLabelY) < labelMinGap)
-				{
-					continue;
-				}
-				lastLabelY = y;
-
-				const std::wstring raw = FormatTick(tick, yStep);
-				const float textWidth = UiMeasureTextWidth(m_fonts->monoSmall, raw);
-				const float pillHeight = 17.0f * m_scale;
-				const gd::RectF pill(lane.rect.X + kLaneLabelPad * m_scale, y - pillHeight * 0.5f,
-				                     std::min(textWidth + 8.0f * m_scale,
-				                              lane.rect.Width - 2.0f * kLaneLabelPad * m_scale),
-				                     pillHeight);
-				if (pill.Width <= 0.0f)
-				{
-					continue;
-				}
-				// 与图例重叠时不再跳过：标尺值先绘制，随后绘制的图例会盖在其上层
-				// （顶层始终为图例），因此两者都不丢失。
-				// 数值**完全**移出可见区时才不绘制；只要还有一部分在区内就绘制未被遮挡的部分
-				// （裁剪交给 GDI 文本的 ETO_CLIPPED 与下面的底板夹取共同保证）。
-				const float visibleTop = std::max(pill.Y, clipTop);
-				const float visibleBottom = std::min(pill.Y + pill.Height, clipBottom);
-				if (visibleBottom <= visibleTop)
-				{
-					continue;
-				}
-
-				pills.push_back(gd::RectF(pill.X, visibleTop, pill.Width, visibleBottom - visibleTop));
-				pillTexts.push_back(
-				    UiEllipsize(raw, m_fonts->monoSmall, pill.Width - 6.0f * m_scale));
-				pillZero.push_back(tick == 0.0);
-			}
-
-			// 记录胶囊矩形（供装饰层绘制/贴回；略微外扩以容纳圆角与文字边缘）。
-			for (const gd::RectF& pill : pills)
-			{
-				m_decorRects.push_back(gd::RectF(pill.X - 2.0f * m_scale, pill.Y - 1.0f * m_scale,
-				                                 pill.Width + 4.0f * m_scale, pill.Height + 2.0f * m_scale));
-			}
-			// 命中装饰缓存：跳过重绘（文字 + 圆角底板），由上层整块贴回。
-			// ⚠️ 底板是**圆角且不透明**：装饰位图带 alpha，圆角之外必须保持全透明，
-			// 贴回时才能透出当前波形（避免"圆角外多出一圈直角白边"）。
-			if (!m_useDecorCache)
-			{
-				UiFillRoundRects(g, pills, 3.0f * m_scale, m_theme->cardBg | 0xFF000000u);
-				for (std::size_t index = 0; index < pills.size(); ++index)
-				{
-					const gd::RectF& pill = pills[index];
-					// 用 UiTextAtClipped 保证长文本不越过绘图区（GDI 文本不受 GDI+ 裁剪约束）。
-					UiTextAtClipped(g, pillTexts[index], m_fonts->monoSmall, pill.X + 4.0f * m_scale,
-					                gd::RectF(pill.X + 4.0f * m_scale, pill.Y, pill.Width - 8.0f * m_scale,
-					                          pill.Height),
-					                pillZero[index] ? m_theme->text : m_theme->textMuted,
-					                clipRectForLabels);
-				}
-			}
-		}
-
-		if (!m_renderWide && lane.rect.Height >= 24.0f * m_scale)
-		{
-			PaintLaneLegend(g, laneIndex, lane, clipTop, clipBottom);
-		}
-
-		g.Restore(saveState);
-	}
-
-	void PlotView::PaintLaneDividers(gd::Graphics& g) const
-	{
-		if (m_theme == nullptr)
-		{
-			return;
-		}
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			const gd::RectF& rect = m_lanes[index].rect;
-			const float dividerY = rect.Y;
-			if (dividerY < m_plotRect.Y - 1.0f || dividerY > m_plotRect.Y + m_plotRect.Height)
-			{
-				continue;
-			}
-			const float segments[4] = {rect.X, dividerY, rect.X + rect.Width, dividerY};
-			const std::uint32_t dividerColor =
-			    ((index == 0) ? m_theme->axisLine : m_theme->borderStrong) | 0xFF000000u;
-			// GDI 批绘不受 GDI+ 裁剪约束 → 显式给出只覆盖该分界线附近的裁剪矩形。
-			const gd::RectF clip(m_area.X, dividerY - 4.0f * m_scale, m_area.Width, 8.0f * m_scale);
-			UiDrawSolidLines(g, clip, segments, 1, dividerColor,
-			                 (index == 0) ? 2 : static_cast<int>(kLaneDividerWidth));
-		}
-	}
-
-	SignalRef PlotView::LegendAtPoint(int x, int y) const
-	{
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-		for (const LegendHit& hit : m_legendHits)
-		{
-			if (UiPointInRect(hit.rect, fx, fy))
-			{
-				return hit.ref;
-			}
-		}
-		return SignalRef();
-	}
-
-	void PlotView::PaintLaneDerivedOverlays(gd::Graphics& g, int laneIndex, const LaneVisual& lane) const
-	{
-		if (m_tab == nullptr || laneIndex < 0 ||
-		    laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return;
-		}
-		const Lane& tabLane = Tab().Lanes()[static_cast<std::size_t>(laneIndex)];
-		const bool centerOn = tabLane.edgeCenter;
-		const bool meanFilterOn = tabLane.meanFilter;
-		const bool weakPeakOn = tabLane.weakPeak;
-		if (!centerOn && !meanFilterOn && !weakPeakOn)
-		{
-			return;
-		}
-		const int saveState = g.Save();
-		g.SetClip(lane.rect, gd::CombineModeIntersect);
-		for (const SignalRef& ref : tabLane.signals)
-		{
-			const ResolvedSignal resolved = ResolveSignal(ref);
-			if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
-			{
-				continue;
-			}
-			if (centerOn)
-			{
-				const Lane::EdgeCenterItem* centerItem = tabLane.FindEdgeCenterItem(ref);
-				if (centerItem != nullptr)
-				{
-					PaintMeanFilterCurve(g, resolved, lane, centerItem->points, centerItem->iterations);
-				}
-			}
-			if (meanFilterOn)
-			{
-				const Lane::MeanFilterItem* item = tabLane.FindMeanFilterItem(ref);
-				if (item != nullptr)
-				{
-					PaintMeanFilterCurve(g, resolved, lane, item->points, item->iterations);
-				}
-			}
-			if (weakPeakOn)
-			{
-				// 每个信号用自己的「增强等级 + 迭代次数」（与面板滑块、构建新信号完全一致）。
-				const Lane::WeakPeakItem* item = tabLane.FindWeakPeakItem(ref);
-				if (item != nullptr)
-				{
-					const int amountPercent =
-					    std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, item->amountPercent));
-					const int boostIterations = std::max(
-					    kWeakPeakIterationsMin,
-					    std::min(kWeakPeakIterationsMaxLimit, item->iterations));
-					PaintWeakPeakCurve(g, resolved, lane, amountPercent, boostIterations);
-				}
-			}
-		}
-		g.Restore(saveState);
-	}
-
-	void PlotView::PaintLaneLegend(gd::Graphics& g, int laneIndex, const LaneVisual& lane, float visibleTop,
-	                               float visibleBottom)
-	{
-		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
-		{
-			return;
-		}
-
-		// 图例固定在网格左上角：网格被滚动出可视区时整体跳过，避免文字溢出到工具栏。
-		const gd::RectF legendBand(lane.rect.X + kLegendPad * m_scale,
-		                           lane.rect.Y + kLegendPad * m_scale, lane.rect.Width,
-		                           kLegendHeight * m_scale);
-		if (!IsFullyVisible(legendBand, visibleTop, visibleBottom))
-		{
-			return;
-		}
-
-		const std::vector<SignalRef>& laneSignals = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals;
-		const bool multiFile = LaneSpansMultipleFiles(laneIndex);
-
-		const float top = legendBand.Y;
-		const float height = kLegendHeight * m_scale;
-		const float swatchSize = kLegendSwatchSize * m_scale;
-		const float maxX = lane.rect.X + lane.rect.Width - kLanePadding * m_scale;
-
-		// 网格编号徽标（图例左侧）：与左侧信号面板每行末尾的 “GX” 徽标样式完全一致。
-		// 矩形由 LaneBadgeRect 统一计算，绘制与命中测试因此永远一致。
-		const gd::RectF badgeRect = LaneBadgeRect(laneIndex);
-		const float badgeHeight = kLaneBadgeHeight * m_scale;
-		float cursorX = badgeRect.X + badgeRect.Width + kLaneBadgeGap * m_scale;
-
-		// 图例条目的托底 = **与 GX 编号徽标完全同款**（用户明确要求）：
-		//   * 高度与徽标相同（`bgadeRect` 的上下边界一模一样，因此"上下边距相同"）；
-		//   * 圆角 = 高度的一半（胶囊形），与徽标的 `badgeHeight * 0.5f` 一致；
-		//   * 配色与描边宽度也与徽标一致（`cardBg/border`，选中态 `accentSoft/accent`）；
-		//   * 水平内边距 = 胶囊半径（若小于半径，内容会溢出圆角之外）。
-		//   * 文本改用**更小的字体**（`uiTiny`）：原用 `uiSmall` 时文字几乎顶满胶囊高度。
-		// ⚠️ 托底矩形**同时就是命中矩形**（看到的与点得到的严格一致）。
-		const float plateHeight = badgeHeight;
-		const float plateTop = badgeRect.Y;
-		const float platePadX = plateHeight * 0.5f;
-
-		// ------------------------------------------------------------------
-		// 1) 几何：算出"放得下"的条目及其矩形（**唯一来源**，命中 / 装饰 / 绘制共用）。
-		// ------------------------------------------------------------------
-		struct LegendItem
-		{
-			SignalRef ref;
-			float left = 0.0f;			// 色块左缘
-			float width = 0.0f;			// 条目**内容**宽度（色块 + 间距 + 文本）
-			float plateWidth = 0.0f;	// 托底宽度（内容 + 两侧内边距）
-			float textWidth = 0.0f;
-			std::wstring label;
-			bool selected = false;
-		};
-		std::vector<LegendItem> items;
-		int visibleCount = 0;
-		float contentRight = cursorX;
-		{
-			float probeX = cursorX;
-			for (const SignalRef& ref : laneSignals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
-				{
-					continue;
-				}
-				++visibleCount;
-				std::wstring label = BuildLegendText(*resolved.data);
-				if (multiFile && resolved.group != nullptr)
-				{
-					label += L" · " + resolved.group->name;
-				}
-				const float maxTextWidth = kLegendMaxTextWidth * m_scale;
-				const float fullTextWidth = UiMeasureTextWidth(m_fonts->uiTiny, label);
-				const float textWidth = std::min(fullTextWidth, maxTextWidth);
-				const float contentWidth = swatchSize + 5.0f * m_scale + textWidth;
-				const float plateWidth = contentWidth + platePadX * 2.0f;
-				if (probeX + plateWidth > maxX)
-				{
-					break;		// 空间不足：其余条目省略，下方用 "+N" 提示
-				}
-				LegendItem item;
-				item.ref = ref;
-				item.left = probeX + platePadX;		// 色块左缘（托底内缩一个内边距）
-				item.width = contentWidth;
-				item.plateWidth = plateWidth;
-				item.textWidth = textWidth;
-				item.label = (fullTextWidth > maxTextWidth)
-				                 ? UiEllipsize(label, m_fonts->uiTiny, maxTextWidth)
-				                 : label;
-				item.selected = (SelectedRef() == ref);
-				items.push_back(std::move(item));
-				probeX += plateWidth + kLegendItemGap * m_scale;
-			}
-			contentRight = probeX;
-		}
-		const auto PlateRect = [&](const LegendItem& item)
-		{
-			return gd::RectF(item.left - platePadX, plateTop, item.plateWidth, plateHeight);
-		};
-		// 条目托底 = 与 GX 编号徽标同一套风格的**胶囊形圆角矩形**（半径 = 高度的一半）。
-		const float plateRadius = plateHeight * 0.5f;
-		// 「+N」（图例空间不足）与「（无可见信号）」提示的矩形。
-		// ⚠️ 它们同样属于装饰层、必须登记进 `m_decorRects`：否则会被画进装饰位图
-		// 却因不在贴回列表里而永远看不见。
-		const bool hasMoreText = (visibleCount > static_cast<int>(items.size())) &&
-		                         (contentRight + 20.0f * m_scale <= maxX);
-		const bool hasEmptyText = (visibleCount == 0);
-		const gd::RectF moreTextRect(contentRight, top, 24.0f * m_scale, height);
-		const gd::RectF emptyTextRect(legendBand.X, top, lane.rect.Width, height);
-
-		// ------------------------------------------------------------------
-		// 2) 命中矩形：**无论是否命中装饰缓存都必须重建**。
-		//    整幅重绘路径会先清空 `m_legendHits`；若这里因为"装饰缓存命中"而提前返回、
-		//    不写入新矩形，图例的悬停高亮 / 点击选中 / 双击改名就会**全部失效**
-		//（用户报告："用中键移动过视角之后图例点不动、悬停也没反应"）。
-		// ------------------------------------------------------------------
-		for (auto iterator = m_legendHits.begin(); iterator != m_legendHits.end();)
-		{
-			if (m_tab->LaneOfSignal(iterator->ref) == laneIndex)
-			{
-				iterator = m_legendHits.erase(iterator);
-			}
-			else
-			{
-				++iterator;
-			}
-		}
-		for (const LegendItem& item : items)
-		{
-			const ResolvedSignal resolved = ResolveSignal(item.ref);
-			LegendHit hit;
-			hit.ref = item.ref;
-			hit.rect = PlateRect(item);
-			hit.radius = plateRadius;
-			hit.swatch =
-			    gd::RectF(item.left, plateTop + (plateHeight - swatchSize) * 0.5f, swatchSize, swatchSize);
-			hit.text = gd::RectF(item.left + swatchSize + 5.0f * m_scale, plateTop,
-			                     std::max(8.0f, item.textWidth + 2.0f), plateHeight);
-			hit.label = item.label;
-			// 「选中」与「悬停」用同一套配色（用户明确要求），因此文字色在这里也按选中态取。
-			hit.textColor = item.selected ? m_theme->textStrong : m_theme->text;
-			if (resolved.style != nullptr)
-			{
-				hit.swatchColor = resolved.style->color;
-				hit.swatchOpacity = resolved.style->opacity;
-			}
-			m_legendHits.push_back(std::move(hit));
-			if (m_editTarget == PlotEditTarget::SIGNAL_NAME && m_editSignal == item.ref)
-			{
-				m_editFieldRect = PlateRect(item);
-			}
-		}
-
-		// 装饰矩形：**逐块**（徽标一块 + 每个条目一块），而不是覆盖整条图例带 ——
-		// 覆盖整条带没有必要，且逐块能减少装饰层贴图面积。
-		m_decorRects.push_back(badgeRect);
-		for (const LegendItem& item : items)
-		{
-			m_decorRects.push_back(PlateRect(item));
-		}
-		if (hasEmptyText)
-		{
-			m_decorRects.push_back(emptyTextRect);
-		}
-		if (hasMoreText)
-		{
-			m_decorRects.push_back(moreTextRect);
-		}
-
-		// 命中装饰缓存：徽标与图例的像素改由装饰层贴回，跳过重绘（命中矩形已在上方重建）。
-		if (m_useDecorCache)
-		{
-			return;
-		}
-
-		// ------------------------------------------------------------------
-		// 3) 绘制。托底是**圆角矩形**（与 GX 编号徽标同风格）：
-		//    "一个 GX 标签，只是内容换成了图例信息"（用户明确要求）。
-		//    ⚠️ **不再铺任何外扩的不透明直角底色**：装饰位图带 alpha，圆角之外必须保持
-		//    全透明，贴回时才能透出**当前**波形 —— 否则圆角外会多出一圈"直角白边"。
-		//    ⚠️ 徽标与条目的**悬停 / 激活高亮不在这里**（随鼠标变化，画在贴图之后，
-		//    见 PaintLegendHighlight）—— 否则会被缓存冻结，悬停时看不到任何反馈。
-		// ------------------------------------------------------------------
-		{
-			UiFillRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->cardBg);
-			UiDrawRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->border, 1.0f);
-			UiText(g, L"G" + std::to_wstring(laneIndex + 1), m_fonts->monoSmall, badgeRect,
-			       m_theme->text, TextAlign::CENTER);
-
-			for (const LegendItem& item : items)
-			{
-				const ResolvedSignal resolved = ResolveSignal(item.ref);
-				if (resolved.data == nullptr || resolved.style == nullptr)
-				{
-					continue;
-				}
-				const gd::RectF plate = PlateRect(item);
-				// 选中态 = 悬停态配色（`accentSoft` 底 + `accent` 描边），
-				// 与 GX 编号徽标的鼠标悬停效果完全一致。
-				UiFillRoundRect(g, plate, plateRadius,
-				                item.selected ? m_theme->accentSoft : m_theme->cardBg);
-				UiDrawRoundRect(g, plate, plateRadius,
-				                item.selected ? m_theme->accent : m_theme->border, 1.0f);
-
-				// 改名编辑态：整块托底变成输入框（与左侧列表双击改名一致）。
-				if (m_editTarget == PlotEditTarget::SIGNAL_NAME && m_editSignal == item.ref)
-				{
-					UiDrawEditField(g, plate, m_edit, m_fonts->uiTiny, m_scale);
-					continue;
-				}
-
-				UiDrawSwatch(g,
-				             gd::RectF(item.left, plateTop + (plateHeight - swatchSize) * 0.5f,
-				                       swatchSize, swatchSize),
-				             resolved.style->color, resolved.style->opacity, 1.5f * m_scale, m_scale);
-				UiText(g, item.label, m_fonts->uiTiny,
-				       gd::RectF(item.left + swatchSize + 5.0f * m_scale, plateTop,
-				                 std::max(8.0f, item.textWidth + 2.0f), plateHeight),
-				       item.selected ? m_theme->textStrong : m_theme->text, TextAlign::LEFT);
-			}
-		}
-
-		if (hasEmptyText)
-		{
-			UiText(g, L"（无可见信号）", m_fonts->uiTiny, emptyTextRect, m_theme->textMuted,
-			       TextAlign::LEFT);
-		}
-		else if (hasMoreText)
-		{
-			// 图例空间不足时提示剩余信号数量，避免误认为信号丢失。
-			const std::wstring moreText =
-			    L"+" + std::to_wstring(visibleCount - static_cast<int>(items.size()));
-			UiText(g, moreText, m_fonts->uiTiny, moreTextRect, m_theme->textMuted, TextAlign::LEFT);
-		}
-	}
-
-	bool PlotView::IsFullyVisible(const gd::RectF& rect, float visibleTop, float visibleBottom)
-	{
-		return (rect.Y >= visibleTop - 0.5f) && (rect.Y + rect.Height <= visibleBottom + 0.5f);
-	}
-
-	void PlotView::PaintTimeAxis(gd::Graphics& g, const std::vector<double>& timeTicks, double timeStep)
-	{
-		const float axisY = m_plotRect.Y + m_plotRect.Height;
-		// 时间轴的轴线与刻度线同样走 GDI 批量绘制（理由见 PaintLane 中的说明）。
-		const gd::RectF axisClip(m_area.X, m_area.Y, m_area.Width, m_area.Height);
-		const std::uint32_t axisColor = m_theme->axisLine | 0xFF000000u;
-		{
-			const float axisSegment[4] = {m_plotRect.X, axisY, m_plotRect.X + m_plotRect.Width, axisY};
-			UiDrawSolidLines(g, axisClip, axisSegment, 1, axisColor);
-		}
-
-		// 时间轴列名（取自首个可见信号所属分组的第一条时间轴），贴左侧绘制。
-		std::wstring axisName = L"时间";
-		if (m_dataSet != nullptr && m_tab != nullptr)
-		{
-			for (std::size_t groupIndex = 0; groupIndex < m_dataSet->GroupCount(); ++groupIndex)
-			{
-				if (!m_tab->GroupHasVisible(static_cast<int>(groupIndex)))
-				{
-					continue;
-				}
-				const SignalGroup* group = m_dataSet->GroupAt(static_cast<int>(groupIndex));
-				if (group != nullptr && !group->axes.empty() && !group->axes.front().name.empty())
-				{
-					axisName = group->axes.front().name;
-					// CSV 中该列通常直接叫 "time"，这里补上时间单位秒便于阅读；
-					// 若列名自带单位描述（以右括号结尾）则不重复追加。
-					if (axisName.back() != L')')
-					{
-						axisName += L" (s)";
-					}
-				}
-				break;
-			}
-		}
-
-		const float nameWidth =
-		    std::min(UiMeasureTextWidth(m_fonts->monoSmall, axisName) + 8.0f * m_scale,
-		             m_plotRect.Width * 0.4f);
-		const gd::RectF nameRect(m_plotRect.X + 2.0f * m_scale, axisY + 3.0f * m_scale, nameWidth,
-		                         std::max(0.0f, m_timeAxisRect.Height - 5.0f * m_scale));
-		UiText(g, UiEllipsize(axisName, m_fonts->monoSmall, nameWidth), m_fonts->monoSmall, nameRect,
-		       m_theme->textMuted, TextAlign::LEFT);
-
-		const float labelWidth = 96.0f * m_scale;
-
-		// 五等分子刻度线：在相邻主刻度之间插入 4 条短刻度（更长的主刻度在最前绘制，
-		// 短刻度与主刻度重合的位置跳过），便于目视读取中间时刻。
-		const double minorStep = timeStep / static_cast<double>(kMinorDivisions);
-		std::vector<double> minorTicks;
-		BuildTicks(Tab().ViewMin(), Tab().ViewMax(), minorStep, minorTicks);
-		std::vector<float> minorSegments;
-		std::vector<float> majorSegments;
-		minorSegments.reserve(minorTicks.size() * 4);
-		majorSegments.reserve(timeTicks.size() * 4);
-		for (const double tick : minorTicks)
-		{
-			const double majorIndex = tick / timeStep;
-			if (std::fabs(majorIndex - std::floor(majorIndex + 0.5)) < 1.0e-6)
-			{
-				continue;
-			}
-			const float x = TimeToX(tick);
-			if (x < m_plotRect.X - 1.0f || x > m_plotRect.X + m_plotRect.Width + 1.0f)
-			{
-				continue;
-			}
-			minorSegments.insert(minorSegments.end(), {x, axisY, x, axisY + 3.0f * m_scale});
-		}
-
-		for (const double tick : timeTicks)
-		{
-			const float x = TimeToX(tick);
-			if (x < m_plotRect.X - 1.0f || x > m_plotRect.X + m_plotRect.Width + 1.0f)
-			{
-				continue;
-			}
-			majorSegments.insert(majorSegments.end(), {x, axisY, x, axisY + 4.0f * m_scale});
-		}
-		if (!minorSegments.empty())
-		{
-			UiDrawSolidLines(g, axisClip, minorSegments.data(), minorSegments.size() / 4, axisColor);
-		}
-		if (!majorSegments.empty())
-		{
-			UiDrawSolidLines(g, axisClip, majorSegments.data(), majorSegments.size() / 4, axisColor);
-		}
-
-		for (const double tick : timeTicks)
-		{
-			const float x = TimeToX(tick);
-			if (x < m_plotRect.X - 1.0f || x > m_plotRect.X + m_plotRect.Width + 1.0f)
-			{
-				continue;
-			}
-
-			// 刻度标签夹在绘图区横向范围内，并与左侧列名互不重叠。
-			float labelX = x - labelWidth * 0.5f;
-			labelX = std::max(m_plotRect.X, std::min(labelX, m_plotRect.X + m_plotRect.Width - labelWidth));
-			const gd::RectF labelRect(labelX, axisY + 4.0f * m_scale, labelWidth,
-			                          std::max(0.0f, m_timeAxisRect.Height - 6.0f * m_scale));
-			if (labelRect.X < nameRect.X + nameRect.Width)
-			{
-				continue;
-			}
-			UiText(g, FormatTick(tick, timeStep), m_fonts->monoSmall, labelRect, m_theme->textMuted,
-			       TextAlign::CENTER);
-		}
-	}
-
-
-	void PlotView::DrawLabelOutline(gd::Graphics& g, const gd::RectF& rect, float radius,
-	                                std::uint32_t outlineColor)
-	{
-		// 描边色由 `UiContrastInk` 与文字色一起算出（恒与文字色反相、且随信号配色线性变化）。
-		// 这样胶囊压在同类色背景或信号曲线上时仍有清晰的边界。
-		UiDrawRoundRect(g, rect, radius, outlineColor, 1.0f);
-	}
-
-	gd::RectF PlotView::CursorSpanRect(bool& insideAxis) const
-	{
-		insideAxis = false;
-		if (m_tab == nullptr || Tab().CursorMode() != PlotCursorMode::DOUBLE ||
-		    m_fonts == nullptr || m_fonts->monoSmall == nullptr)
-		{
-			return gd::RectF();
-		}
-
-		const std::wstring text = FormatSpanText(CursorSpan());
-		const float width = std::max(
-		    72.0f * m_scale, UiMeasureTextWidth(m_fonts->monoSmall, text) + 18.0f * m_scale);
-		const float height = 20.0f * m_scale;
-
-		// 水平位置取两条光标时间读数的中点（与它们同一行，位于时间轴上方）。
-		// 注意用"显示横坐标"：光标滞留在可视区外时会被钉在网格边缘，
-		// 此时二者在屏幕上必然很近，差值标签应改放到主时间轴内部。
-		const gd::RectF first = CursorLabelRect(1);
-		const gd::RectF second = CursorLabelRect(2);
-		float center = (CursorDisplayX(1) + CursorDisplayX(2)) * 0.5f;
-		if (first.Width > 0.0f && second.Width > 0.0f)
-		{
-			center = ((first.X + first.Width * 0.5f) + (second.X + second.Width * 0.5f)) * 0.5f;
-		}
-
-		float left = center - width * 0.5f;
-		left = std::max(m_plotRect.X + 2.0f * m_scale,
-		                std::min(left, m_plotRect.X + m_plotRect.Width - width - 2.0f * m_scale));
-
-		// 两条**时间读数标签**之间的净空不足时，同一行放不下第三个标签
-		// → 改放到主时间轴内部（时间轴上方已无空间）。
-		const gd::RectF& leftRect = (first.X <= second.X) ? first : second;
-		const gd::RectF& rightRect = (first.X <= second.X) ? second : first;
-		const float freeStart = leftRect.X + leftRect.Width;
-		const float freeEnd = rightRect.X;
-		const bool fits = (freeStart <= freeEnd) && ((freeEnd - freeStart) >= (width + 2.0f * m_scale));
-
-		// 双光标都滞留在**同一侧**视界之外时，两条时间读数会被钉在同一条边上并叠成两行；
-		// 此时差值标签也跟着它们排成一列（用户要求"垂直排列要对齐"），
-		// 而不是孤零零地留在时间轴上方。
-		const float pinLeftEdge = m_plotRect.X + 1.0f * m_scale;
-		const float pinRightEdge = m_plotRect.X + m_plotRect.Width - 1.0f * m_scale;
-		const bool offLeft1 = CursorX(1) < pinLeftEdge;
-		const bool offRight1 = CursorX(1) > pinRightEdge;
-		const bool offLeft2 = CursorX(2) < pinLeftEdge;
-		const bool offRight2 = CursorX(2) > pinRightEdge;
-		const bool bothOffSameSide = (offLeft1 && offLeft2 && !offRight1 && !offRight2) ||
-		                             (offRight1 && offRight2 && !offLeft1 && !offLeft2);
-
-		if (bothOffSameSide)
-		{
-			// 与两条时间读数同一列、叠在它们下方（更靠下的一行之下）。
-			const float columnLeft = std::max(m_plotRect.X, first.X);
-			const float stackBottom = std::max(first.Y, second.Y) + first.Height + 2.0f * m_scale;
-			insideAxis = true;
-			const float axisHeight = std::max(14.0f * m_scale, m_timeAxisRect.Height - 4.0f * m_scale);
-			return gd::RectF(columnLeft, stackBottom, width, std::min(height, axisHeight));
-		}
-
-		if (!fits)
-		{
-			insideAxis = true;
-			const float top = m_timeAxisRect.Y + 2.0f * m_scale;
-			const float axisHeight = std::max(14.0f * m_scale, m_timeAxisRect.Height - 4.0f * m_scale);
-			return gd::RectF(left, top, width, std::min(height, axisHeight));
-		}
-
-		return gd::RectF(left, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale, width, height);
-	}
-
-	bool PlotView::CursorOffViewSide(int which, bool& offRight) const
-	{
-		offRight = false;
-		if (m_tab == nullptr || !Tab().CursorEnabled())
-		{
-			return false;
-		}
-		const float pinLeft = m_plotRect.X + 1.0f * m_scale;
-		const float pinRight = m_plotRect.X + m_plotRect.Width - 1.0f * m_scale;
-		const float raw = CursorX(which);
-		if (raw < pinLeft)
-		{
-			return true;
-		}
-		if (raw > pinRight)
-		{
-			offRight = true;
-			return true;
-		}
-		return false;
-	}
-
-	void PlotView::PaintCursorOffViewTip(gd::Graphics& g, const gd::RectF& labelRect, bool offRight,
-	                                     std::uint32_t color)
-	{
-		// 三角画在读数胶囊的**外侧**（尖端朝外、指向光标实际所在的那一侧），
-		// 与胶囊之间留出 `kMarkerTriangleGap` 的空白。
-		//
-		// 旧实现把三角压在胶囊**上沿**且水平居中：既没有间隙（看起来像胶囊长了个尖角），
-		// 又与网格内"数据点越界"的画法（左右三角）不统一。现在两处共用同一套画法。
-		const float arm = kMarkerTriangleArm * m_scale;
-		const float depth = kMarkerTriangleDepth * m_scale;
-		const float gap = kMarkerTriangleGap * m_scale;
-		const float centerY = labelRect.Y + labelRect.Height * 0.5f;
-		gd::PointF outer[3];
-		if (offRight)
-		{
-			const float baseX = labelRect.X + labelRect.Width + gap;
-			outer[0] = gd::PointF(baseX, centerY - arm);
-			outer[1] = gd::PointF(baseX, centerY + arm);
-			outer[2] = gd::PointF(baseX + depth, centerY);
-		}
-		else
-		{
-			const float baseX = labelRect.X - gap;
-			outer[0] = gd::PointF(baseX, centerY - arm);
-			outer[1] = gd::PointF(baseX, centerY + arm);
-			outer[2] = gd::PointF(baseX - depth, centerY);
-		}
-		gd::SolidBrush brush(ToGdiColor(color));
-		g.FillPolygon(&brush, outer, 3);
-	}
-
-	void PlotView::PaintCursor(gd::Graphics& g, const std::vector<LaneVisual>& lanes)
-	{
-		if (!Tab().CursorEnabled() || m_tab == nullptr)
-		{
-			return;
-		}
-
-		const bool doubleMode = (Tab().CursorMode() == PlotCursorMode::DOUBLE);
-		const int cursorCount = doubleMode ? 2 : 1;
-
-		// 本次绘制重新统计已占用的取值标注矩形（用于避免多个信号/光标的内容互相覆盖）。
-		// 先把底部的时间读数/差值标签也登记进去：它们在取值标注之后绘制、会盖在上面，
-		// 因此取值标注必须主动避开它们，否则会被遮住半个字。
-		m_cursorLabelRects.clear();
-		for (int which = 1; which <= cursorCount; ++which)
-		{
-			const gd::RectF timeRect = CursorLabelRect(which);
-			if (timeRect.Width > 0.0f)
-			{
-				m_cursorLabelRects.push_back(timeRect);
-			}
-		}
-		if (doubleMode)
-		{
-			bool insideAxis = false;
-			const gd::RectF spanRect = CursorSpanRect(insideAxis);
-			if (spanRect.Width > 0.0f)
-			{
-				m_cursorLabelRects.push_back(spanRect);
-			}
-		}
-
-		// 重叠时把"最近操作过的那条光标"的内容画在上层，因此先画另一条。
-		const int iterations[2] = { (m_activeCursor == 2) ? 1 : 2, (m_activeCursor == 2) ? 2 : 1 };
-
-		// 增量差值**只**显示在"右侧光标"上。右侧 = 时间较大的那条，随拖拽实时变化：
-		// 把右光标拖到左边后，增量会自动改由新的右侧光标显示。
-		const int rightCursor = (Tab().CursorTime() <= Tab().CursorTimeAlt()) ? 2 : 1;
-
-		// ---- 光标竖线 + 顶部把手 ----
-		for (int pass = 0; pass < cursorCount; ++pass)
-		{
-			const int which = doubleMode ? iterations[pass] : 1;
-			const double time = (which == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
-			const float x = TimeToX(time);
-			if (x < m_plotRect.X - 2.0f || x > m_plotRect.X + m_plotRect.Width + 2.0f)
-			{
-				// 光标滞留在可视区外：不画竖线（其取值/时间读数会在下面贴边显示）。
-				continue;
-			}
-
-			const bool hot = (m_hoverCursor == which);
-			const std::uint32_t color = CursorColor();
-			const float lineTop = m_plotRect.Y;
-			const float lineBottom = m_timeAxisRect.Y + m_timeAxisRect.Height;
-			UiDrawLine(g, x, lineTop, x, lineBottom, color, (hot ? 2.0f : 1.4f) * m_scale);
-
-			// 顶部三角把手（两条光标样式一致，靠颜色区分）。
-			const float arm = 5.0f * m_scale;
-			gd::PointF points[3];
-			points[0] = gd::PointF(x - arm, lineTop);
-			points[1] = gd::PointF(x + arm, lineTop);
-			points[2] = gd::PointF(x, lineTop + arm * 1.4f);
-			gd::SolidBrush handle(ToGdiColor(color));
-			g.FillPolygon(&handle, points, 3);
-		}
-
-		// ---- 数据点取值标注 ----
-		for (int pass = 0; pass < cursorCount; ++pass)
-		{
-			const int which = doubleMode ? iterations[pass] : 1;
-			const double time = (which == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
-			const double otherTime = (which == 2) ? Tab().CursorTime() : Tab().CursorTimeAlt();
-			// 只有右侧光标显示增量差值（左光标只显示自身取值）。
-			const bool showDelta = doubleMode && (which == rightCursor);
-
-			// 光标在可视区外时，把标注"钉"在对应的网格边上，保证取值仍然可见。
-			// 具体是否越界（左右/上下）由 MakeDataMarker 逐点判定。
-			const float pinX = CursorDisplayX(which);
-			const float rawX = TimeToX(time);
-
-			for (std::size_t laneIndex = 0; laneIndex < lanes.size(); ++laneIndex)
-			{
-				const LaneVisual& lane = lanes[laneIndex];
-				const float clipTop = std::max(lane.rect.Y, m_plotRect.Y);
-				const float clipBottom =
-				    std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height);
-				if (clipBottom <= clipTop)
-				{
-					continue;
-				}
-
-				for (const SignalRef& ref : m_tab->Lanes()[laneIndex].signals)
-				{
-					const ResolvedSignal resolved = ResolveSignal(ref);
-					if (resolved.data == nullptr || resolved.style == nullptr ||
-					    resolved.axis == nullptr || !resolved.visible)
-					{
-						continue;
-					}
-
-					const bool interpolate = (resolved.style->mode != DrawMode::SCATTER);
-					double value = 0.0;
-					if (!SampleDisplayedSignalAt(*resolved.axis, *resolved.data, *resolved.style, time,
-					                             interpolate, value))
-					{
-						continue;
-					}
-					// 取值读数必须与画出来的波形一致：同样套用系数/绝对值/镜像。
-					value = ApplyDrawTransform(*resolved.style, value);
-
-					const float rawY = ValueToY(value, lane);
-					// 上下越界的数据点不再被丢弃：与左右越界一致，贴边绘制指示方向的三角。
-					// 上边界额外预留光标顶部把手的高度，避免数据点三角压住光标把手。
-					// 非 const：上下越界时下面还要把方向三角与取值标注纵向居中对齐。
-					DataMarker marker =
-					    MakeDataMarker(rawX, rawY, pinX, clipTop, clipBottom, kCursorHandleReserve * m_scale);
-
-					const std::uint32_t signalColor = StyleColor(*resolved.style);
-
-					// 数据点：视界内为圆点，任一方向越界时改为贴边三角。
-					// **先算好取值标注、再画数据点**：上下越界时的方向三角需要与标注
-					// 纵向居中对齐，而标注的位置要经过避让处理才能最终确定。
-					const float radius = 3.4f * m_scale;
-
-					// 取值标注：底色用信号色，文字/描边用随信号配色线性相关的高对比度配色。
-					std::wstring text = FormatValue(value);
-					if (showDelta)
-					{
-						double otherValue = 0.0;
-						if (SampleDisplayedSignalAt(*resolved.axis, *resolved.data, *resolved.style, otherTime,
-					                               interpolate, otherValue))
-						{
-							otherValue = ApplyDrawTransform(*resolved.style, otherValue);
-							const double delta = value - otherValue;
-							// 增量 = 右侧光标取值 − 左侧光标取值，包在圆括号里并按差值显式给出正负号。
-							text += L" (";
-							text += (delta < 0.0) ? L"-" : L"+";
-							text += FormatValue(std::fabs(delta));
-							text += L")";
-						}
-					}
-
-					const float textWidth = UiMeasureTextWidth(m_fonts->monoSmall, text) + 10.0f * m_scale;
-					const float textHeight = 17.0f * m_scale;
-					// 左右越界时三角贴在视界内侧、尖端朝外；数值标注必须放在三角的**内侧**
-					// 并留出 `kMarkerTriangleGap` 的空白，否则三角会像"多出来的一个尖角"
-					// （用户报告的"三角形与数值显示部分没有间隔"）。
-					float labelLeft;
-					if (marker.offLeft)
-					{
-						labelLeft = marker.x + kMarkerTriangleGap * m_scale;
-					}
-					else if (marker.offRight)
-					{
-						labelLeft = marker.x - kMarkerTriangleGap * m_scale - textWidth;
-					}
-					else
-					{
-						labelLeft = pinX + radius + 4.0f * m_scale;
-						if (labelLeft + textWidth > m_plotRect.X + m_plotRect.Width - 2.0f * m_scale)
-						{
-							labelLeft = pinX - radius - 4.0f * m_scale - textWidth;
-						}
-					}
-					labelLeft = std::max(
-					    m_plotRect.X + 2.0f * m_scale,
-					    std::min(labelLeft, m_plotRect.X + m_plotRect.Width - textWidth - 2.0f * m_scale));
-					float labelTop = marker.y - textHeight * 0.5f;
-					labelTop = std::max(clipTop + 1.0f * m_scale,
-					                    std::min(labelTop, clipBottom - textHeight - 1.0f * m_scale));
-					gd::RectF labelRect(labelLeft, labelTop, textWidth, textHeight);
-
-					// 多个信号的取值标注可能落在同一位置（数据点重合或过近）：
-					// 依次向下（再向上）避让已占用的标注，保证不会互相覆盖。
-					PlaceCursorLabel(labelRect, labelTop, textHeight, clipTop, clipBottom);
-
-					// 越界方向三角与最终落位的取值标注纵向居中对齐
-					// （用户明确要求“超过上下视界时三角需要与显示的数值居中对齐”；
-					//   左右越界时同样对齐，避免三角与数值错行、看起来不协调）。
-					if (marker.offUp || marker.offDown || marker.offLeft || marker.offRight)
-					{
-						marker.y = labelRect.Y + labelRect.Height * 0.5f;
-					}
-					PaintDataMarker(g, marker, radius, signalColor, m_theme->cardBg);
-
-					const UiInk ink = UiContrastInk(signalColor);
-					UiFillRoundRect(g, labelRect, 3.0f * m_scale, WithAlpha(signalColor, 0xF0));
-					DrawLabelOutline(g, labelRect, 3.0f * m_scale, ink.outline);
-					UiText(g, text, m_fonts->monoSmall, labelRect, ink.text, TextAlign::CENTER);
-
-					// 「边沿计数（中心轴）」/「均值滤波」/「弱峰调整」开启时，纵向光标还要额外标注
-					// **派生曲线**在该时刻的取值（它不是信号，因此单独标注，不并入上面的取值文案）。
-					// 三条曲线只是曲线来源不同，标注规则完全一致，故共用同一段绘制逻辑。
-					// ⚠️ 曲线只取「可见区间 ∪ 两个光标时刻 ± 保护带」的窗口（与绘制共用缓存），
-					// 因此拖动光标/拖动参数滑块都不会触发整条曲线的重算。
-					const auto paintDerivedCapsule = [&](DerivedCurveKind kind, int points,
-					                                     int iterations, int amountPercent,
-					                                     const std::wstring& suffix)
-					{
-						const int sampleIndex = FindNearestSample(*resolved.axis, time);
-						if (sampleIndex < 0)
-						{
-							return;
-						}
-						const int otherIndex =
-						    showDelta ? FindNearestSample(*resolved.axis, otherTime) : -1;
-						// 本函数**只需要光标所在采样点处的派生取值**（以及双光标另一端的取值），
-						// 因此把请求窗口收窄到「需要的那几个下标」即可，均值滤波半径造成的取值
-						// 依赖由 `CurveSpanFor` 自身的保护带负责覆盖。
-						//
-						// ⚠️ 绝不能把窗口扩成「光标 ↔ 视界边缘」的并集：光标停在视界之外（例如
-						// 平移视界把光标甩到很远，或光标远离当前缩放区间）时会得到一个上千万采样的
-						// 巨大窗口，超过缓存上限后走一次性缓冲 → **每帧重算整段滤波**，
-						// 实测单帧 300ms+（用户报告的"平移/拖动光标异常卡顿"的直接原因）。
-						std::size_t begin = static_cast<std::size_t>(sampleIndex);
-						std::size_t end = begin + 1;
-						if (otherIndex >= 0)
-						{
-							const std::size_t other = static_cast<std::size_t>(otherIndex);
-							begin = std::min(begin, other);
-							end = std::max(end, other + 1);
-						}
-						std::size_t spanBegin = 0;
-						const std::vector<float>* curvePtr =
-						    CurveSpanFor(kind, *resolved.data, points, iterations, amountPercent, begin,
-						                 end, spanBegin, true);
-						if (curvePtr == nullptr)
-						{
-							return;
-						}
-						const auto curveValueAt = [curvePtr, spanBegin](int index) -> double
-						{
-							if (index < 0 || static_cast<std::size_t>(index) < spanBegin ||
-							    (static_cast<std::size_t>(index) - spanBegin) >= curvePtr->size())
-							{
-								return std::numeric_limits<double>::quiet_NaN();
-							}
-							return static_cast<double>((*curvePtr)[static_cast<std::size_t>(index) -
-							                                       spanBegin]);
-						};
-						const double derivedValue = curveValueAt(sampleIndex);
-						if (!std::isfinite(derivedValue))
-						{
-							return;
-						}
-
-						const float rawCenterY = ValueToY(derivedValue, lane);
-						DataMarker centerMarker = MakeDataMarker(
-						    rawX, rawCenterY, pinX, clipTop, clipBottom, kCursorHandleReserve * m_scale);
-						// 派生数据点的配色与原始信号一致（便于一一对应）；
-						// 但**始终按线段模式**绘制（不跟随原信号的散点模式）。
-						const std::uint32_t centerColor = StyleColor(*resolved.style);
-
-						// 取值文本：数值在前，尾缀「（中心轴）/（均值滤波）」；双光标的右侧光标
-						// 还要附上增量，形如「（+0.0008 中心轴）」（参考常规信号的增量显示）。
-						std::wstring centerText = FormatValue(derivedValue);
-						centerText += L"（";
-						if (showDelta)
-						{
-							const double otherDerived = curveValueAt(otherIndex);
-							if (std::isfinite(otherDerived))
-							{
-								const double delta = derivedValue - otherDerived;
-								centerText += (delta < 0.0) ? L"-" : L"+";
-								centerText += FormatValue(std::fabs(delta));
-								centerText += L" ";
-							}
-						}
-						centerText += suffix;
-						centerText += L"）";
-
-						const float centerTextWidth =
-						    UiMeasureTextWidth(m_fonts->monoSmall, centerText) + 10.0f * m_scale;
-						// 与常规取值标注同一规则：左右越界时标注要让开外侧的方向三角。
-						float centerLeft;
-						if (centerMarker.offLeft)
-						{
-							centerLeft = centerMarker.x + kMarkerTriangleGap * m_scale;
-						}
-						else if (centerMarker.offRight)
-						{
-							centerLeft = centerMarker.x - kMarkerTriangleGap * m_scale - centerTextWidth;
-						}
-						else
-						{
-							centerLeft = pinX + radius + 4.0f * m_scale;
-							if (centerLeft + centerTextWidth >
-							    m_plotRect.X + m_plotRect.Width - 2.0f * m_scale)
-							{
-								centerLeft = pinX - radius - 4.0f * m_scale - centerTextWidth;
-							}
-						}
-						centerLeft = std::max(
-						    m_plotRect.X + 2.0f * m_scale,
-						    std::min(centerLeft,
-						             m_plotRect.X + m_plotRect.Width - centerTextWidth - 2.0f * m_scale));
-						float centerTop = centerMarker.y - textHeight * 0.5f;
-						centerTop = std::max(clipTop + 1.0f * m_scale,
-						                     std::min(centerTop, clipBottom - textHeight - 1.0f * m_scale));
-						gd::RectF centerRect(centerLeft, centerTop, centerTextWidth, textHeight);
-						PlaceCursorLabel(centerRect, centerTop, textHeight, clipTop, clipBottom);
-						// 与原始信号同一规则：越界方向三角与取值标注纵向居中对齐。
-						if (centerMarker.offUp || centerMarker.offDown || centerMarker.offLeft ||
-						    centerMarker.offRight)
-						{
-							centerMarker.y = centerRect.Y + centerRect.Height * 0.5f;
-						}
-						PaintDataMarker(g, centerMarker, radius, centerColor, m_theme->cardBg);
-						// 颜色样式与原始信号一致（同底色/同描边/同文字配色）。
-						const UiInk centerInk = UiContrastInk(centerColor);
-						UiFillRoundRect(g, centerRect, 3.0f * m_scale, WithAlpha(centerColor, 0xE0));
-						DrawLabelOutline(g, centerRect, 3.0f * m_scale, centerInk.outline);
-						UiText(g, centerText, m_fonts->monoSmall, centerRect, centerInk.text,
-						       TextAlign::CENTER);
-					};
-
-					if (m_tab->Lanes()[laneIndex].edgeCenter)
-					{
-						// 只标注被勾选（即真正绘制了曲线）的信号。
-						const Lane::EdgeCenterItem* centerItem =
-						    m_tab->Lanes()[laneIndex].FindEdgeCenterItem(ref);
-						if (centerItem != nullptr)
-						{
-							paintDerivedCapsule(DerivedCurveKind::MEAN_FILTER, centerItem->points,
-							                    centerItem->iterations, 0, L"中心轴");
-						}
-					}
-					if (m_tab->Lanes()[laneIndex].meanFilter)
-					{
-						// 只标注被勾选（即真正绘制了预览曲线）的信号。
-						const Lane::MeanFilterItem* meanItem =
-						    m_tab->Lanes()[laneIndex].FindMeanFilterItem(ref);
-						if (meanItem != nullptr)
-						{
-							paintDerivedCapsule(DerivedCurveKind::MEAN_FILTER, meanItem->points,
-							                    meanItem->iterations, 0, L"均值滤波");
-						}
-					}
-					if (m_tab->Lanes()[laneIndex].weakPeak)
-					{
-						// 弱峰调整曲线：同样是只标注被勾选的信号，尾缀为「弱峰调整」。
-						const Lane::WeakPeakItem* boostItem =
-						    m_tab->Lanes()[laneIndex].FindWeakPeakItem(ref);
-						if (boostItem != nullptr)
-						{
-							const int amountPercent =
-							    std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, boostItem->amountPercent));
-							const int iterations = std::max(
-							    kWeakPeakIterationsMin,
-							    std::min(kWeakPeakIterationsMaxLimit, boostItem->iterations));
-							paintDerivedCapsule(DerivedCurveKind::WEAK_PEAK, 0, iterations, amountPercent,
-							                    L"弱峰调整");
-						}
-					}
-				}
-			}
-		}
-
-		// ---- 底部：时间读数 + 双光标差值 ----
-		if (m_editTarget == PlotEditTarget::CURSOR_TIME ||
-		    m_editTarget == PlotEditTarget::CURSOR_SPAN)
-		{
-			PaintEditField(g);
-			return;
-		}
-
-		for (int pass = 0; pass < cursorCount; ++pass)
-		{
-			const int which = doubleMode ? iterations[pass] : 1;
-			const gd::RectF labelRect = CursorLabelRect(which);
-			if (labelRect.Width <= 0.0f)
-			{
-				continue;
-			}
-			const bool highlighted = (m_cursorHover && m_hoverCursor == which);
-			const std::uint32_t color = CursorColor();
-			bool offRight = false;
-			const bool offView = CursorOffViewSide(which, offRight);
-			if (offView)
-			{
-				PaintCursorOffViewTip(g, labelRect, offRight, color);
-			}
-			UiFillRoundRect(g, labelRect, 3.0f * m_scale,
-			                highlighted ? color : WithAlpha(color, 0xE0));
-			const UiInk ink = UiContrastInk(color);
-			DrawLabelOutline(g, labelRect, 3.0f * m_scale, ink.outline);
-			UiText(g, FormatCursorTime(which == 2 ? Tab().CursorTimeAlt() : Tab().CursorTime()),
-			       m_fonts->monoSmall, labelRect, ink.text, TextAlign::CENTER);
-		}
-
-		// 双光标差值：显示在两条时间读数中间（时间轴上方；过近时落到主时间轴上）。
-		if (doubleMode)
-		{
-			bool insideAxis = false;
-			const gd::RectF spanRect = CursorSpanRect(insideAxis);
-			m_cursorSpanRect = spanRect;
-			if (spanRect.Width > 0.0f && spanRect.Height > 0.0f)
-			{
-				// 样式与光标时间读数完全一致（同底色/同描边/同文字配色）。
-				const std::uint32_t color = CursorColor();
-				// 双光标同时越界到同一侧时，差值标签也在视界之外 → 同样画方向三角。
-				bool offRight1 = false, offRight2 = false;
-				const bool off1 = CursorOffViewSide(1, offRight1);
-				const bool off2 = CursorOffViewSide(2, offRight2);
-				if (off1 && off2 && offRight1 == offRight2)
-				{
-					PaintCursorOffViewTip(g, spanRect, offRight1, color);
-				}
-				UiFillRoundRect(g, spanRect, 3.0f * m_scale,
-				                m_spanHover ? color : WithAlpha(color, 0xE0));
-				const UiInk ink = UiContrastInk(color);
-				DrawLabelOutline(g, spanRect, 3.0f * m_scale, ink.outline);
-				UiText(g, FormatSpanText(CursorSpan()), m_fonts->monoSmall, spanRect, ink.text,
-				       TextAlign::CENTER);
-			}
-		}
-		else
-		{
-			m_cursorSpanRect = gd::RectF();
-		}
-	}
-
-	void PlotView::SyncPanelOrder() const
-	{
-		// 收集当前"可见"（已启用且已展开、且网格内有可见信号）的面板集合。
-		std::vector<PanelRef> visible;
-		for (int index = 0; index < static_cast<int>(m_lanes.size()); ++index)
-		{
-			for (int pass = 0; pass < kEdgePanelKindCount; ++pass)
-			{
-				const EdgePanelKind kind = kEdgePanelKinds[pass];
-				if (EdgePanelLayoutFor(index, kind).panel.Width > 0.0f)
-				{
-					PanelRef ref;
-					ref.laneIndex = index;
-					ref.kind = static_cast<int>(kind);
-					visible.push_back(ref);
-				}
-			}
-		}
-		// 保留已有层序（剔除已不可见的），并把**新出现**的面板追加到队尾（= 最上层），
-		// 这样新打开的面板不会被已有面板盖住。
-		std::vector<PanelRef> next;
-		next.reserve(visible.size());
-		for (const PanelRef& existing : m_panelOrder)
-		{
-			for (const PanelRef& candidate : visible)
-			{
-				if (candidate == existing)
-				{
-					next.push_back(existing);
-					break;
-				}
-			}
-		}
-		for (const PanelRef& candidate : visible)
-		{
-			bool present = false;
-			for (const PanelRef& kept : next)
-			{
-				if (kept == candidate)
-				{
-					present = true;
-					break;
-				}
-			}
-			if (!present)
-			{
-				next.push_back(candidate);
-			}
-		}
-		m_panelOrder = std::move(next);
-	}
-
-	void PlotView::BringPanelToFront(int laneIndex, int kind)
-	{
-		SyncPanelOrder();
-		PanelRef target;
-		target.laneIndex = laneIndex;
-		target.kind = kind;
-		for (std::size_t index = 0; index < m_panelOrder.size(); ++index)
-		{
-			if (!(m_panelOrder[index] == target))
-			{
-				continue;
-			}
-			if (index + 1 == m_panelOrder.size())
-			{
-				return;		// 已经在最上层
-			}
-			m_panelOrder.erase(m_panelOrder.begin() + static_cast<std::ptrdiff_t>(index));
-			m_panelOrder.push_back(target);
-			return;
-		}
-	}
-
-	bool PlotView::TopPanelAtPoint(float x, float y, int& laneIndex, int& kind) const
-	{
-		laneIndex = -1;
-		kind = 0;
-		SyncPanelOrder();
-		// `m_panelOrder` 队尾 = 最上层：从后往前找第一个命中的面板。
-		for (std::size_t index = m_panelOrder.size(); index-- > 0;)
-		{
-			const PanelRef& ref = m_panelOrder[index];
-			const EdgePanelLayout layout =
-			    EdgePanelLayoutFor(ref.laneIndex, static_cast<EdgePanelKind>(ref.kind));
-			if (layout.panel.Width <= 0.0f)
-			{
-				continue;
-			}
-			if (UiPointInRect(layout.panel, x, y))
-			{
-				laneIndex = ref.laneIndex;
-				kind = ref.kind;
-				return true;
-			}
-		}
-		return false;
-	}
-
-	PlotView::EdgePanelLayout PlotView::EdgePanelLayoutFor(int laneIndex, EdgePanelKind kind) const
-	{
-		EdgePanelLayout layout;
-		if (m_tab == nullptr || m_fonts == nullptr || laneIndex < 0 ||
-		    laneIndex >= static_cast<int>(m_tab->Lanes().size()) ||
-		    laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return layout;
-		}
-		const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
-		const bool centerAxis = (kind == EdgePanelKind::CENTER);
-		const bool meanFilter = (kind == EdgePanelKind::MEAN);
-		const bool weakPeak = (kind == EdgePanelKind::PEAK);
-		// 「均值滤波」与「弱峰调整」共用同一套「逐条目 + 底部按钮」排布。
-		const bool itemized = (centerAxis || meanFilter || weakPeak);
-		const bool hasButton = (meanFilter || weakPeak);
-		const bool enabled = meanFilter ? lane.meanFilter
-		                                : (weakPeak ? lane.weakPeak
-		                                             : (centerAxis ? lane.edgeCenter : lane.edgeCount));
-		const bool open = meanFilter ? lane.meanFilterPanelOpen
-		                             : (weakPeak ? lane.weakPeakPanelOpen
-		                                          : (centerAxis ? lane.edgeCenterPanelOpen : lane.edgePanelOpen));
-		if (!enabled || !open)
-		{
-			return layout;
-		}
-
-		int rowCount = 0;
-		for (const SignalRef& ref : lane.signals)
-		{
-			const ResolvedSignal resolved = ResolveSignal(ref);
-			if (resolved.data != nullptr && resolved.visible)
-			{
-				++rowCount;
-			}
-		}
-		if (rowCount <= 0)
-		{
-			return layout;
-		}
-		layout.rows = rowCount;
-
-		const float width = EdgePanelWidth(laneIndex, kind);
-		const float titleHeight = kEdgePanelTitleHeight * m_scale;
-		const float rowHeight = kEdgePanelRowHeight * m_scale;
-		const float pad = kEdgePanelPad * m_scale;
-		// 「中心轴边沿计数」「均值滤波」「弱峰调整」共用同一套「逐条目」排布，
-		// 因此不再有独立的底部编辑行；只有「边沿计数」保留两行文本式排版。
-		const float buttonHeight = hasButton ? (kEdgePanelButtonHeight * m_scale) : 0.0f;
-		const float rowsPerSignal = meanFilter ? 1.0f : 2.0f;
-
-		// 逐条目面板：每个条目 = 第一排（信号名 + 复选框）
-		// + 参数部分（**只在该条目被勾选时才占位**，因此面板高度随勾选数量动态变化）：
-		//   * MEAN / CENTER：一行「均值点数 X + 迭代次数 N」输入框（中心轴再多一行统计结果）；
-		//   * PEAK：两行滑块（调整幅度 % / 迭代次数 N），每个信号各有一套自己的参数。
-		const bool itemHasParams = (centerAxis || meanFilter || weakPeak);
-		const float weakPeakSliderRow = kWeakPeakSliderRowHeight * m_scale;
-		float meanRowHeight = 0.0f;
-		float itemsHeight = 0.0f;
-		float height = 0.0f;
-		if (itemized)
-		{
-			meanRowHeight = kEdgePanelMeanRowHeight * m_scale;
-			for (const SignalRef& ref : lane.signals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				if (resolved.data == nullptr || !resolved.visible)
-				{
-					continue;
-				}
-				itemsHeight += meanRowHeight;
-				const bool checked = meanFilter ? lane.MeanFilterEnabled(ref)
-				                                : (weakPeak ? lane.WeakPeakEnabled(ref)
-				                                             : lane.EdgeCenterEnabled(ref));
-				if (checked && itemHasParams)
-				{
-					if (weakPeak)
-					{
-						itemsHeight += weakPeakSliderRow * 2.0f;
-					}
-					else
-					{
-						itemsHeight += (kEdgePanelMeanEditHeight + kEdgePanelMeanRowGap) * m_scale;
-						if (centerAxis)
-						{
-							itemsHeight += kEdgePanelMeanRowHeight * m_scale;
-						}
-					}
-				}
-			}
-			// 底部按钮行：上方与条目之间、下方与面板下边界之间各留一个 `pad`，
-			// 与面板的左右内边距完全一致（原先按钮直接贴着下边框，看起来很不协调）。
-			height = titleHeight + pad + itemsHeight + pad + buttonHeight + (hasButton ? pad : 0.0f);
-		}
-		else
-		{
-			height = titleHeight + pad + static_cast<float>(rowCount) * rowHeight * rowsPerSignal + pad;
-		}
-
-		// 首次使用（位置为负）时自动放到绘图区右侧，并各网格依次错开，避免完全重叠。
-		const double storedX = meanFilter ? lane.meanFilterPanelX
-		                                  : (weakPeak ? lane.weakPeakPanelX
-		                                               : (centerAxis ? lane.edgeCenterPanelX : lane.edgePanelX));
-		const double storedY = meanFilter ? lane.meanFilterPanelY
-		                                  : (weakPeak ? lane.weakPeakPanelY
-		                                               : (centerAxis ? lane.edgeCenterPanelY : lane.edgePanelY));
-		float left = (storedX >= 0.0)
-		                 ? static_cast<float>(storedX)
-		                 : (m_plotRect.X + m_plotRect.Width - width - 16.0f * m_scale);
-		float top = (storedY >= 0.0)
-		                ? static_cast<float>(storedY)
-		                : (m_plotRect.Y + 16.0f * m_scale +
-		                   static_cast<float>(laneIndex) * 28.0f * m_scale);
-
-		// 面板始终限制在绘图区内（用户明确要求"可以在右侧的整个绘制区域拖动"）。
-		left = std::max(m_plotRect.X + 2.0f * m_scale,
-		                std::min(left, m_plotRect.X + m_plotRect.Width - width - 2.0f * m_scale));
-		top = std::max(m_plotRect.Y + 2.0f * m_scale,
-		               std::min(top, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale));
-
-		layout.panel = gd::RectF(left, top, width, height);
-		// 只有标题栏可以拖拽；✕ 位于标题栏右端，命中时优先按“关闭按钮”处理。
-		layout.title = gd::RectF(left, top, width, titleHeight);
-		const float closeSize = titleHeight;
-		layout.close = gd::RectF(left + width - closeSize, top, closeSize, closeSize);
-		if (itemized)
-		{
-			const float buttonRowHeight = kEdgePanelButtonHeight * m_scale;
-			if (hasButton)
-			{
-				// 底部按钮与面板下边界之间留出与左右、与内容相同的 `pad` 间距
-				//（原先按钮行直接贴着下边框，视觉上与其它元素不协调）；
-				// 面板高度已含这份 pad，因此这里只上移按钮行即可。
-				layout.button = gd::RectF(left + pad, top + height - pad - buttonRowHeight,
-				                          std::max(0.0f, width - pad * 2.0f), buttonRowHeight);
-			}
-
-			// 逐信号条目：第一排 = 名称 + 复选框（复选框靠右）；
-			// 参数部分：MEAN / CENTER = 一行两个输入框（中心轴再多一行统计结果）；
-			//           PEAK = 两行滑块（每个信号各有自己的等级与迭代次数）。
-			const float checkSize = kEdgePanelMeanCheckSize * m_scale;
-			const float fieldHeight = kEdgePanelMeanEditHeight * m_scale;
-			const float halfWidth = std::max(40.0f, (width - pad * 2.0f - 8.0f * m_scale) * 0.5f);
-			// 滑块行列宽（与 `EdgePanelWidth` 使用同一组算式，避免布局与宽度计算漂移）。
-			const float weakPeakLabelWidth = WeakPeakLabelColumnWidth(m_fonts->uiSmall);
-			const float weakPeakValueWidth = WeakPeakValueColumnWidth(m_fonts->monoSmall);
-			const float weakPeakResetSize = kWeakPeakResetButtonSize * m_scale;
-			const float weakPeakResetGap = kWeakPeakResetGap * m_scale;
-			const float weakPeakTrackHeight = kWeakPeakTrackHeight * m_scale;
-			const float weakPeakTrackLeft = left + pad + weakPeakLabelWidth + 6.0f * m_scale;
-			const float weakPeakTrackWidth =
-			    std::max(10.0f * m_scale,
-			             (left + width - pad - weakPeakValueWidth - weakPeakResetGap -
-			              weakPeakResetSize - 6.0f * m_scale) -
-			                 weakPeakTrackLeft);
-			float rowY = top + titleHeight + pad;
-			for (const SignalRef& ref : lane.signals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				if (resolved.data == nullptr || !resolved.visible)
-				{
-					continue;
-				}
-
-				layout.rowRefs.push_back(ref);
-				layout.rowChecks.push_back(gd::RectF(
-				    left + width - pad - checkSize, rowY + (meanRowHeight - checkSize) * 0.5f, checkSize,
-				    checkSize));
-				const bool checked = meanFilter ? lane.MeanFilterEnabled(ref)
-				                                : (weakPeak ? lane.WeakPeakEnabled(ref)
-				                                             : lane.EdgeCenterEnabled(ref));
-				if (weakPeak)
-				{
-					// 每个被勾选的信号各有两行滑块：调整幅度（-400% – +400%）与迭代次数（1 … 上限）。
-					if (checked)
-					{
-						const float levelRowTop = rowY + meanRowHeight;
-						const float iterRowTop = levelRowTop + weakPeakSliderRow;
-						const gd::RectF levelTrack(
-						    weakPeakTrackLeft,
-						    levelRowTop + (weakPeakSliderRow - weakPeakTrackHeight) * 0.5f,
-						    weakPeakTrackWidth, weakPeakTrackHeight);
-						const gd::RectF iterTrack(
-						    weakPeakTrackLeft,
-						    iterRowTop + (weakPeakSliderRow - weakPeakTrackHeight) * 0.5f,
-						    weakPeakTrackWidth, weakPeakTrackHeight);
-						layout.rowLevelTracks.push_back(levelTrack);
-						layout.rowLevelValues.push_back(gd::RectF(
-						    levelTrack.X + levelTrack.Width + 6.0f * m_scale, levelRowTop,
-						    weakPeakValueWidth, weakPeakSliderRow));
-						layout.rowIterTracks.push_back(iterTrack);
-						layout.rowIterValues.push_back(gd::RectF(
-						    iterTrack.X + iterTrack.Width + 6.0f * m_scale, iterRowTop,
-						    weakPeakValueWidth, weakPeakSliderRow));
-						// 每行滑块右侧的**复位按钮**（与数值列同一右边界，保证两行上下对齐）。
-						const float resetX = levelTrack.X + levelTrack.Width + 6.0f * m_scale +
-						                     weakPeakValueWidth + weakPeakResetGap;
-						layout.rowLevelResets.push_back(
-						    gd::RectF(resetX, levelRowTop + (weakPeakSliderRow - weakPeakResetSize) * 0.5f,
-						              weakPeakResetSize, weakPeakResetSize));
-						layout.rowIterResets.push_back(
-						    gd::RectF(resetX, iterRowTop + (weakPeakSliderRow - weakPeakResetSize) * 0.5f,
-						              weakPeakResetSize, weakPeakResetSize));
-					}
-					else
-					{
-						layout.rowLevelTracks.push_back(gd::RectF());
-						layout.rowLevelValues.push_back(gd::RectF());
-						layout.rowLevelResets.push_back(gd::RectF());
-						layout.rowIterTracks.push_back(gd::RectF());
-						layout.rowIterValues.push_back(gd::RectF());
-						layout.rowIterResets.push_back(gd::RectF());
-					}
-					layout.rowPoints.push_back(gd::RectF());
-					layout.rowIterations.push_back(gd::RectF());
-					layout.rowStats.push_back(gd::RectF());
-
-					rowY += meanRowHeight;
-					if (checked)
-					{
-						rowY += weakPeakSliderRow * 2.0f;
-					}
-					continue;
-				}
-				if (checked && itemHasParams)
-				{
-					const float editTop = rowY + meanRowHeight;
-					layout.rowPoints.push_back(
-					    gd::RectF(left + pad, editTop, halfWidth, fieldHeight));
-					layout.rowIterations.push_back(
-					    gd::RectF(left + pad + halfWidth + 8.0f * m_scale, editTop, halfWidth, fieldHeight));
-					if (centerAxis)
-					{
-						layout.rowStats.push_back(
-						    gd::RectF(left + pad, editTop + fieldHeight, width - pad * 2.0f,
-						              kEdgePanelMeanRowHeight * m_scale));
-					}
-					else
-					{
-						layout.rowStats.push_back(gd::RectF());
-					}
-				}
-				else
-				{
-					layout.rowPoints.push_back(gd::RectF());
-					layout.rowIterations.push_back(gd::RectF());
-					layout.rowStats.push_back(gd::RectF());
-				}
-
-				rowY += meanRowHeight;
-				if (checked && itemHasParams)
-				{
-					rowY += (kEdgePanelMeanEditHeight + kEdgePanelMeanRowGap) * m_scale;
-					if (centerAxis)
-					{
-						rowY += kEdgePanelMeanRowHeight * m_scale;
-					}
-				}
-			}
-		}
-		return layout;
-	}
-
-	int PlotView::PeakRowIndexOf(const EdgePanelLayout& layout, const SignalRef& ref) const
-	{
-		for (std::size_t index = 0; index < layout.rowRefs.size(); ++index)
-		{
-			if (layout.rowRefs[index] == ref)
-			{
-				return static_cast<int>(index);
-			}
-		}
-		return -1;
-	}
-
-	bool PlotView::IsOnEdgeCursorLine(int x, int y, int& laneIndex) const
-	{
-		laneIndex = -1;
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		const std::vector<Lane>& tabLanes = m_tab->Lanes();
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-		const float tolerance = 5.0f * m_scale;
-
-		for (std::size_t index = 0; index < m_lanes.size() && index < tabLanes.size(); ++index)
-		{
-			if (!tabLanes[index].edgeCount)
-			{
-				continue;
-			}
-			const LaneVisual& visual = m_lanes[index];
-			if (fx < visual.rect.X || fx > visual.rect.X + visual.rect.Width)
-			{
-				continue;
-			}
-			const float clipTop = std::max(visual.rect.Y, m_plotRect.Y);
-			const float clipBottom =
-			    std::min(visual.rect.Y + visual.rect.Height, m_plotRect.Y + m_plotRect.Height);
-			if (clipBottom <= clipTop)
-			{
-				continue;
-			}
-			const float lineY = std::max(
-			    clipTop, std::min(ValueToY(tabLanes[index].edgeValue, visual), clipBottom));
-			if (std::fabs(fy - lineY) <= tolerance)
-			{
-				laneIndex = static_cast<int>(index);
-				return true;
-			}
-		}
-		return false;
-	}
-
-	PlotView::DataMarker PlotView::MakeDataMarker(float rawX, float rawY, float pinX, float clipTop,
-	                                              float clipBottom, float topReserve) const
-	{
-		DataMarker marker;
-		// 形状**只**由“数据点本身是否越出绘制边界”决定：
-		// 旧实现拿“夹取之后”的位置反推越界方向，于是贴近边界、其实仍在视界内的数据点
-		// 也会被误画成三角（用户报告的“数值显示超出边界就改变数据点形状”）。
-		const float left = m_plotRect.X;
-		const float right = m_plotRect.X + m_plotRect.Width;
-		marker.offLeft = (rawX < left);
-		marker.offRight = (rawX > right);
-		marker.offUp = (rawY < clipTop);
-		marker.offDown = (rawY > clipBottom);
-
-		marker.x = pinX;
-		// 左右越界时三角沿水平方向**向外**伸出 `kMarkerTriangleDepth`：
-		// 光标贴边时 pinX 只离边界 1px，若直接把锚点放在那里，三角会有一大半画到
-		// 网格绘制区之外（被裁剪后只看到残缺的一角，描边也随之断开）。
-		// 因此把锚点沿水平方向**向内**推 keepIn，保证三角完整落在绘制区内。
-		const float keepIn = (kMarkerTriangleDepth + 1.0f) * m_scale;
-		if (marker.offLeft)
-		{
-			marker.x = std::max(pinX, left + keepIn);
-		}
-		else if (marker.offRight)
-		{
-			marker.x = std::min(pinX, right - keepIn);
-		}
-
-		if (marker.offUp)
-		{
-			// 上越界：为方向三角与顶部把手预留高度，避免压住把手。
-			marker.y = clipTop + kMarkerEdgeInset * m_scale + topReserve;
-		}
-		else if (marker.offDown)
-		{
-			marker.y = clipBottom - kMarkerEdgeInset * m_scale;
-		}
-		else
-		{
-			// 视界内：保留数据点的真实纵坐标（越界判定已在上面完成，这里夹取只为了让
-			// 圆点整体可见，不会影响形状）。
-			marker.y = std::max(clipTop + kMarkerInsideMargin * m_scale,
-			                    std::min(rawY, clipBottom - kMarkerInsideMargin * m_scale));
-		}
-		return marker;
-	}
-
-	void PlotView::PaintDataMarker(gd::Graphics& g, const DataMarker& marker, float radius,
-	                               std::uint32_t fillColor, std::uint32_t ringColor) const
-	{
-		gd::SolidBrush ring(ToGdiColor(ringColor));
-		gd::SolidBrush fill(ToGdiColor(fillColor));
-		const float arm = kMarkerTriangleArm * m_scale;		/**< 三角“半宽/半高”（垂直于朝向的半边长）。 */
-		const float depth = kMarkerTriangleDepth * m_scale;	/**< 三角沿朝向的深度（与光标把手同比例）。 */
-
-		// 越界三角：**尖端朝外**（指向数据点所在的方向，即视界之外），底边在网格内侧；
-		// 三角外接矩形在横/纵两个方向都与锚点**居中**（上下越界时因此与取值标注纵向居中）。
-		// 旧实现方向是反的（上越界画下三角、左越界画右三角），而且内三角按“平移”而非
-		// “向质心收缩”构造，填充色会从三角尖端戳出来。
-		const auto paintTriangle = [&](const gd::PointF* outer)
-		{
-			g.FillPolygon(&ring, outer, 3);
-			const float centerX = (outer[0].X + outer[1].X + outer[2].X) / 3.0f;
-			const float centerY = (outer[0].Y + outer[1].Y + outer[2].Y) / 3.0f;
-			// 按质心等比收缩得到内三角：几何上恒在外三角内部，描边宽度也就均匀了。
-			const float shrink = 0.58f;
-			gd::PointF inner[3];
-			for (int index = 0; index < 3; ++index)
-			{
-				inner[index] = gd::PointF(centerX + (outer[index].X - centerX) * shrink,
-				                          centerY + (outer[index].Y - centerY) * shrink);
-			}
-			g.FillPolygon(&fill, inner, 3);
-		};
-
-		// 左右越界：三角指向左/右（视界之外）。
-		if (marker.offLeft || marker.offRight)
-		{
-			const bool offLeft = marker.offLeft;
-			const float tipX = offLeft ? (marker.x - depth) : (marker.x + depth);
-			const float baseX = marker.x;
-			gd::PointF outer[3];
-			outer[0] = gd::PointF(baseX, marker.y - arm);
-			outer[1] = gd::PointF(baseX, marker.y + arm);
-			outer[2] = gd::PointF(tipX, marker.y);
-			paintTriangle(outer);
-			return;
-		}
-
-		// 上下越界：三角指向上/下（视界之外），外接矩形以 marker.y 为纵向中心
-		// → 与取值标注的纵向中心对齐。
-		if (marker.offUp || marker.offDown)
-		{
-			const bool offUp = marker.offUp;
-			const float half = depth * 0.5f;
-			const float tipY = offUp ? (marker.y - half) : (marker.y + half);
-			const float baseY = offUp ? (marker.y + half) : (marker.y - half);
-			gd::PointF outer[3];
-			outer[0] = gd::PointF(marker.x - arm, baseY);
-			outer[1] = gd::PointF(marker.x + arm, baseY);
-			outer[2] = gd::PointF(marker.x, tipY);
-			paintTriangle(outer);
-			return;
-		}
-
-		// 视界内：常规圆点。
-		g.FillEllipse(&ring, marker.x - radius - 1.2f * m_scale, marker.y - radius - 1.2f * m_scale,
-		              (radius + 1.2f * m_scale) * 2.0f, (radius + 1.2f * m_scale) * 2.0f);
-		g.FillEllipse(&fill, marker.x - radius, marker.y - radius, radius * 2.0f, radius * 2.0f);
-	}
-
-	void PlotView::PlaceCursorLabel(gd::RectF& rect, float preferredTop, float textHeight,
-	                                float clipTop, float clipBottom)
-	{
-		const float gap = 2.0f * m_scale;
-		const float minTop = clipTop + 1.0f * m_scale;
-		const float maxTop = std::max(minTop, clipBottom - textHeight - 1.0f * m_scale);
-		rect.Y = std::max(minTop, std::min(preferredTop, maxTop));
-
-		const auto overlaps = [this](const gd::RectF& candidate, const gd::RectF*& hit) -> bool
-		{
-			for (const gd::RectF& occupied : m_cursorLabelRects)
-			{
-				if (candidate.IntersectsWith(occupied))
-				{
-					hit = &occupied;
-					return true;
-				}
-			}
-			return false;
-		};
-
-		bool resolved = false;
-		for (int step = 0; step < 16; ++step)
-		{
-			const gd::RectF* hit = nullptr;
-			if (!overlaps(rect, hit))
-			{
-				resolved = true;
-				break;
-			}
-			// 向下推一格；超出网格底部则改由原始位置向上避让。
-			const float next = hit->Y + hit->Height + gap;
-			if (next > maxTop)
-			{
-				break;
-			}
-			rect.Y = next;
-		}
-		if (!resolved)
-		{
-			rect.Y = std::max(minTop, std::min(preferredTop, maxTop));
-			for (int step = 0; step < 16; ++step)
-			{
-				const gd::RectF* hit = nullptr;
-				if (!overlaps(rect, hit))
-				{
-					break;
-				}
-				rect.Y = hit->Y - rect.Height - gap;
-				if (rect.Y < minTop)
-				{
-					break;
-				}
-			}
-		}
-		rect.Y = std::max(minTop, std::min(rect.Y, maxTop));
-		m_cursorLabelRects.push_back(rect);
-	}
-
-	void PlotView::PaintDerivedCurve(gd::Graphics& g, const ResolvedSignal& resolved,
-	                                 const LaneVisual& lane, const std::vector<float>& curve,
-	                                 std::size_t curveBegin) const
-	{
-		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
-		{
-			return;
-		}
-
-		const std::vector<double>& time = resolved.axis->time;
-		const std::size_t count = std::min(time.size(), resolved.data->values.size());
-		if (count == 0 || m_plotRect.Width <= 1.0f || curve.empty())
-		{
-			return;
-		}
-
-		std::size_t begin = 0;
-		std::size_t end = 0;
-		VisibleIndexRange(*resolved.axis, count, begin, end, resolved.style->offsetTime);
-		if (end <= begin)
-		{
-			return;
-		}
-
-		const std::size_t visibleCount = end - begin;
-		const float limitTop = lane.rect.Y - lane.rect.Height * 4.0f;
-		const float limitBottom = lane.rect.Y + lane.rect.Height * 5.0f;
-
-		// 派生曲线的颜色：与原信号**同色相**但大幅拉开明度，使其与原始波形形成高对比
-		// （原信号改颜色时曲线随之改变，因为它是从信号色派生出来的）；透明度与原信号一致。
-		const unsigned int baseAlpha = static_cast<unsigned int>(
-		    std::max(0.0, std::min(1.0, static_cast<double>(resolved.style->opacity))) * 255.0 + 0.5);
-		const std::uint32_t derived = WithAlpha(HighContrastDerived(StyleColor(*resolved.style)),
-		                                        baseAlpha);
-
-		// 顶点预算与波形一致（每像素列两个顶点）。
-		// 交互期间进一步降到 1/2：派生曲线往往有 10 条（5 网格 × 均值滤波 + 弱峰调整），
-		// 顶点数就是绘制耗时；降低密度能让拖动参数滑块保持流畅，
-		// 松手后下一帧立刻恢复全密度（用户要求的"低分辨率 → 高分辨率"）。
-		std::size_t budget =
-		    static_cast<std::size_t>(std::max(1.0f, m_plotRect.Width)) * kPolylinePointsPerPixel;
-		budget = std::max(budget, kMinPolylinePoints);
-		budget = std::min(budget, kMaxPolylinePoints);
-		if (m_fastFrame)
-		{
-			budget = std::max<std::size_t>(kMinPolylinePoints, budget / 2);
-		}
-		const std::size_t stride = std::max<std::size_t>(1, visibleCount / std::max<std::size_t>(1, budget));
-
-		std::vector<gd::PointF> points;
-		std::vector<std::size_t> breaks;
-		points.reserve(std::min<std::size_t>(visibleCount, budget) + 1);
-		bool inSegment = false;
-		// 「陡峭段」计数：用于判断抗锯齿是否值得付出（见下）。
-		std::size_t tallSegments = 0;
-		std::size_t totalSegments = 0;
-
-		for (std::size_t index = begin; index < end; index += stride)
-		{
-			// 水平镜像 = 数据反序：遍历下标映射到源下标后再取曲线值。
-			const std::size_t sourceIndex = SourceIndexFor(*resolved.style, count, index);
-			if (sourceIndex < curveBegin || (sourceIndex - curveBegin) >= curve.size())
-			{
-				inSegment = false;
-				continue;
-			}
-			const float sampled = curve[sourceIndex - curveBegin];
-			if (!std::isfinite(sampled))
-			{
-				inSegment = false;
-				continue;
-			}
-			float y = ValueToY(ApplyDrawTransform(*resolved.style, static_cast<double>(sampled)), lane);
-			y = static_cast<float>(ClampDouble(y, limitTop, limitBottom));
-			// 时间偏移：该采样画在 `t + offsetTime` 处。
-			const float x = TimeToX(time[index] + resolved.style->offsetTime);
-			if (!inSegment)
-			{
-				breaks.push_back(points.size());
-				points.push_back(gd::PointF(x, y));
-				inSegment = true;
-			}
-			else
-			{
-				if (std::fabs(y - points.back().Y) > lane.rect.Height * 0.5f)
-				{
-					++tallSegments;
-				}
-				++totalSegments;
-				points.push_back(gd::PointF(x, y));
-			}
-		}
-
-		if (breaks.empty())
-		{
-			return;
-		}
-
-		// 派生曲线**恢复为抗锯齿折线**（与"之前"的显示效果一致）。
-		// 但抗锯齿在"陡峭段很多"的形状上代价极高（实测 2448 顶点 26~37ms，无抗锯齿仅 3.5ms），
-		// 而那种形状下抗锯齿的平滑作用几乎看不出来 —— 因此：
-		//   * ⚠️ **不再因交互（`m_fastFrame`）关闭抗锯齿**：波形基底（图层）始终是全质量抗锯齿，
-		//     若预览曲线在交互期间改成无抗锯齿，就会"比普通信号粗糙"（用户报告的观感下降）；
-		//     预览曲线只是叠加层，抗锯齿的代价与它自身的顶点数成正比（可见区间很小），可以承受。
-		//   * 陡峭段占比过高时（方波/编码器这类信号）仍关闭：那种形态下观感几乎无差别。
-		const bool spiky = (totalSegments > 0) && (tallSegments * 8 > totalSegments);
-		const int savedSmoothing = g.GetSmoothingMode();
-		if (spiky)
-		{
-			g.SetSmoothingMode(gd::SmoothingModeNone);
-		}
-		gd::Pen pen(ToGdiColor(derived), std::max(1.0f, resolved.style->lineWidth) * m_scale);
-		pen.SetLineJoin(gd::LineJoinRound);
-		pen.SetStartCap(gd::LineCapRound);
-		pen.SetEndCap(gd::LineCapRound);
-		for (std::size_t k = 0; k < breaks.size(); ++k)
-		{
-			const std::size_t start = breaks[k];
-			const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
-			if (stop <= start + 1)
-			{
-				continue;
-			}
-			g.DrawLines(&pen, points.data() + start, static_cast<INT>(stop - start));
-		}
-		g.SetSmoothingMode(static_cast<gd::SmoothingMode>(savedSmoothing));
-	}
-
-	void PlotView::PaintMeanFilterCurve(gd::Graphics& g, const ResolvedSignal& resolved,
-	                                    const LaneVisual& lane, int points, int iterations) const
-	{
-		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
-		{
-			return;
-		}
-		// 只取「可见区间 ± 保护带」的窗口（见 `CurveSpanFor`）：拖参数滑块不会重算整条曲线。
-		// 与「边沿计数（中心轴）」共用同一段绘制逻辑
-		//（同色相高对比度的派生配色 + 同透明度），只是曲线本身按多次迭代滤波计算。
-		const std::size_t count = std::min(resolved.axis->time.size(), resolved.data->values.size());
-		if (count == 0)
-		{
-			return;
-		}
-		// ⭐ 预览曲线一律按**整条信号**计算（`[0, count]`），与「构建为新信号」使用的
-		// `ComputeMovingAverageIterated(整段 values, ...)` 完全相同，因此预览与构建结果
-		// **逐位一致**（用户明确要求"预览显示效果要和构建为新信号一致"）。
-		// 整段窗口超过异步门槛时由后台线程计算，绘制线程本帧用已算好的旧曲线顶替，
-		// 因此不会阻塞交互；小信号同步计算。
-		std::size_t spanBegin = 0;
-		const std::vector<float>* curve = CurveSpanFor(DerivedCurveKind::MEAN_FILTER, *resolved.data,
-		                                              points, iterations, 0, 0, count, spanBegin, true);
-		if (curve == nullptr)
-		{
-			return;
-		}
-		PaintDerivedCurve(g, resolved, lane, *curve, spanBegin);
-	}
-
-	void PlotView::PaintWeakPeakCurve(gd::Graphics& g, const ResolvedSignal& resolved,
-	                                   const LaneVisual& lane, int amountPercent, int iterations) const
-	{
-		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
-		{
-			return;
-		}
-		const std::size_t count = std::min(resolved.axis->time.size(), resolved.data->values.size());
-		if (count == 0)
-		{
-			return;
-		}
-		// 预览曲线一律按**整条信号**计算（与「构建为新信号」逐位一致），详见 `PaintMeanFilterCurve`。
-		std::size_t spanBegin = 0;
-		const std::vector<float>* curve = CurveSpanFor(DerivedCurveKind::WEAK_PEAK, *resolved.data, 0,
-		                                              iterations, amountPercent, 0, count, spanBegin,
-		                                              true);
-		if (curve == nullptr)
-		{
-			return;
-		}
-		// 派生曲线一律使用同一段绘制逻辑与配色规则（弱峰调整曲线同样如此）。
-		PaintDerivedCurve(g, resolved, lane, *curve, spanBegin);
-	}
-
-	namespace
-	{
-		/** @brief FNV-1a 混合（面板像素缓存键共用）。 */
-		inline void MixPanelKey(std::uint64_t& hash, std::uint64_t value)
-		{
-			hash ^= value;
-			hash *= 1099511628211ull;
-		}
-	} // namespace
-
-	bool PlotView::EnsurePanelCache()
-	{
-		// 图层只需覆盖绘图区（面板一律被夹在 m_plotRect 内），且**原点必须与客户区一致**：
-		// 面板绘制代码用的是客户区绝对坐标，而 `UiText` 走 GDI（不受 GDI+ 变换影响），
-		// 因此不能靠平移变换把坐标搬进一张小位图里。
-		const int width = static_cast<int>(std::ceil(m_area.X + m_area.Width));
-		const int height = static_cast<int>(std::ceil(m_area.Y + m_area.Height));
-		if (width <= 0 || height <= 0)
-		{
-			return false;
-		}
-		if (m_panelDc != nullptr && m_panelWidth == width && m_panelHeight == height)
-		{
-			return true;
-		}
-
-		ReleasePanelCache();
-
-		HDC screen = GetDC(nullptr);
-		if (screen == nullptr)
-		{
-			return false;
-		}
-		m_panelDc = CreateCompatibleDC(screen);
-		m_panelBitmap = CreateCompatibleBitmap(screen, width, height);
-		ReleaseDC(nullptr, screen);
-		if (m_panelDc == nullptr || m_panelBitmap == nullptr)
-		{
-			ReleasePanelCache();
-			return false;
-		}
-		m_panelOldBitmap = SelectObject(m_panelDc, m_panelBitmap);
-		m_panelWidth = width;
-		m_panelHeight = height;
-		m_panelValid = false;
-		return true;
-	}
-
-	void PlotView::ReleasePanelCache()
-	{
-		m_panelValid = false;
-		m_panelSlots.clear();
-		if (m_panelDc != nullptr)
-		{
-			if (m_panelOldBitmap != nullptr)
-			{
-				SelectObject(m_panelDc, m_panelOldBitmap);
-				m_panelOldBitmap = nullptr;
-			}
-			DeleteDC(m_panelDc);
-			m_panelDc = nullptr;
-		}
-		if (m_panelBitmap != nullptr)
-		{
-			DeleteObject(m_panelBitmap);
-			m_panelBitmap = nullptr;
-		}
-		m_panelWidth = 0;
-		m_panelHeight = 0;
-	}
-
-	bool PlotView::PanelRectInsideLayer(const gd::RectF& rect) const
-	{
-		if (m_panelDc == nullptr)
-		{
-			return false;
-		}
-		return rect.X >= 0.0f && rect.Y >= 0.0f &&
-		       rect.X + rect.Width <= static_cast<float>(m_panelWidth) &&
-		       rect.Y + rect.Height <= static_cast<float>(m_panelHeight);
-	}
-
-	std::uint64_t PlotView::PanelGlobalKey() const
-	{
-		std::uint64_t hash = 1469598103934665603ull;
-		const auto mix = [&hash](std::uint64_t value) { MixPanelKey(hash, value); };
-		const auto mixFloat = [&mix](float value)
-		{
-			std::uint32_t bits = 0;
-			std::memcpy(&bits, &value, sizeof(bits));
-			mix(bits);
-		};
-		const auto mixDouble = [&mix](double value)
-		{
-			std::uint64_t bits = 0;
-			std::memcpy(&bits, &value, sizeof(bits));
-			mix(bits);
-		};
-		const auto mixRect = [&mixFloat](const gd::RectF& rect)
-		{
-			mixFloat(rect.X);
-			mixFloat(rect.Y);
-			mixFloat(rect.Width);
-			mixFloat(rect.Height);
-		};
-		const auto mixRef = [&mix](const SignalRef& ref)
-		{
-			mix(ref.IsValid() ? 1ull : 0ull);
-			mix(static_cast<std::uint64_t>(ref.groupIndex));
-			mix(static_cast<std::uint64_t>(ref.signalIndex));
-		};
-
-		mixFloat(m_scale);
-		mix(reinterpret_cast<std::uintptr_t>(m_theme));
-		mix(reinterpret_cast<std::uintptr_t>(m_fonts));
-		mixRect(m_plotRect);
-		mixRect(m_area);
-		mix(static_cast<std::uint64_t>(m_dragMode));
-		mix(static_cast<std::uint64_t>(m_laneDragFrom + 2));
-		mix(static_cast<std::uint64_t>(m_laneDragTarget + 2));
-		mix(static_cast<std::uint64_t>(m_laneDragMouseY + 4096));
-		mix(static_cast<std::uint64_t>(m_hoverLane + 2));
-		mix(m_cursorHover ? 1ull : 0ull);
-		mix(static_cast<std::uint64_t>(m_hoverCursor + 2));
-		mix(static_cast<std::uint64_t>(m_activeCursor));
-		mix(m_dragMoved ? 1ull : 0ull);
-		mixRect(m_rubberRect);
-		mixRef(m_hoverSignal);
-		mixRef(m_hoverLegend);
-		mixRef(m_dragSignal);
-		mixRef(SelectedRef());
-		mix(static_cast<std::uint64_t>(m_edgePanelDragLane + 2));
-		mix(static_cast<std::uint64_t>(m_edgePanelDragKind));
-
-		// 时间光标与统计区间：面板标题的时间后缀、以及「中心轴」行的上升/下降沿数字都依赖它们。
-		mix(static_cast<std::uint64_t>(Tab().CursorMode()));
-		mixDouble(Tab().CursorTime());
-		mixDouble(Tab().CursorTimeAlt());
-		mix(EdgeRangeActive() ? 1ull : 0ull);
-		mixDouble(EdgeRangeMin());
-		mixDouble(EdgeRangeMax());
-
-		// 跟随鼠标的叠加层（悬停光晕 / 图例半高亮 / 信号拖拽虚影 / 提示动画）位置随时在变：
-		// 只要它存在，就把所有面板缓存作废，避免它的残影被一起缓存进面板像素。
-		const bool mouseDrivenOverlay =
-		    m_hoverSignal.IsValid() || m_hoverLegend.IsValid() ||
-		    m_dragMode == PlotDragMode::MOVE_SIGNAL || m_dragMode == PlotDragMode::RUBBER_SELECT ||
-		    HintNeedsAnimation();
-		mix(mouseDrivenOverlay ? 1ull : 0ull);
-		if (mouseDrivenOverlay)
-		{
-			mix(static_cast<std::uint64_t>(m_mouseX + 4096));
-			mix(static_cast<std::uint64_t>(m_mouseY + 4096));
-		}
-
-		for (const LaneVisual& visual : m_lanes)
-		{
-			mixRect(visual.rect);
-			// ⚠️ **幅值范围（yMin/yMax）刻意不入面板指纹**：面板内容（标题、条目、滑块、
-			// 参数与边沿统计）都不依赖网格的幅值区间；而「拖拽平移的纵向分量」会每帧小幅
-			// 改动它 —— 一旦计入，拖拽期间**全部**悬浮面板都会每帧重画一遍
-			//（实测 20 个面板：竖向拖拽 167ms/帧 vs 横向 38ms/帧，正是用户报告的
-			//  "左右流畅、上下/斜向卡顿"）。代价只是面板不透明底（95.7%）背后那 4%
-			// 透出的底层像素可能旧一帧，与既有取舍一致（实测最大色差 ≤ 29 级）。
-		}
-
-		if (m_tab != nullptr)
-		{
-			const std::vector<Lane>& lanes = m_tab->Lanes();
-			for (const Lane& lane : lanes)
-			{
-				mixFloat(static_cast<float>(lane.edgePanelX));
-				mixFloat(static_cast<float>(lane.edgePanelY));
-				mixFloat(static_cast<float>(lane.edgeCenterPanelX));
-				mixFloat(static_cast<float>(lane.edgeCenterPanelY));
-				mixFloat(static_cast<float>(lane.meanFilterPanelX));
-				mixFloat(static_cast<float>(lane.meanFilterPanelY));
-				mixFloat(static_cast<float>(lane.weakPeakPanelX));
-				mixFloat(static_cast<float>(lane.weakPeakPanelY));
-				mix(lane.edgePanelOpen ? 1ull : 0ull);
-				mix(lane.edgeCenterPanelOpen ? 1ull : 0ull);
-				mix(lane.meanFilterPanelOpen ? 1ull : 0ull);
-				mix(lane.weakPeakPanelOpen ? 1ull : 0ull);
-				mix(lane.edgeValueValid ? 1ull : 0ull);
-				mixDouble(lane.edgeValue);
-			}
-		}
-
-		// ⚠️ **面板层序也是"全局"状态**：层序变化（点击某个面板把它置顶）会让"谁盖住谁"改变，
-		// 因此必须让所有面板缓存失效、按新层序整层重画（否则贴回的旧像素仍是旧层叠关系）。
-		for (const PanelRef& ref : m_panelOrder)
-		{
-			mix(static_cast<std::uint64_t>(ref.laneIndex + 2));
-			mix(static_cast<std::uint64_t>(ref.kind + 2));
-		}
-		return hash;
-	}
-
-	std::uint64_t PlotView::PanelSlotKey(int laneIndex, EdgePanelKind kind,
-	                                     const EdgePanelLayout& layout) const
-	{
-		std::uint64_t hash = 1469598103934665603ull;
-		const auto mix = [&hash](std::uint64_t value) { MixPanelKey(hash, value); };
-		const auto mixFloat = [&mix](float value)
-		{
-			std::uint32_t bits = 0;
-			std::memcpy(&bits, &value, sizeof(bits));
-			mix(bits);
-		};
-		const auto mixRect = [&mixFloat](const gd::RectF& rect)
-		{
-			mixFloat(rect.X);
-			mixFloat(rect.Y);
-			mixFloat(rect.Width);
-			mixFloat(rect.Height);
-		};
-		mix(static_cast<std::uint64_t>(laneIndex + 2));
-		mix(static_cast<std::uint64_t>(static_cast<int>(kind) + 2));
-		mixRect(layout.panel);
-		mixRect(layout.title);
-		mixRect(layout.close);
-		mixRect(layout.edit);
-		mixRect(layout.button);
-		mix(static_cast<std::uint64_t>(layout.rows));
-		for (const gd::RectF& rect : layout.rowChecks)
-		{
-			mixRect(rect);
-		}
-		for (const gd::RectF& rect : layout.rowPoints)
-		{
-			mixRect(rect);
-		}
-		for (const gd::RectF& rect : layout.rowIterations)
-		{
-			mixRect(rect);
-		}
-		for (const gd::RectF& rect : layout.rowStats)
-		{
-			mixRect(rect);
-		}
-
-		const Lane& lane = Tab().Lanes()[static_cast<std::size_t>(laneIndex)];
-		for (const SignalRef& ref : layout.rowRefs)
-		{
-			mix(ref.IsValid() ? 1ull : 0ull);
-			mix(static_cast<std::uint64_t>(ref.groupIndex));
-			mix(static_cast<std::uint64_t>(ref.signalIndex));
-			// 勾选状态与参数直接决定行文本与行高。
-			mix(lane.MeanFilterEnabled(ref) ? 1ull : 0ull);
-			mix(lane.EdgeCenterEnabled(ref) ? 1ull : 0ull);
-			mix(lane.WeakPeakEnabled(ref) ? 1ull : 0ull);
-			const Lane::MeanFilterItem* meanItem = lane.FindMeanFilterItem(ref);
-			mix(static_cast<std::uint64_t>(meanItem != nullptr ? meanItem->points + 2 : 0));
-			mix(static_cast<std::uint64_t>(meanItem != nullptr ? meanItem->iterations + 2 : 0));
-			const Lane::EdgeCenterItem* centerItem = lane.FindEdgeCenterItem(ref);
-			mix(static_cast<std::uint64_t>(centerItem != nullptr ? centerItem->points + 2 : 0));
-			mix(static_cast<std::uint64_t>(centerItem != nullptr ? centerItem->iterations + 2 : 0));
-			// 弱峰调整的逐信号参数（调整幅度 % + 迭代次数 + 该信号的滑块上限）直接显示在面板上：
-			// 上限决定迭代次数滑块的圆钮位置，因此也必须参与缓存键。
-			const Lane::WeakPeakItem* peakItem = lane.FindWeakPeakItem(ref);
-			mix(static_cast<std::uint64_t>(peakItem != nullptr ? peakItem->amountPercent + 2 : 0));
-			mix(static_cast<std::uint64_t>(peakItem != nullptr ? peakItem->iterations + 2 : 0));
-			mix(static_cast<std::uint64_t>(peakItem != nullptr ? peakItem->maxIterations + 2 : 0));
-		}
-
-		// ⚠️⚠️ **边沿统计的数字本身就是面板内容，必须进缓存键**（用户报告的缺陷根因）：
-		// 面板像素图层按本键缓存，而界面上的「上升沿 / 下降沿」是**分帧推进**出来的中间结果 ——
-		// 若这些数字不进键，则「统计推进 → 数字变化」不会让键变化 ⇒ 面板一直贴旧像素
-		// ⇒ 用户不动鼠标时统计永远停在“统计中…”或某个中间值，**只有移动鼠标**（改变别的键）
-		// 才会显示出早已算完的正确结果。
-		// ⇒ 把该面板当前要显示的 (上升沿, 下降沿, 是否扫完) 一并 mix 进去：推进会让键变化 ⇒
-		//    面板重绘 ⇒ 显示随进度更新，直到扫完（扫完后数字不再变，重新命中缓存）。
-		if (kind == EdgePanelKind::COUNT)
-		{
-			for (const SignalRef& ref : lane.signals)
-			{
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				if (resolved.data == nullptr || resolved.style == nullptr || resolved.axis == nullptr ||
-				    !resolved.visible)
-				{
-					continue;	// 与绘制时的可见性判定保持一致
-				}
-				std::size_t rising = 0;
-				std::size_t falling = 0;
-				bool complete = true;
-				EdgeCountsFor(*resolved.axis, *resolved.data, *resolved.style, lane.edgeValue,
-				              EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(), rising, falling, complete);
-				mix(static_cast<std::uint64_t>(rising));
-				mix(static_cast<std::uint64_t>(falling));
-				mix(complete ? 1ull : 0ull);
-			}
-		}
-		else if (kind == EdgePanelKind::CENTER)
-		{
-			for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
-			{
-				if (rowIndex >= layout.rowStats.size() || layout.rowStats[rowIndex].Width <= 0.0f)
-				{
-					continue;	// 与绘制时的条件一致：只有这一排才显示统计数字
-				}
-				const SignalRef& ref = layout.rowRefs[rowIndex];
-				const ResolvedSignal resolved = ResolveSignal(ref);
-				const Lane::EdgeCenterItem* item = lane.FindEdgeCenterItem(ref);
-				if (resolved.data == nullptr || resolved.style == nullptr || resolved.axis == nullptr ||
-				    item == nullptr)
-				{
-					continue;
-				}
-				std::size_t rising = 0;
-				std::size_t falling = 0;
-				bool complete = true;
-				EdgeCenterCountsFor(*resolved.axis, *resolved.data, *resolved.style, item->points,
-				                    item->iterations, EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(),
-				                    rising, falling, complete);
-				mix(static_cast<std::uint64_t>(rising));
-				mix(static_cast<std::uint64_t>(falling));
-				mix(complete ? 1ull : 0ull);
-			}
-		}
-
-		// 弱峰调整的滑块行矩形（每信号两行）。
-		for (const gd::RectF& rect : layout.rowLevelTracks)
-		{
-			mixRect(rect);
-		}
-		for (const gd::RectF& rect : layout.rowIterTracks)
-		{
-			mixRect(rect);
-		}
-		for (const gd::RectF& rect : layout.rowIterValues)
-		{
-			mixRect(rect);
-		}
-		// 弱峰调整每行滑块右侧的复位按钮（悬停高亮依赖它的精确矩形）。
-		for (const gd::RectF& rect : layout.rowLevelResets)
-		{
-			mixRect(rect);
-		}
-		for (const gd::RectF& rect : layout.rowIterResets)
-		{
-			mixRect(rect);
-		}
-
-		// 鼠标落在面板内时，✕ / 复选框 / 滑块 / 底部按钮的悬停态都依赖精确坐标。
-		const float margin = 6.0f * m_scale;
-		const gd::RectF hot(layout.panel.X - margin, layout.panel.Y - margin,
-		                    layout.panel.Width + margin * 2.0f,
-		                    layout.panel.Height + margin * 2.0f);
-		if (UiPointInRect(hot, static_cast<float>(m_mouseX), static_cast<float>(m_mouseY)))
-		{
-			mix(static_cast<std::uint64_t>(m_mouseX + 4096));
-			mix(static_cast<std::uint64_t>(m_mouseY + 4096));
-		}
-		return hash;
-	}
-
-	void PlotView::PaintEdgeCursor(gd::Graphics& g, const std::vector<LaneVisual>& lanes)
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-
-		std::vector<Lane>& tabLanes = m_tab->Lanes();
-		const std::size_t count = std::min(lanes.size(), tabLanes.size());
-		const std::uint32_t color = CursorColor();
-		const UiInk ink = UiContrastInk(color);
-
-		// ---- 横向光标（线与两端把手 + 左侧幅值读数）----
-		for (std::size_t index = 0; index < count; ++index)
-		{
-			Lane& tabLane = tabLanes[index];
-			if (!tabLane.edgeCount)
-			{
-				continue;
-			}
-			const LaneVisual& visual = lanes[index];
-			const float clipTop = std::max(visual.rect.Y, m_plotRect.Y);
-			const float clipBottom =
-			    std::min(visual.rect.Y + visual.rect.Height, m_plotRect.Y + m_plotRect.Height);
-			if (clipBottom <= clipTop)
-			{
-				continue;
-			}
-
-			// 首次绘制时把横向光标落在可见幅值范围的中点。
-			if (!tabLane.edgeValueValid)
-			{
-				tabLane.edgeValue = (visual.yMin + visual.yMax) * 0.5;
-				tabLane.edgeValueValid = true;
-			}
-
-			const float lineY =
-			    std::max(clipTop, std::min(ValueToY(tabLane.edgeValue, visual), clipBottom));
-			const float left = visual.rect.X;
-			const float right = visual.rect.X + visual.rect.Width;
-
-			// 横线与纵向光标同色同宽；两端各画一个尖端朝内的三角把手。
-			UiDrawLine(g, left, lineY, right, lineY, color, 1.4f * m_scale);
-			const float arm = 5.0f * m_scale;
-			gd::SolidBrush handle(ToGdiColor(color));
-			gd::PointF leftHandle[3];
-			leftHandle[0] = gd::PointF(left, lineY - arm);
-			leftHandle[1] = gd::PointF(left, lineY + arm);
-			leftHandle[2] = gd::PointF(left + arm * 1.4f, lineY);
-			g.FillPolygon(&handle, leftHandle, 3);
-			gd::PointF rightHandle[3];
-			rightHandle[0] = gd::PointF(right, lineY - arm);
-			rightHandle[1] = gd::PointF(right, lineY + arm);
-			rightHandle[2] = gd::PointF(right - arm * 1.4f, lineY);
-			g.FillPolygon(&handle, rightHandle, 3);
-
-			// 幅值读数：靠网格左侧、纵向居中于横线（与纵向光标的时间读数同款胶囊）。
-			// **必须让开左端的三角把手**（把手横向占 [left, left + arm*1.4]），
-			// 否则数值胶囊会盖住把手（用户明确要求向右挪一些）。
-			const std::wstring text = FormatValue(tabLane.edgeValue);
-			const float textWidth = std::max(
-			    56.0f * m_scale, UiMeasureTextWidth(m_fonts->monoSmall, text) + 16.0f * m_scale);
-			const float textHeight = 18.0f * m_scale;
-			const float labelLeft = left + (arm * 1.4f + 4.0f * m_scale);
-			const float labelTop =
-			    std::max(clipTop + 1.0f * m_scale, std::min(lineY - textHeight * 0.5f,
-			                                                clipBottom - textHeight - 1.0f * m_scale));
-			const gd::RectF labelRect(labelLeft, labelTop, textWidth, textHeight);
-			UiFillRoundRect(g, labelRect, 3.0f * m_scale, WithAlpha(color, 0xE0));
-			DrawLabelOutline(g, labelRect, 3.0f * m_scale, ink.outline);
-			UiText(g, text, m_fonts->monoSmall, labelRect, ink.text, TextAlign::CENTER);
-
-			// 幅值超出视界时（横线被贴边显示），在数值胶囊的**上方/下方**画一个方向三角，
-			// 与常规纵向光标数据点越界的处理方式一致；三角与胶囊**水平居中对齐**。
-			const float rawLineY = ValueToY(tabLane.edgeValue, visual);
-			const bool offUp = (rawLineY < clipTop - 0.5f);
-			const bool offDown = (rawLineY > clipBottom + 0.5f);
-			if (offUp || offDown)
-			{
-				const float tipArm = 5.0f * m_scale;
-				const float depth = tipArm * 1.4f;
-				const float centerX = labelRect.X + labelRect.Width * 0.5f;
-				// 三角整体贴在胶囊外侧（上方越界 → 胶囊上方的向上三角）。
-				const float anchorY = offUp ? (labelRect.Y - depth * 0.5f - 1.0f * m_scale)
-				                            : (labelRect.Y + labelRect.Height + depth * 0.5f + 1.0f * m_scale);
-				gd::PointF outer[3];
-				if (offUp)
-				{
-					outer[0] = gd::PointF(centerX - tipArm, anchorY + depth * 0.5f);
-					outer[1] = gd::PointF(centerX + tipArm, anchorY + depth * 0.5f);
-					outer[2] = gd::PointF(centerX, anchorY - depth * 0.5f);
-				}
-				else
-				{
-					outer[0] = gd::PointF(centerX - tipArm, anchorY - depth * 0.5f);
-					outer[1] = gd::PointF(centerX + tipArm, anchorY - depth * 0.5f);
-					outer[2] = gd::PointF(centerX, anchorY + depth * 0.5f);
-				}
-				gd::SolidBrush tipBrush(ToGdiColor(color));
-				g.FillPolygon(&tipBrush, outer, 3);
-			}
-		}
-
-		// ---- 统计浮动面板（最后绘制，覆盖在波形之上）----
-		// 「边沿计数」「边沿计数（中心轴）」「均值滤波」「弱峰调整」共用同一套样式，
-		// 仅标题、内容行与底部按钮不同。
-		//
-		// 面板是**静态**内容：只有被拖动 / 悬停 / 参数变化的那一个真正重画，
-		// 其余直接贴上一帧缓存好的像素（15 个面板全画一遍实测约 33ms，
-		// 而贴图 <1ms —— 拖动弱峰调整滑块时的主要卡顿就来自这一层）。
-		// 「上升沿 / 下降沿」两列排版（列起点固定 ⇒ 多条信号的文字严格垂直对齐）。
-		// ⚠️ 未完成时**两个数字后面都带 `…`**（旧实现只在整行末尾追加一次，
-		//    视觉上只跟在“下降沿”的数字后面；用户明确要求为“上升沿”也补上这个尾缀）。
-		const auto paintCounts = [this, &g](const gd::RectF& rect, std::size_t rising,
-		                                    std::size_t falling, bool complete)
-		{
-			if (EdgeCountsPending(rising, falling, complete))
-			{
-				UiText(g, L"统计中…", m_fonts->monoSmall, rect, m_theme->textMuted, TextAlign::LEFT);
-				return;
-			}
-			const float gap = kEdgePanelStatColumnGap * m_scale;
-			const float columnWidth = std::max(10.0f, (rect.Width - gap) * 0.5f);
-			UiText(g, EdgeRisingText(rising, complete), m_fonts->monoSmall,
-			       gd::RectF(rect.X, rect.Y, columnWidth, rect.Height), m_theme->textMuted,
-			       TextAlign::LEFT);
-			UiText(g, EdgeFallingText(falling, complete), m_fonts->monoSmall,
-			       gd::RectF(rect.X + columnWidth + gap, rect.Y, columnWidth, rect.Height),
-			       m_theme->textMuted, TextAlign::LEFT);
-		};
-
-		std::vector<PanelSlot> nextSlots;
-		std::vector<gd::RectF> dirtyRects;
-		const std::uint64_t panelGlobalKey = PanelGlobalKey();
-		// 编辑态（输入框 + 插入符）逐个面板变化太细碎，直接整体不缓存。
-		const bool panelCacheReady =
-		    (m_editTarget == PlotEditTarget::NONE) && EnsurePanelCache();
-		const bool panelGlobalSame =
-		    panelCacheReady && m_panelValid && panelGlobalKey == m_panelGlobalKey;
-		// ⚠️ **按层序从下往上绘制**（与命中测试、像素缓存的层叠顺序完全一致）：
-		// `m_panelOrder` 队尾 = 最上层 = 最后绘制。
-		SyncPanelOrder();
-		for (const PanelRef& panelRef : m_panelOrder)
-		{
-			const EdgePanelKind kind = static_cast<EdgePanelKind>(panelRef.kind);
-			const std::size_t index = static_cast<std::size_t>(panelRef.laneIndex);
-			const bool centerAxis = (kind == EdgePanelKind::CENTER);
-			const bool meanFilter = (kind == EdgePanelKind::MEAN);
-			const bool weakPeak = (kind == EdgePanelKind::PEAK);
-			// 「均值滤波」与「弱峰调整」共用「逐条目 + 底部按钮」排布。
-			const bool itemized = (centerAxis || meanFilter || weakPeak);
-			const bool hasButton = (meanFilter || weakPeak);
-			{
-				if (index >= count)
-				{
-					continue;
-				}
-				const Lane& tabLane = tabLanes[index];
-				const EdgePanelLayout layout = EdgePanelLayoutFor(static_cast<int>(index), kind);
-				const gd::RectF& panel = layout.panel;
-				if (panel.Width <= 0.0f || panel.Height <= 0.0f)
-				{
-					continue;
-				}
-
-				// 面板自身的内容指纹；命中缓存时直接贴图，本帧不再重画这个面板。
-				// ⚠️ 缓存像素里含**它与它下面的一切**（面板背后的波形、被它遮住的其他面板），
-				// 因此只要有一个面板重画，所有「在它之后绘制、且与它重叠」的面板也必须重画，
-				// 否则后画者会把旧像素重新盖回去（面板默认位置本来就常常叠在一起）。
-				const float cacheMargin = 4.0f * m_scale;
-				const gd::RectF cachedRect(panel.X - cacheMargin, panel.Y - cacheMargin,
-				                           panel.Width + cacheMargin * 2.0f,
-				                           panel.Height + cacheMargin * 2.0f);
-				bool forcedDirty = false;
-				for (const gd::RectF& dirtyRect : dirtyRects)
-				{
-					if (dirtyRect.IntersectsWith(cachedRect))
-					{
-						forcedDirty = true;
-						break;
-					}
-				}
-
-				std::uint64_t slotKey = 0;
-				const std::size_t slotIndex = nextSlots.size();
-				if (panelCacheReady)
-				{
-					slotKey = PanelSlotKey(static_cast<int>(index), kind, layout);
-					if (panelGlobalSame && !forcedDirty)
-					{
-						const PanelSlot* hit = nullptr;
-						for (const PanelSlot& slot : m_panelSlots)
-						{
-							if (slot.laneIndex == static_cast<int>(index) &&
-							    slot.kind == static_cast<int>(kind))
-							{
-								hit = &slot;
-								break;
-							}
-						}
-						if (hit != nullptr && hit->key != 0 && hit->key == slotKey)
-						{
-							HDC target = g.GetHDC();
-							if (target != nullptr)
-							{
-								BitBlt(target, hit->x0, hit->y0, hit->x1 - hit->x0, hit->y1 - hit->y0,
-								       m_panelDc, hit->x0, hit->y0, SRCCOPY);
-								g.ReleaseHDC(target);
-							}
-							nextSlots.push_back(*hit);
-							continue;
-						}
-					}
-				}
-				nextSlots.push_back(PanelSlot());
-				dirtyRects.push_back(cachedRect);
-
-				const float titleHeight = kEdgePanelTitleHeight * m_scale;
-				const float rowHeight = kEdgePanelRowHeight * m_scale;
-				const float pad = kEdgePanelPad * m_scale;
-
-				// 面板主体 + 标题栏。
-				// 投影响用两张大面积的半透明圆角矩形模拟，代价不低；交互期间（快速帧）省略它，
-				// 让拖动参数滑块时面板重绘不再被投影拖累（松手后的全质量帧会补回投影）。
-				if (!m_fastFrame)
-				{
-					UiFillRoundRect(g, gd::RectF(panel.X + 1.0f * m_scale, panel.Y + 2.0f * m_scale,
-					                             panel.Width, panel.Height),
-					                5.0f * m_scale, 0x14000000u);
-				}
-				UiFillRoundRect(g, panel, 5.0f * m_scale, WithAlpha(m_theme->cardBg, 0xF4));
-				UiDrawRoundRect(g, panel, 5.0f * m_scale, m_theme->borderStrong, 1.0f);
-				UiFillRoundRect(g, gd::RectF(panel.X, panel.Y, panel.Width, titleHeight), 5.0f * m_scale,
-				                WithAlpha(m_theme->accent, 0x2A));
-
-				// 标题：与左侧信号面板一致的 “GX” 徽标。
-				const float badgeWidth = kLaneBadgeWidth * m_scale;
-				const float badgeHeight = kLaneBadgeHeight * m_scale;
-				const gd::RectF badgeRect(panel.X + pad, panel.Y + (titleHeight - badgeHeight) * 0.5f,
-				                          badgeWidth, badgeHeight);
-				UiFillRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->cardBg);
-				UiDrawRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->border, 1.0f);
-				UiText(g, L"G" + std::to_wstring(index + 1), m_fonts->monoSmall, badgeRect,
-				       m_theme->text, TextAlign::CENTER);
-				const std::wstring title =
-				    meanFilter ? std::wstring(L"均值滤波")
-				               : (weakPeak ? std::wstring(kWeakPeakTitle)
-				                            : ((centerAxis ? L"中心轴边沿计数" : L"边沿计数") +
-				                               EdgeRangeSuffix()));
-				UiText(g, title, m_fonts->uiSmall,
-				       gd::RectF(badgeRect.X + badgeRect.Width + 8.0f * m_scale, panel.Y,
-				                 panel.Width - badgeRect.Width - 8.0f * m_scale - titleHeight,
-				                 titleHeight),
-				       m_theme->textStrong, TextAlign::LEFT);
-
-				// 关闭按钮 ✕：悬停时高亮提示（鼠标光标本身不改变样式）。
-				const gd::RectF& closeRect = layout.close;
-				const bool closeHot =
-				    (m_dragMode != PlotDragMode::EDGE_PANEL_MOVE) &&
-				    UiPointInRect(closeRect, static_cast<float>(m_mouseX), static_cast<float>(m_mouseY));
-				if (closeHot)
-				{
-					UiFillRoundRect(g, gd::RectF(closeRect.X + 3.0f * m_scale, closeRect.Y + 3.0f * m_scale,
-					                             closeRect.Width - 6.0f * m_scale,
-					                             closeRect.Height - 6.0f * m_scale),
-					                3.0f * m_scale, WithAlpha(m_theme->danger, 0x33));
-				}
-				const float crossPad = 8.0f * m_scale;
-				const std::uint32_t crossColor = closeHot ? m_theme->danger : m_theme->textMuted;
-				UiDrawLine(g, closeRect.X + crossPad, closeRect.Y + crossPad,
-				           closeRect.X + closeRect.Width - crossPad,
-				           closeRect.Y + closeRect.Height - crossPad, crossColor, 1.6f * m_scale);
-				UiDrawLine(g, closeRect.X + closeRect.Width - crossPad, closeRect.Y + crossPad,
-				           closeRect.X + crossPad, closeRect.Y + closeRect.Height - crossPad, crossColor,
-				           1.6f * m_scale);
-
-				// 「中心轴边沿计数」/「均值滤波」/「弱峰调整」面板都采用「逐条目」排布：
-				// 第一排 = 名称 + 复选框，第二排 = 两个参数输入框（仅勾选的条目，
-				// 弱峰调整没有参数输入框），中心轴再多第三排 = 对应的统计结果。
-				if (itemized)
-				{
-					for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
-					{
-						const SignalRef& ref = layout.rowRefs[rowIndex];
-						const ResolvedSignal resolved = ResolveSignal(ref);
-						if (resolved.data == nullptr || resolved.style == nullptr)
-						{
-							continue;
-						}
-						const std::uint32_t signalColor = StyleColor(*resolved.style);
-						const gd::RectF& checkRect = layout.rowChecks[rowIndex];
-						const bool checked = meanFilter ? tabLane.MeanFilterEnabled(ref)
-						                                : (weakPeak ? tabLane.WeakPeakEnabled(ref)
-						                                             : tabLane.EdgeCenterEnabled(ref));
-
-						// 名称：第一排左侧，避开右侧复选框（超长时省略）。
-						const float nameWidth =
-						    std::min(std::max(20.0f, checkRect.X - (panel.X + pad) - 6.0f * m_scale),
-						             kEdgePanelNameMaxWidth * m_scale);
-						UiText(g, UiEllipsize(resolved.data->name, m_fonts->uiSmall, nameWidth),
-						       m_fonts->uiSmall,
-						       gd::RectF(panel.X + pad, checkRect.Y - 3.0f * m_scale, nameWidth,
-						                 checkRect.Height + 6.0f * m_scale),
-						       signalColor, TextAlign::LEFT);
-						UiDrawCheckBox(g, checkRect, checked ? 1 : 0, 3.0f * m_scale);
-
-						if (!checked)
-						{
-							continue;
-						}
-
-						// MEAN / CENTER 的平滑参数条目（弱峰调整用自己的 `WeakPeakItem`）。
-						const Lane::MeanFilterItem* item =
-						    (meanFilter || centerAxis)
-						        ? (meanFilter ? tabLane.FindMeanFilterItem(ref)
-						                      : tabLane.FindEdgeCenterItem(ref))
-						        : nullptr;
-
-						// 「弱峰调整」：每个被勾选的信号各有两行**滑块**
-						//（调整幅度 -200% – +200% / 迭代次数 1 … 该信号自定义上限）。
-						// 迭代次数行的右侧数值可点击 → 整行变为输入框以修改滑块上限。
-						if (weakPeak)
-						{
-							const Lane::WeakPeakItem* peakItem = tabLane.FindWeakPeakItem(ref);
-							if (peakItem != nullptr && rowIndex < layout.rowLevelTracks.size() &&
-							    layout.rowLevelTracks[rowIndex].Width > 0.0f)
-							{
-								// 两行滑块的「标签」始终绘制（编辑上限时也要能看出在改哪一项）；
-								// 「轨道 + 数值」在编辑上限时改由 `PaintEditField` 画成输入框。
-								const auto paintSliderLabel = [&](const gd::RectF& track,
-								                                  const wchar_t* label)
-								{
-									const float labelColumn =
-									    WeakPeakLabelColumnWidth(m_fonts->uiSmall);
-									const float labelLeft =
-									    track.X - 6.0f * m_scale - labelColumn;
-									UiText(g, label, m_fonts->uiSmall,
-									       gd::RectF(labelLeft, track.Y - 8.0f * m_scale,
-									                 labelColumn, track.Height + 16.0f * m_scale),
-									       m_theme->textMuted, TextAlign::LEFT);
-								};
-								const auto paintSliderBody = [&](const gd::RectF& track, double ratio,
-								                                 const std::wstring& valueText,
-								                                 bool active)
-								{
-									UiDrawSlider(g, track, ratio, m_theme->accent, active, m_scale);
-									UiText(g, valueText, m_fonts->monoSmall,
-									       gd::RectF(track.X + track.Width + 6.0f * m_scale,
-									                 track.Y - 8.0f * m_scale,
-									                 WeakPeakValueColumnWidth(m_fonts->monoSmall),
-									                 track.Height + 16.0f * m_scale),
-									       m_theme->textStrong, TextAlign::LEFT);
-								};
-								// 每行滑块右侧的**复位控件**（与「系数/偏移」二级面板里的还原图标同一套绘制）：
-								// 悬停时高亮 + 手型光标，点击把该行参数恢复为默认值（幅度 0 / 迭代 1 且上限回初始值）。
-								const auto paintSliderReset = [&](const gd::RectF& rect)
-								{
-									if (rect.Width <= 0.0f)
-									{
-										return;
-									}
-									const bool hot =
-									    (m_dragMode != PlotDragMode::EDGE_PANEL_MOVE) &&
-									    UiPointInRect(rect, static_cast<float>(m_mouseX),
-									                  static_cast<float>(m_mouseY));
-									if (hot)
-									{
-										UiFillRoundRect(
-										    g, gd::RectF(rect.X - 1.0f * m_scale, rect.Y - 1.0f * m_scale,
-										                 rect.Width + 2.0f * m_scale,
-										                 rect.Height + 2.0f * m_scale),
-										    3.0f * m_scale, WithAlpha(m_theme->accent, 0x33));
-									}
-									PaintPanelResetIcon(g, rect,
-									                    hot ? m_theme->accent : m_theme->textMuted, m_scale);
-								};
-
-								const gd::RectF& levelTrack = layout.rowLevelTracks[rowIndex];
-								const gd::RectF& iterTrack = layout.rowIterTracks[rowIndex];
-								paintSliderLabel(levelTrack, kWeakPeakLevelLabel);
-								paintSliderLabel(iterTrack, kWeakPeakIterationsSliderLabel);
-
-								const bool levelActive = (m_dragMode == PlotDragMode::PEAK_LEVEL) &&
-								                         (m_peakDragLane == static_cast<int>(index)) &&
-								                         (m_peakDragRef == ref);
-								const double levelRatio =
-								    (static_cast<double>(std::max(kWeakPeakAmountMin,
-								                                 std::min(kWeakPeakAmountMax,
-								                                          peakItem->amountPercent))) /
-								         (100.0 * kWeakPeakSliderScale) +
-								     1.0) *
-								    0.5;
-								paintSliderBody(levelTrack, levelRatio,
-								                (peakItem->amountPercent > 0 ? L"+" : L"") +
-								                    std::to_wstring(peakItem->amountPercent) + L"%",
-								                levelActive);
-								paintSliderReset(layout.rowLevelResets[rowIndex]);
-
-								// 迭代次数滑块：量程 = 1 … 该信号自己的上限。
-								const int peakMax = std::max(kWeakPeakIterationsMin,
-								                             std::min(kWeakPeakIterationsMaxLimit,
-								                                      peakItem->maxIterations));
-								const int peakIter = std::max(
-								    kWeakPeakIterationsMin, std::min(peakMax, peakItem->iterations));
-								const double iterRatio =
-								    (peakMax > kWeakPeakIterationsMin)
-								        ? (static_cast<double>(peakIter - kWeakPeakIterationsMin) /
-								           static_cast<double>(peakMax - kWeakPeakIterationsMin))
-								        : 0.0;
-								const bool iterActive = (m_dragMode == PlotDragMode::PEAK_ITERATIONS) &&
-								                        (m_peakDragLane == static_cast<int>(index)) &&
-								                        (m_peakDragRef == ref);
-								const bool editingMax =
-								    (m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX) &&
-								    (m_editLane == static_cast<int>(index)) && (m_editMeanRef == ref);
-								if (!editingMax)
-								{
-									paintSliderBody(iterTrack, iterRatio, std::to_wstring(peakIter),
-									                iterActive);
-									paintSliderReset(layout.rowIterResets[rowIndex]);
-								}
-							}
-						}
-
-						// MEAN / CENTER：第二排的两个参数输入框。
-						if (!weakPeak)
-						{
-						const int shownPoints = (item != nullptr) ? item->points : 5;
-						const int shownOrder = (item != nullptr) ? item->iterations : 1;
-						const PlotEditTarget pointsTarget =
-						    meanFilter ? PlotEditTarget::MEAN_FILTER_POINTS
-						               : PlotEditTarget::EDGE_CENTER_POINTS;
-						const PlotEditTarget orderTarget =
-						    meanFilter ? PlotEditTarget::MEAN_FILTER_ITERATIONS
-						               : PlotEditTarget::EDGE_CENTER_ITERATIONS;
-						const auto paintField = [&](const gd::RectF& rect, const wchar_t* label,
-						                            int value, PlotEditTarget target)
-						{
-							if (rect.Width <= 0.0f)
-							{
-								return;
-							}
-							const float labelWidth = UiMeasureTextWidth(m_fonts->uiSmall, label);
-							UiText(g, label, m_fonts->uiSmall,
-							       gd::RectF(rect.X, rect.Y, labelWidth, rect.Height), m_theme->textMuted,
-							       TextAlign::LEFT);
-
-							const float fieldWidth =
-							    std::max(kEdgePanelEditFieldWidth * m_scale * 0.75f,
-							             UiMeasureTextWidth(m_fonts->monoSmall, std::to_wstring(value)) +
-							                 18.0f * m_scale);
-							const float fieldLeft = rect.X + rect.Width - fieldWidth;
-							const float fieldHeight = rect.Height - 4.0f * m_scale;
-							const gd::RectF fieldRect(fieldLeft, rect.Y + 2.0f * m_scale, fieldWidth,
-							                          fieldHeight);
-
-							const bool editingThis = (m_editTarget == target) &&
-							                         (m_editLane == static_cast<int>(index)) &&
-							                         (m_editMeanRef == ref);
-							if (editingThis)
-							{
-								UiDrawEditField(g, fieldRect, m_edit, m_fonts->monoSmall, m_scale);
-							}
-							else
-							{
-								UiFillRoundRect(g, fieldRect, 3.0f * m_scale, m_theme->pressed);
-								UiDrawRoundRect(g, fieldRect, 3.0f * m_scale, m_theme->border, 1.0f);
-								UiText(g, std::to_wstring(value), m_fonts->monoSmall, fieldRect,
-								       m_theme->textStrong, TextAlign::CENTER);
-							}
-						};
-						paintField(layout.rowPoints[rowIndex], L"均值点数 X", shownPoints, pointsTarget);
-						paintField(layout.rowIterations[rowIndex], kWeakPeakIterationsLabel, shownOrder,
-						           orderTarget);
-						}
-
-						// 第三排（中心轴）：该信号在当前参数下的上升沿/下降沿统计结果。
-						if (centerAxis && rowIndex < layout.rowStats.size() &&
-						    layout.rowStats[rowIndex].Width > 0.0f)
-						{
-							const gd::RectF& statsRect = layout.rowStats[rowIndex];
-							const int statsPoints = (item != nullptr) ? item->points : 5;
-							const int statsOrder = (item != nullptr) ? item->iterations : 1;
-							std::size_t rising = 0;
-							std::size_t falling = 0;
-							bool statsComplete = false;
-							EdgeCenterCountsFor(*resolved.axis, *resolved.data, *resolved.style,
-							                    statsPoints, statsOrder, EdgeRangeActive(),
-							                    EdgeRangeMin(), EdgeRangeMax(), rising, falling,
-							                    statsComplete);
-							// 两列排版（列起点固定）⇒ 多条信号的“上升沿 / 下降沿”垂直对齐。
-							paintCounts(statsRect, rising, falling, statsComplete);
-						}
-					}
-				}
-
-				float rowY = panel.Y + titleHeight + pad;
-				for (const SignalRef& ref : tabLane.signals)
-				{
-					const ResolvedSignal resolved = ResolveSignal(ref);
-					if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
-					{
-						continue;
-					}
-					if (itemized)
-					{
-						// 逐条目绘制已在上面完成。
-						continue;
-					}
-					const std::uint32_t signalColor = StyleColor(*resolved.style);
-					const float textWidth = panel.Width - pad * 2.0f;
-					// 名称：超长时省略（面板宽度被 `kEdgePanelNameMaxWidth` 限制，不会把面板顶得很长）。
-					UiText(g,
-					       UiEllipsize(resolved.data->name, m_fonts->uiSmall,
-					                   std::min(textWidth, kEdgePanelNameMaxWidth * m_scale)),
-					       m_fonts->uiSmall, gd::RectF(panel.X + pad, rowY, textWidth, rowHeight),
-					       signalColor, TextAlign::LEFT);
-
-					std::size_t rising = 0;
-					std::size_t falling = 0;
-					bool complete = true;
-					EdgeCountsFor(*resolved.axis, *resolved.data, *resolved.style, tabLane.edgeValue,
-					              EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(), rising, falling,
-					              complete);
-					paintCounts(gd::RectF(panel.X + pad, rowY + rowHeight, textWidth, rowHeight), rising,
-					            falling, complete);
-					rowY += rowHeight * 2.0f;
-				}
-
-				// 逐条目面板底部按钮行：「构建为新信号」（悬停高亮）。
-				if (hasButton)
-				{
-					const gd::RectF& buttonRect = layout.button;
-					if (buttonRect.Width > 0.0f)
-					{
-						const gd::RectF inner(buttonRect.X, buttonRect.Y + 2.0f * m_scale,
-						                      buttonRect.Width, buttonRect.Height - 4.0f * m_scale);
-						const bool hot =
-						    (m_dragMode != PlotDragMode::EDGE_PANEL_MOVE) &&
-						    UiPointInRect(inner, static_cast<float>(m_mouseX),
-						                  static_cast<float>(m_mouseY));
-						UiFillRoundRect(g, inner, 4.0f * m_scale,
-						                hot ? WithAlpha(m_theme->accent, 0x3A) : m_theme->cardBg);
-						UiDrawRoundRect(g, inner, 4.0f * m_scale, m_theme->accent, 1.2f);
-						UiText(g, kBuildSignalLabel, m_fonts->uiSmall, inner, m_theme->accent,
-						       TextAlign::CENTER);
-					}
-				}
-
-				// 面板画完了：把它刚画进后备缓冲区的像素（连同缓存键）存进面板图层，
-				// 下一帧只要键不变就直接贴图。矩形外的 4 逻辑像素边距用于容纳投影。
-				PanelSlot& stored = nextSlots[slotIndex];
-				stored.laneIndex = static_cast<int>(index);
-				stored.kind = static_cast<int>(kind);
-				stored.key = 0;
-				if (panelCacheReady && slotKey != 0)
-				{
-					const int x0 = std::max(0, static_cast<int>(std::floor(cachedRect.X)));
-					const int y0 = std::max(0, static_cast<int>(std::floor(cachedRect.Y)));
-					const int x1 = std::max(x0, static_cast<int>(std::ceil(cachedRect.X + cachedRect.Width)));
-					const int y1 = std::max(y0, static_cast<int>(std::ceil(cachedRect.Y + cachedRect.Height)));
-					const gd::RectF layerRect(static_cast<float>(x0), static_cast<float>(y0),
-					                          static_cast<float>(x1 - x0), static_cast<float>(y1 - y0));
-					if (x1 > x0 && y1 > y0 && PanelRectInsideLayer(layerRect))
-					{
-						HDC source = g.GetHDC();
-						if (source != nullptr)
-						{
-							const BOOL ok = BitBlt(m_panelDc, x0, y0, x1 - x0, y1 - y0, source, x0, y0,
-							                       SRCCOPY);
-							g.ReleaseHDC(source);
-							if (ok != FALSE)
-							{
-								stored.key = slotKey;
-								stored.x0 = x0;
-								stored.y0 = y0;
-								stored.x1 = x1;
-								stored.y1 = y1;
-							}
-						}
-					}
-				}
-			}
-		}
-
-		m_panelSlots = std::move(nextSlots);
-		m_panelGlobalKey = panelGlobalKey;
-		m_panelValid = panelCacheReady;
-	}
-
-	void PlotView::PaintEditField(gd::Graphics& g)
-	{
-		const gd::RectF fieldRect = EditFieldRect();
-		if (fieldRect.Width <= 0.0f || fieldRect.Height <= 0.0f)
-		{
-			return;
-		}
-
-		// 编辑态：强调色外框 + 选区高亮 + 插入符，首次键入即整体替换（与常规输入框一致）。
-		UiDrawEditField(g, fieldRect, m_edit, m_fonts->monoSmall, m_scale);
-
-		// 「迭代次数 N 上限」：输入框**以空内容开始**，未输入任何内容时以灰色提示当前上限值。
-		// 提示文案 = “输入上限（当前N）”（用户明确要求：旧实现只显示一个孤立的数字，缺少说明）。
-		if (m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX && m_edit.Text().empty())
-		{
-			const int currentMax = m_peakEditCurrentMax > 0 ? m_peakEditCurrentMax
-			                                                : kWeakPeakIterationsDefaultMax;
-			const std::wstring hint = L"输入上限（当前" + std::to_wstring(currentMax) + L"）";
-			const float hintLeft = fieldRect.X + 11.0f * m_scale;
-			UiTextAtClipped(g, hint, m_fonts->monoSmall, hintLeft,
-			                gd::RectF(hintLeft, fieldRect.Y,
-			                          std::max(0.0f, fieldRect.X + fieldRect.Width -
-			                                             hintLeft - 4.0f * m_scale),
-			                          fieldRect.Height),
-			                m_theme->textMuted, fieldRect);
-		}
-	}
-
-	void PlotView::PaintSignalInteraction(gd::Graphics& g)
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr || m_lanes.empty())
-		{
-			return;
-		}
-
-		// 拖拽中：虚影跟随鼠标纵向位移，同时在目标网格内高亮落点。
-		if (m_dragMode == PlotDragMode::MOVE_SIGNAL && m_dragSignal.IsValid())
-		{
-			const ResolvedSignal resolved = ResolveSignal(m_dragSignal);
-			const int sourceLane = m_tab->LaneOfSignal(m_dragSignal);
-			if (resolved.data == nullptr || resolved.style == nullptr || sourceLane < 0 ||
-			    sourceLane >= static_cast<int>(m_lanes.size()))
-			{
-				return;
-			}
-
-			// 虚影：以源网格的幅值映射构建波形，再按鼠标位移整体平移。
-			// 第一帧位移为 0，因此虚影必然精确落在鼠标下方（曲线形态与抓住时完全一致）；
-			// 之后纵向与横向均自由跟随，形成“拖着曲线走”的观感。
-			const LaneVisual& sourceVisual = m_lanes[static_cast<std::size_t>(sourceLane)];
-			const float offsetX = static_cast<float>(m_dragMouseX - m_dragStartX);
-			const float offsetY = static_cast<float>(m_dragMouseY - m_dragStartY);
-
-			{
-				const int saveState = g.Save();
-				g.SetClip(gd::RectF(m_plotRect.X, m_plotRect.Y, m_plotRect.Width, m_plotRect.Height),
-				          gd::CombineModeIntersect);
-
-				// 虚影的几何与源网格里的信号完全一致，直接复用折线顶点缓存，
-				// 再用平移变换让整体跟随鼠标：避免每帧重新构建并逐点搬运上万顶点。
-				const PolylineCacheEntry* ghostSource = AcquirePolyline(m_dragSignal, resolved, sourceVisual);
-				if (ghostSource == nullptr)
-				{
-					g.Restore(saveState);
-					return;
-				}
-				const std::vector<gd::PointF>& points = ghostSource->points;
-				const std::vector<std::size_t>& breaks = ghostSource->breaks;
-
-				g.TranslateTransform(offsetX, offsetY);
-
-				const DrawMode mode = resolved.style->mode;
-				const bool drawLine = (mode != DrawMode::SCATTER);
-				const bool drawScatter = (mode == DrawMode::SCATTER || mode == DrawMode::LINE_SCATTER);
-
-				// 虚影保持原信号的颜色与样式（不再是虚线），仅以轻微透明区分“尚未落地”。
-				const std::uint32_t ghostColor = WithAlpha(resolved.style->color,
-				                                           static_cast<unsigned int>(
-				                                               std::max(0.35, static_cast<double>(resolved.style->opacity)) *
-				                                               255.0 + 0.5));
-
-				if (drawLine && !breaks.empty())
-				{
-					if (ghostSource->bandMode && !ghostSource->bandBreaks.empty())
-					{
-						// 稠密包络虚影同样用一次 FillPath（见 PaintLane 的说明）。
-						gd::GraphicsPath bandPath;
-						bandPath.SetFillMode(gd::FillModeWinding);
-						for (std::size_t k = 0; k < ghostSource->bandBreaks.size(); ++k)
-						{
-							const std::size_t start = ghostSource->bandBreaks[k];
-							const std::size_t stop = (k + 1 < ghostSource->bandBreaks.size())
-							                             ? ghostSource->bandBreaks[k + 1]
-							                             : ghostSource->band.size();
-							const std::size_t total = stop - start;
-							if (total < 4 || (total % 2) != 0)
-							{
-								continue;
-							}
-							const std::size_t half = total / 2;
-							bandPath.StartFigure();
-							bandPath.AddLines(ghostSource->band.data() + start, static_cast<INT>(half));
-							bandPath.AddLines(ghostSource->band.data() + start + half,
-							                  static_cast<INT>(half));
-							bandPath.CloseFigure();
-						}
-						if (bandPath.GetPointCount() > 0)
-						{
-							gd::SolidBrush brush(ToGdiColor(ghostColor));
-							g.FillPath(&brush, &bandPath);
-						}
-					}
-					else
-					{
-						gd::Pen ghost(ToGdiColor(ghostColor),
-						              std::max(1.0f, resolved.style->lineWidth) * m_scale);
-						ghost.SetLineJoin(gd::LineJoinRound);
-						ghost.SetStartCap(gd::LineCapRound);
-						ghost.SetEndCap(gd::LineCapRound);
-						for (std::size_t k = 0; k < breaks.size(); ++k)
-						{
-							const std::size_t start = breaks[k];
-							const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
-							if (stop <= start + 1)
-							{
-								continue;
-							}
-							g.DrawLines(&ghost, points.data() + start, static_cast<INT>(stop - start));
-						}
-					}
-				}
-
-				if (drawScatter && !points.empty())
-				{
-					const float radius = static_cast<float>(
-					    ClampDouble(static_cast<double>(resolved.style->lineWidth) * kScatterRadiusScale,
-					                kMinScatterRadius, kMaxScatterRadius) *
-					    m_scale);
-					const std::size_t scatterStride =
-					    std::max<std::size_t>(1, points.size() / kMaxScatterPoints);
-					// 与主绘制一致：合并成一条路径一次填充，并显式使用缠绕规则避免重叠处出现空洞。
-					gd::GraphicsPath ghostPath;
-					ghostPath.SetFillMode(gd::FillModeWinding);
-					for (std::size_t k = 0; k < points.size(); k += scatterStride)
-					{
-						ghostPath.AddEllipse(points[k].X - radius, points[k].Y - radius, radius * 2.0f,
-						                     radius * 2.0f);
-					}
-					gd::SolidBrush brush(ToGdiColor(ghostColor));
-					if (ghostPath.GetPointCount() > 0)
-					{
-						g.FillPath(&brush, &ghostPath);
-					}
-				}
-				else if (drawScatter && resolved.data->finiteCount == 1)
-				{
-					// ⚠️ **只有单个有效数据点**的信号：折线缓存给不出顶点（`points` 可能为空），
-					// 因此直接按数据点的屏幕坐标画那个圆点，否则拖动时虚影会**整个消失**
-					//（用户 2026-10-15 要求单点信号也能拖拽换网格）。
-					gd::PointF dot;
-					if (SinglePointScreenPos(resolved, sourceVisual, dot))
-					{
-						const float radius = SinglePointDotRadius(resolved);
-						gd::SolidBrush brush(ToGdiColor(ghostColor));
-						g.FillEllipse(&brush, dot.X - radius, dot.Y - radius, radius * 2.0f, radius * 2.0f);
-					}
-				}
-
-				g.Restore(saveState);
-			}
-
-			// 落点提示：高亮鼠标所在网格并给出文字说明。
-			const int target = (m_dragTargetLane >= 0) ? m_dragTargetLane : sourceLane;
-			if (target >= 0 && target < static_cast<int>(m_lanes.size()))
-			{
-				const gd::RectF& targetRect = m_lanes[static_cast<std::size_t>(target)].rect;
-				const float visibleTop = std::max(targetRect.Y, m_plotRect.Y);
-				const float visibleBottom = std::min(targetRect.Y + targetRect.Height,
-				                                     m_plotRect.Y + m_plotRect.Height);
-				if (visibleBottom > visibleTop)
-				{
-					gd::Pen frame(ToGdiColor(m_theme->accent), 2.0f);
-					g.DrawRectangle(&frame, targetRect.X, visibleTop, targetRect.Width,
-					                visibleBottom - visibleTop);
-
-					const std::wstring hint = (target == sourceLane)
-					                              ? std::wstring(L"松开左键放回本网格")
-					                              : (L"移动到网格 " + std::to_wstring(target + 1) +
-					                                 L"：松开左键确认");
-					const float textWidth = UiMeasureTextWidth(m_fonts->uiSmall, hint) + 16.0f * m_scale;
-					const float height = 20.0f * m_scale;
-					float left = targetRect.X + (targetRect.Width - textWidth) * 0.5f;
-					left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - textWidth));
-					const gd::RectF pill(left, visibleTop + 4.0f * m_scale, textWidth, height);
-					UiFillRoundRect(g, pill, 3.0f * m_scale, m_theme->accent);
-					UiText(g, hint, m_fonts->uiSmall, pill, m_theme->textOnAccent, TextAlign::CENTER);
-				}
-			}
-			return;
-		}
-
-		// 其它拖拽（光标/平移/中键/横向光标/面板）期间不显示信号悬停提示：
-		// 这些操作不会更新 m_hoverSignal，按下前的值会残留，表现为提示气泡"挂在原地"。
-		if (m_dragMode != PlotDragMode::NONE)
-		{
-			return;
-		}
-
-		// 悬停提示：光标贴近曲线时给出可拖拽说明（与时间光标的提示方式一致）。
-		if (!m_hoverSignal.IsValid())
-		{
-			return;
-		}
-		const int laneIndex = m_tab->LaneOfSignal(m_hoverSignal);
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return;
-		}
-		const ResolvedSignal resolved = ResolveSignal(m_hoverSignal);
-		if (resolved.data == nullptr)
-		{
-			return;
-		}
-
-		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
-		const std::wstring text = resolved.data->name + L" · 按住拖拽可移入其它网格";
-
-		// 提示跟随鼠标：在可拖拽区域内持续移动时，提示条也要跟着走。
-		const float textWidth = UiMeasureTextWidth(m_fonts->uiSmall, text) + 16.0f * m_scale;
-		const float height = 20.0f * m_scale;
-		float left = static_cast<float>(m_mouseX) + 12.0f * m_scale;
-		if (left + textWidth > m_plotRect.X + m_plotRect.Width)
-		{
-			left = m_plotRect.X + m_plotRect.Width - textWidth;
-		}
-		left = std::max(m_plotRect.X, left);
-
-		float top = static_cast<float>(m_mouseY) + 14.0f * m_scale;
-		top = std::min(top, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale);
-		top = std::max(top, lane.rect.Y + 2.0f * m_scale);
-
-		const gd::RectF pill(left, top, textWidth, height);
-		UiFillRoundRect(g, pill, 3.0f * m_scale, WithAlpha(m_theme->readoutBg, 0xF2));
-		UiDrawRoundRect(g, pill, 3.0f * m_scale, m_theme->accent, 1.0f);
-		UiText(g, text, m_fonts->uiSmall, pill, m_theme->textStrong, TextAlign::CENTER);
-	}
-
-	void PlotView::PaintScrollBar(gd::Graphics& g)
-	{
-		if (!m_scrollBarVisible || m_laneContentHeight <= m_plotRect.Height)
-		{
-			return;
-		}
-
-		UiFillRoundRect(g, m_scrollBarRect, kScrollBarThickness * m_scale * 0.5f, m_theme->gridWeak);
-
-		const float ratio = std::min(1.0f, m_plotRect.Height / m_laneContentHeight);
-		const float thumbHeight = std::max(24.0f * m_scale, m_scrollBarRect.Height * ratio);
-		const float maxScroll = m_laneContentHeight - m_plotRect.Height;
-		const float progress = (maxScroll > 0.0f) ? (Tab().LaneScroll() / maxScroll) : 0.0f;
-		const float thumbY = m_scrollBarRect.Y + progress * (m_scrollBarRect.Height - thumbHeight);
-
-		const gd::RectF thumb(m_scrollBarRect.X, thumbY, m_scrollBarRect.Width, thumbHeight);
-		UiFillRoundRect(g, thumb, kScrollBarThickness * m_scale * 0.5f, m_theme->borderStrong);
-	}
 
 } // namespace jdi
+
diff --git a/Components/PlotView/Src/PlotViewFeatures.cpp b/Components/PlotView/Src/PlotViewFeatures.cpp
new file mode 100644
index 0000000..08ab178
--- /dev/null
+++ b/Components/PlotView/Src/PlotViewFeatures.cpp
@@ -0,0 +1,3005 @@
+// PlotView 实现分片 —— 本文件只包含 PlotView 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与工具函数在 PlotViewInternal.hpp（命名空间 `pvdetail`，全部 inline）。
+// 四个分片的职责划分（按功能）：
+//   core        视图核心：构造/析构、上下文绑定、布局、坐标映射、视界与平移、网格结构与归属、
+//               选区/网格划分、拖动取消
+//   paint       渲染与像素缓存：全部绘制（Paint*/Render*）、场景缓存、装饰缓存、每网格图层、
+//               宽基底与滚动补条、并行图层重建
+//   interaction 交互与编辑：命中测试、鼠标与键盘处理、光标形状、内联输入框、浮动面板层序与命中
+//   features    视图特性与派生数据：光标状态与读数、提示浮层、缩放模式、自适应、光标吸附、
+//               单点信号、派生曲线线程池、边沿统计、实验性功能（均值滤波 / 弱峰调整）参数
+#include "PlotViewInternal.hpp"
+
+namespace jdi
+{
+
+	bool PlotView::CursorEnabled() const
+	{
+		return Tab().CursorEnabled();
+	}
+
+	double PlotView::CursorTime() const
+	{
+		return Tab().CursorTime();
+	}
+
+	PlotCursorMode PlotView::CursorMode() const
+	{
+		return Tab().CursorMode();
+	}
+
+	void PlotView::ZoomTimeAt(double factor, double anchorTime)
+	{
+		if (m_dataSet == nullptr || m_dataSet->Empty() || !(factor > 0.0) || !std::isfinite(anchorTime))
+		{
+			return;
+		}
+
+		double dataMin = 0.0;
+		double dataMax = 1.0;
+		TimeBounds(dataMin, dataMax);
+		const double dataSpan = std::max(dataMax - dataMin, kMinTimeSpan);
+
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(span > 0.0))
+		{
+			return;
+		}
+		// 下限与选区放大共用同一个来源（见 `MinimumTimeSpan`），
+		// 否则“滚轮缩放有限制、选区放大没有”会让视界退化到不可用。
+		const double minimum = MinimumTimeSpan(Tab().ViewMin(), Tab().ViewMax());
+		const double newSpan = ClampDouble(span / factor, minimum, dataSpan * 100.0);
+
+		const double ratio = (anchorTime - Tab().ViewMin()) / span;
+		const double low = anchorTime - ratio * newSpan;
+		SetTimeView(low, low + newSpan);
+	}
+
+	void PlotView::ZoomTimeStep(double factor)
+	{
+		const double anchor = (Tab().ViewMin() + Tab().ViewMax()) * 0.5;
+		ZoomTimeAt(factor, anchor);
+	}
+
+	void PlotView::FitAll()
+	{
+		if (m_dataSet == nullptr || m_dataSet->Empty())
+		{
+			SetTimeView(0.0, 1.0);
+			return;
+		}
+		if (m_tab == nullptr)
+		{
+			return;
+		}
+
+		// 全部可见信号的"边界贡献"（时刻范围 / 绘制取值 / 是否单点 / 散点半径）。
+		std::vector<std::vector<FitContribution>> perLane;
+		const std::size_t visibleCount = CollectFitContributions(perLane);
+
+		// ---- 特例：所有可见数据点都是单值信号、且时刻完全相同 ----
+		bool allSingle = true;
+		bool sameTime = true;
+		double sharedTime = 0.0;
+		bool haveTime = false;
+		for (const std::vector<FitContribution>& items : perLane)
+		{
+			for (const FitContribution& item : items)
+			{
+				if (!item.singlePoint)
+				{
+					allSingle = false;
+					continue;
+				}
+				if (!haveTime)
+				{
+					sharedTime = item.pointTime;
+					haveTime = true;
+				}
+				else if (std::fabs(item.pointTime - sharedTime) >
+				         kSinglePointSameTimeEpsilon * std::max(1.0, std::fabs(sharedTime)))
+				{
+					sameTime = false;
+				}
+			}
+		}
+		if (visibleCount > 0 && allSingle && sameTime)
+		{
+			FitSinglePointCluster(perLane, sharedTime);
+			return;
+		}
+
+		// ---- 常规的整段适应 ----
+		double low = 0.0;
+		double high = 1.0;
+		TimeBounds(low, high);
+		if (!(high > low))
+		{
+			const double padding = std::max(1.0e-6, std::fabs(low) * 0.01);
+			low -= padding;
+			high += padding;
+		}
+
+		// 时间边界处的单值散点不能被裁切：**被裁切的那一侧**向外让出散点半径。
+		// ⚠️ 迭代两遍：让出余量会改变跨度，而"半径换算成多少时间"又依赖跨度。
+		const double plotWidth = std::max(1.0, static_cast<double>(m_plotRect.Width));
+		for (int pass = 0; pass < 2; ++pass)
+		{
+			const double span = high - low;
+			if (!(span > 0.0))
+			{
+				break;
+			}
+			for (const std::vector<FitContribution>& items : perLane)
+			{
+				for (const FitContribution& item : items)
+				{
+					if (!item.singlePoint || !(item.dotRadius > 0.0f))
+					{
+						continue;
+					}
+					const double radius =
+					    (static_cast<double>(item.dotRadius) + kSinglePointBoundaryPadPixels) * span /
+					    plotWidth;
+					if (item.pointTime - radius < low)
+					{
+						low = item.pointTime - radius;
+					}
+					if (item.pointTime + radius > high)
+					{
+						high = item.pointTime + radius;
+					}
+				}
+			}
+		}
+
+		SetTimeView(low, high);
+		// ⚠️ **只有真的存在可见信号时才置位 `ViewInitialized()`**：没有任何信号被勾选时
+		//（用户先连点几次「适应视图」）必须保持"未初始化"，否则随后勾选第一个信号时
+		// `Application::SynchronizeView` 会**跳过初次自适应** —— 数据点既不居中，
+		// 还可能有一半被裁在网格外（用户 2026-10-15 报告）。
+		if (visibleCount > 0)
+		{
+			Tab().ViewInitialized() = true;
+		}
+		Tab().LaneScroll() = 0.0f;
+		// 只放下进行中的选区与拖拽，**不改变「选区放大」等缩放模式的启用状态**
+		// （用户明确要求：点适应视图后仍保持已启用的缩放模式）。
+		m_rubberRect = gd::RectF();
+		m_dragMode = PlotDragMode::NONE;
+		m_dragSignal = SignalRef();
+		m_dragTargetLane = -1;
+		m_hoverSignal = SignalRef();
+		SetHint(Tab().ZoomMode() == PlotZoomMode::NONE
+		            ? std::wstring()
+		            : L"横向或纵向拖动以放大选择区域，ESC退出选区模式");
+
+		// ---- 逐网格的幅值轴 ----
+		// 保留既有语义：开启了「选区 Y 轴自适应」的网格按新的（整段）时间视图重新匹配，
+		// 其余网格回到整段自适应；随后再为"被单值散点顶住的边界"让出余量。
+		const float laneHeight = FitLaneHeight();
+		for (std::size_t index = 0; index < m_tab->Lanes().size(); ++index)
+		{
+			const int laneIndex = static_cast<int>(index);
+			if (m_tab->Lanes()[index].fitYToSelection)
+			{
+				AutoRangeLaneToView(laneIndex);
+			}
+			else
+			{
+				m_tab->Lanes()[index].autoRange = true;
+			}
+			ApplySinglePointValueMargins(laneIndex, perLane[index], laneHeight);
+		}
+		// 适应视图已回到初始状态，这里不再移动光标（光标允许停留在可视区外）。
+		BuildLaneVisuals();
+	}
+
+	std::size_t PlotView::CollectFitContributions(std::vector<std::vector<FitContribution>>& perLane) const
+	{
+		perLane.clear();
+		if (m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return 0;
+		}
+		perLane.assign(m_tab->Lanes().size(), std::vector<FitContribution>());
+
+		std::size_t total = 0;
+		for (std::size_t laneIndex = 0; laneIndex < m_tab->Lanes().size(); ++laneIndex)
+		{
+			for (const SignalRef& ref : m_tab->Lanes()[laneIndex].signals)
+			{
+				if (!m_tab->IsVisible(ref))
+				{
+					continue;
+				}
+				const SignalData* data = m_dataSet->Resolve(ref);
+				const TimeAxis* axis = m_dataSet->Axis(ref);
+				if (data == nullptr || axis == nullptr || data->finiteCount == 0)
+				{
+					continue;
+				}
+
+				FitContribution item;
+				item.ref = ref;
+				// 与 `ComputeVisibleTimeBounds` 同源：时间边界用**时间轴**的范围
+				//（一个分组的多条信号可能共用一条轴，轴范围才是"这一段数据"的边界）。
+				item.minTime = axis->minTime;
+				item.maxTime = axis->maxTime;
+				item.singlePoint = (data->finiteCount == 1);
+				if (item.singlePoint)
+				{
+					double time = 0.0;
+					double value = 0.0;
+					if (!SinglePointOfSignal(*data, *axis, time, value))
+					{
+						item.singlePoint = false;
+					}
+					else
+					{
+						const SignalStyle* style = m_dataSet->Style(ref);
+						item.pointTime = time;
+						item.pointValue =
+						    (style != nullptr) ? ApplyDrawTransform(*style, value) : value;
+						item.dotRadius = SinglePointDotRadius(ResolveSignal(ref));
+					}
+				}
+				perLane[laneIndex].push_back(item);
+				++total;
+			}
+		}
+		return total;
+	}
+
+	float PlotView::FitLaneHeight() const
+	{
+		// 与 `BuildLaneVisuals()` **完全同源**：网格高度 = 绘图区高 / 网格数（不低于最小高度）。
+		// 直接复用它（而不是读 `m_lanes[i].rect.Height`）：`FitAll` 可能在网格数量刚变化、
+		// 布局尚未重建时被调用，用公式能拿到**将要生效**的高度。
+		const std::size_t count = (m_tab != nullptr) ? m_tab->Lanes().size() : 0;
+		if (count == 0 || !(m_plotRect.Height > 0.0f))
+		{
+			return 0.0f;
+		}
+		float height = m_plotRect.Height / static_cast<float>(count);
+		if (height < m_minLaneHeight * m_scale)
+		{
+			height = m_minLaneHeight * m_scale;
+		}
+		return height;
+	}
+
+	void PlotView::ApplySinglePointValueMargins(int laneIndex, const std::vector<FitContribution>& items,
+	                                           float laneHeight)
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr || laneHeight <= 1.0f)
+		{
+			return;
+		}
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return;
+		}
+
+		bool anySingle = false;
+		for (const FitContribution& item : items)
+		{
+			if (item.singlePoint && item.dotRadius > 0.0f)
+			{
+				anySingle = true;
+				break;
+			}
+		}
+		if (!anySingle)
+		{
+			return;			// 该网格的边界不是单值散点顶住的：保持现有（自动）区间
+		}
+
+		// 该网格当前**生效**的幅值区间（自动自适应时即 `ComputeLaneRange` 的结果）。
+		double low = 0.0;
+		double high = 0.0;
+		m_tab->ComputeLaneRange(*m_dataSet, laneIndex, low, high);
+		if (!(high > low))
+		{
+			return;
+		}
+
+		double newLow = low;
+		double newHigh = high;
+		// 迭代两遍：让出余量会改变跨度，而"半径换算成多少数值"又依赖跨度。
+		for (int pass = 0; pass < 2; ++pass)
+		{
+			const double span = newHigh - newLow;
+			if (!(span > 0.0))
+			{
+				break;
+			}
+			for (const FitContribution& item : items)
+			{
+				if (!item.singlePoint || !(item.dotRadius > 0.0f))
+				{
+					continue;
+				}
+				const double radius =
+				    (static_cast<double>(item.dotRadius) + kSinglePointBoundaryPadPixels) * span /
+				    static_cast<double>(laneHeight);
+				if (item.pointValue - radius < newLow)
+				{
+					newLow = item.pointValue - radius;
+				}
+				if (item.pointValue + radius > newHigh)
+				{
+					newHigh = item.pointValue + radius;
+				}
+			}
+		}
+		if (newLow == low && newHigh == high)
+		{
+			return;			// 散点本来就完整可见：不改动区间（保持自动自适应的语义）
+		}
+
+		// ⚠️ 必须**同时**关掉 `autoRange`：否则 `ComputeLaneRange` 会忽略下面写入的区间。
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		lane.autoRange = false;
+		lane.yMin = newLow;
+		lane.yMax = newHigh;
+	}
+
+	void PlotView::FitSinglePointCluster(const std::vector<std::vector<FitContribution>>& perLane,
+	                                     double sharedTime)
+	{
+		// 时间轴：该时刻居中、**一大格 = 1s**（视界 = 大格数 × 1s）。
+		//
+		// 幅值轴与其余场景**共用同一段逻辑**（见函数末尾）：`fitYToSelection` 的网格走
+		// `AutoRangeLaneToView`、其余走整段自适应（`ComputeLaneRange`），两者都只由
+		// `PadValueRange` 提供留白。这样「适应视图」与「Y 轴自适应」互为幂等 ——
+		// 同一视界下反复切换两者不会改变区间，也不会关掉 Y 轴自适应开关（用户 2026-10-16）。
+		const double span =
+		    static_cast<double>(kTimeTickTarget) * kSinglePointClusterSecondsPerCell;
+		SetTimeView(sharedTime - span * 0.5, sharedTime + span * 0.5);
+		Tab().ViewInitialized() = true;
+		Tab().LaneScroll() = 0.0f;
+		// ⚠️ **不要**在这里复位 `ZoomMode()`：用户明确要求"点适应视图后仍保持已启用的
+		//    缩放模式"（`FitAll` 的常规路径同样只更新提示、不动缩放模式）。
+		m_rubberRect = gd::RectF();
+		m_dragMode = PlotDragMode::NONE;
+		m_dragSignal = SignalRef();
+		m_dragTargetLane = -1;
+		m_hoverSignal = SignalRef();
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+		SetHint(Tab().ZoomMode() == PlotZoomMode::NONE
+		            ? std::wstring()
+		            : L"横向或纵向拖动以放大选择区域，ESC退出选区模式");
+
+		// ---- 逐网格的幅值轴 ----
+		// ⚠️ **必须与 `FitAll()` 的常规路径、以及「Y 轴自适应」（`AutoRangeLaneToView`）同源**：
+		// 旧实现在这条特例里按“散点半径留白 + 跨度 1”另算一套区间，而 Y 轴自适应走
+		// `PadValueRange`，于是对**同一个视界**两者会算出不同的幅值范围
+		//（用户 2026-10-16 报告：单数据点信号上「适应视图」与「Y 轴自适应」的范围不一致）；
+		// 并且旧实现还把 `fitYToSelection` 置回 false —— 原本开着「Y 轴自适应」时点一下
+		// 「适应视图」会把这个开关**悄悄关掉**。
+		// 现在两者共用同一段逻辑：留白只来自 `PadValueRange`，且**不改动** Y 轴自适应开关。
+		const float laneHeight = FitLaneHeight();
+		for (std::size_t index = 0; index < perLane.size() && index < m_tab->Lanes().size(); ++index)
+		{
+			const int laneIndex = static_cast<int>(index);
+			if (m_tab->Lanes()[index].fitYToSelection)
+			{
+				// 已开启「选区 Y 轴自适应」的网格按当前（刚设好的）时间视图重新匹配 ——
+				// 与工具栏开关打开时的算法完全一致，因此两种操作互为幂等。
+				AutoRangeLaneToView(laneIndex);
+			}
+			else
+			{
+				m_tab->Lanes()[index].autoRange = true;
+			}
+			// 补齐“被单值散点顶住的边界”（散点本来就完整可见时保持不变）。
+			ApplySinglePointValueMargins(laneIndex, perLane[index], laneHeight);
+		}
+
+		InvalidateSceneCache();
+		BuildLaneVisuals();
+	}
+
+	bool PlotView::SinglePointOfSignal(const SignalData& signal, const TimeAxis& axis, double& time,
+	                                   double& value) const
+	{
+		time = std::numeric_limits<double>::quiet_NaN();
+		value = std::numeric_limits<double>::quiet_NaN();
+
+		// 正常路径：加载/插入信号时已把“有效点很少”的信号的全部有效点缓存下来。
+		if (!signal.sparseTimes.empty() && signal.sparseTimes.size() == signal.sparseValues.size())
+		{
+			time = signal.sparseTimes.front();
+			value = signal.sparseValues.front();
+			return std::isfinite(time) && std::isfinite(value);
+		}
+
+		// 兜底：逐个采样找那个有效点（单点信号的采样数组必然很短）。
+		const std::size_t count = std::min(axis.time.size(), signal.values.size());
+		for (std::size_t index = 0; index < count; ++index)
+		{
+			if (std::isfinite(signal.values[index]) && std::isfinite(axis.time[index]))
+			{
+				time = axis.time[index];
+				value = signal.values[index];
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void PlotView::DisableCursor()
+	{
+		Tab().CursorMode() = PlotCursorMode::NONE;
+		m_cursorHover = false;
+		m_hoverCursor = 0;
+		if (m_editTarget == PlotEditTarget::CURSOR_TIME || m_editTarget == PlotEditTarget::CURSOR_SPAN)
+		{
+			EndEdit(false);
+		}
+		if (m_dragMode == PlotDragMode::CURSOR_MOVE || m_dragMode == PlotDragMode::CURSOR_SPAN_MOVE)
+		{
+			m_dragMode = PlotDragMode::NONE;
+		}
+	}
+
+	bool PlotView::CycleCursorMode()
+	{
+		// 三态循环：无 → 单光标 → 双光标 → 无。光标模式本身不显示提示。
+		switch (Tab().CursorMode())
+		{
+		case PlotCursorMode::NONE:
+		{
+			Tab().CursorMode() = PlotCursorMode::SINGLE;
+			// 首次启用时置于视图中心，随后可用鼠标靠近拖拽或双击指定精确时间。
+			const double center = (Tab().ViewMin() + Tab().ViewMax()) * 0.5;
+			Tab().CursorTime() = center;
+			Tab().CursorTimeAlt() = center;
+			m_cursorHover = true;
+			m_hoverCursor = 1;
+			m_activeCursor = 1;
+			break;
+		}
+		case PlotCursorMode::SINGLE:
+		{
+			Tab().CursorMode() = PlotCursorMode::DOUBLE;
+			// 光标 2 首次出现：紧邻光标 1 且必须落在当前可见时间范围内，
+			// 这样无需额外操作就能立即看到两个光标的对比读数。
+			const double low = Tab().ViewMin();
+			const double high = Tab().ViewMax();
+			const double span = (high > low) ? (high - low) : 1.0;
+			const double offset = span * 0.12;
+			double second = Tab().CursorTime() + offset;
+			if (second > high - span * 0.02)
+			{
+				second = Tab().CursorTime() - offset;
+			}
+			if (second < low + span * 0.02 || second > high - span * 0.02)
+			{
+				second = low + span * 0.5;
+			}
+			Tab().CursorTimeAlt() = second;
+			ClampCursorToView(2);
+			m_cursorHover = true;
+			m_hoverCursor = 2;
+			m_activeCursor = 2;
+			break;
+		}
+		case PlotCursorMode::DOUBLE:
+		default:
+			DisableCursor();
+			break;
+		}
+		return true;
+	}
+
+	void PlotView::SetHint(const std::wstring& text)
+	{
+		m_hintText = text;
+		m_hintSticky = false;
+		m_hintShownAt = (text.empty()) ? 0 : GetTickCount64();
+	}
+
+	void PlotView::SetHintSticky(const std::wstring& text)
+	{
+		m_hintText = text;
+		m_hintSticky = !text.empty();
+		m_hintShownAt = (text.empty()) ? 0 : GetTickCount64();
+	}
+
+	void PlotView::ReleaseHint()
+	{
+		// 粘滞结束：从这里开始重新计时（先停留再淡出）。
+		m_hintSticky = false;
+		if (!m_hintText.empty())
+		{
+			m_hintShownAt = GetTickCount64();
+		}
+	}
+
+	bool PlotView::HintNeedsAnimation() const
+	{
+		if (m_hintText.empty() || m_hintShownAt == 0)
+		{
+			return false;
+		}
+		if (m_hintSticky)
+		{
+			return true;
+		}
+		const std::uint64_t elapsed = GetTickCount64() - m_hintShownAt;
+		return elapsed < (kHintHoldMs + kHintFadeMs);
+	}
+
+	double PlotView::CursorSpan() const
+	{
+		if (m_tab == nullptr || Tab().CursorMode() != PlotCursorMode::DOUBLE)
+		{
+			return 0.0;
+		}
+		return std::fabs(Tab().CursorTimeAlt() - Tab().CursorTime());
+	}
+
+	void PlotView::ClampCursorToView(int which)
+	{
+		if (m_tab == nullptr || m_plotRect.Width <= 0.0f)
+		{
+			return;
+		}
+		const double low = Tab().ViewMin();
+		const double high = Tab().ViewMax();
+		if (!(high > low))
+		{
+			return;
+		}
+		// 只在拖拽时夹取；留一点内缩，保证光标线及把手完整可见。
+		// ⚠️ 视图变化（平移 / 缩放 / 自适应 / 滚轮 / 方向键）**不**调用本函数：光标是一个固定的
+		// **时间位置**，视界移动时它必须留在原处（可以滑出可视区，此时读数贴在网格边缘显示）。
+		const double inset = (high - low) * 0.002;
+		if (which == 2)
+		{
+			Tab().CursorTimeAlt() = ClampDouble(Tab().CursorTimeAlt(), low + inset, high - inset);
+		}
+		else
+		{
+			Tab().CursorTime() = ClampDouble(Tab().CursorTime(), low + inset, high - inset);
+		}
+	}
+
+	std::uint32_t PlotView::CursorColor() const
+	{
+		// 两条光标统一使用同一样式与颜色，不按序号区分配色。
+		if (m_theme == nullptr)
+		{
+			return 0xFF000000u;
+		}
+		return m_theme->cursor;
+	}
+
+	void PlotView::InvalidateDerivedCaches()
+	{
+		// 后台线程可能在读取采样数据：先暂停并作废异步结果，再清同步缓存。
+		PauseDerivedAsync();
+		m_polylineCache.clear();
+		// 数据层结构变化后边沿统计与均值滤波曲线的派生结果都会失效。
+		m_edgeScans.clear();
+		m_edgeScanBudget = 0;
+		m_meanCurveCache.clear();
+		m_weakPeakCurveCache.clear();
+		// 信号下标可能已经整体位移：清掉按引用缓存的悬停/拖拽目标，避免指向错误的信号。
+		m_hoverSignal = SignalRef();
+		m_hoverLegend = SignalRef();
+		m_dragSignal = SignalRef();
+		m_dragTargetLane = -1;
+		InvalidateSceneCache();
+	}
+
+	void PlotView::PauseDerivedAsync()
+	{
+		// 等待在算任务结束（先发取消），然后清空队列与缓存，并自增代次使任何迟到结果作废。
+		StopCurveWorker();
+		std::lock_guard<std::mutex> lock(m_curveMutex);
+		++m_curveGeneration;
+		m_curveJobs.clear();
+		m_curveEntries.clear();
+		m_curvePins.clear();
+		m_curveLatest.clear();
+		m_curveHugeActive = 0;
+		m_curveSceneDirty.store(false, std::memory_order_relaxed);
+		m_curveCancelAll.store(false, std::memory_order_relaxed);	// 恢复：下次需要时可以重新开始
+	}
+
+	bool PlotView::AnyDerivedPreviewEnabled() const
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		for (const Lane& lane : m_tab->Lanes())
+		{
+			if (lane.weakPeak || lane.meanFilter || lane.edgeCenter)
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void PlotView::TrimDerivedCurveDataIfIdle()
+	{
+		if (AnyDerivedPreviewEnabled())
+		{
+			return;		// 还有网格在用预览曲线：缓存仍然有用，不能清
+		}
+		// 停掉后台线程池：这会让各线程的 `thread_local` 工作缓冲**析构并归还内存** ——
+		// 这是"关掉预览后内存不下降"的根因（thread_local 只在线程退出时释放）。
+		PauseDerivedAsync();
+		m_meanCurveCache.clear();
+		m_weakPeakCurveCache.clear();
+	}
+
+	bool PlotView::FitTimeToLane(int laneIndex)
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+
+		const std::vector<Lane>& lanes = m_tab->Lanes();
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(lanes.size()))
+		{
+			return false;
+		}
+
+		double low = std::numeric_limits<double>::infinity();
+		double high = -std::numeric_limits<double>::infinity();
+		for (const SignalRef& ref : lanes[static_cast<std::size_t>(laneIndex)].signals)
+		{
+			const TimeAxis* axis = m_dataSet->Axis(ref);
+			if (axis == nullptr || axis->finiteCount == 0)
+			{
+				continue;
+			}
+			low = std::min(low, axis->minTime);
+			high = std::max(high, axis->maxTime);
+		}
+
+		if (!std::isfinite(low) || !std::isfinite(high) || !(high > low))
+		{
+			return false;
+		}
+
+		SetTimeView(low, high);
+		Tab().ViewInitialized() = true;
+		// 与“适应视图”保持一致：退出选区放大模式，避免模式按钮与实际状态不符。
+		Tab().ZoomMode() = PlotZoomMode::NONE;
+		m_rubberRect = gd::RectF();
+		m_dragMode = PlotDragMode::NONE;
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+
+		// 针对本网格信号范围展开时间轴后，同时把该网格的 Y 轴自适应一次，
+		// 否则展开后会看到“时间对了但幅值区间不合适”的波形。
+		AutoRangeLaneToView(laneIndex);
+
+		// 其它开启了「选区 Y 轴自适应」的网格同样要跟新的时间视图重新匹配：
+		// 时间视图变了，只让被展开的那个网格合适、其余网格停留在旧幅值区间并不符合预期。
+		ApplySelectionAutoFit();
+
+		// 注意：不在这里移动光标——光标允许滞留在网格可视区域之外。
+		BuildLaneVisuals();
+		return true;
+	}
+
+	bool PlotView::SignalSnapEnabled(const TimeAxis& axis, const SignalData& signal,
+	                                 double timeShift) const
+	{
+		const int cells = GridMinorCellCount();
+		if (cells <= 0 || signal.finiteCount == 0)
+		{
+			return false;
+		}
+		const std::size_t threshold =
+		    static_cast<std::size_t>(cells) * static_cast<std::size_t>(kSnapVisibleCellsPerPoint);
+		if (threshold == 0)
+		{
+			return false;
+		}
+
+		const std::size_t count = std::min(axis.time.size(), signal.values.size());
+		if (count == 0)
+		{
+			return false;
+		}
+		std::size_t begin = 0;
+		std::size_t end = 0;
+		VisibleIndexRange(axis, count, begin, end, timeShift);
+		if (end <= begin)
+		{
+			return false;
+		}
+
+		// ⚠️ 视界内**至少要有一个可见数据点**：一个数据点都不在屏幕上的信号既没有可吸附的
+		//    对象、也没有可提示的内容。少了这一条，“数据点全都落在视界之外”的信号会被判成
+		//    “稀疏”（0 < N×4）而被自动切成「点线」，属于无意义的状态抖动。
+		if (signal.finiteCount < threshold)
+		{
+			// 有效点总数本来就不足阈值 ⇒ 只需确认视界内确实有点（稀疏点已缓存时二分判定）。
+			return HasVisibleSample(axis, signal, begin, end, timeShift);
+		}
+
+		// 一般信号：统计**当前视界内**的有效点数量（攒够阈值立刻早退，代价有界）。
+		// 连续 NaN 不计入有效点，因此再给一个**有界**的扫描窗口，防止极端情况下长循环。
+		const std::size_t window =
+		    std::min(std::min(end, signal.values.size()), begin + threshold * kSnapScanWindowFactor + 8u);
+		std::size_t seen = 0;
+		for (std::size_t index = begin; index < window; ++index)
+		{
+			if (!std::isfinite(signal.values[index]))
+			{
+				continue;
+			}
+			// ⚠️ 必须按**绘制时刻**判断可见性（`t + offsetTime`），否则存在时间轴偏移时
+			//    会把“已经移出视界”的采样点算进来（用户报告吸附到历史位置）。
+			const double time = axis.time[index];
+			if (!std::isfinite(time))
+			{
+				continue;
+			}
+			const double displayTime = time + timeShift;
+			if (displayTime < Tab().ViewMin() || displayTime > Tab().ViewMax())
+			{
+				continue;
+			}
+			if (++seen >= threshold)
+			{
+				return false;		// 一屏内的数据点已经足够密：保持自由移动
+			}
+		}
+		return seen > 0;
+	}
+
+	bool PlotView::NearestSnapSample(const TimeAxis& axis, const SignalData& signal, double time,
+	                                 double timeShift, double& candidate) const
+	{
+		// ⚠️ `time` / `candidate` 都是**显示时间**（画面上的时刻）：采样点 k 画在 `time[k] + timeShift`
+		//    处，而光标存的也是显示时间，因此查找与可见性判定都要整体平移（否则存在
+		//    「调整 → 时间轴偏移」时吸附会落在历史位置上，用户 2026-10-15 报告）。
+		const double viewMin = Tab().ViewMin() - timeShift;
+		const double viewMax = Tab().ViewMax() - timeShift;
+
+		// 稀疏信号：有效点已在加载时缓存（按时间升序）⇒ 二分取最近的一个。
+		if (!signal.sparseTimes.empty())
+		{
+			const std::vector<double>& times = signal.sparseTimes;
+			const double target = time - timeShift;
+			const std::vector<double>::const_iterator it = std::lower_bound(times.begin(), times.end(), target);
+			bool found = false;
+			double bestDistance = std::numeric_limits<double>::infinity();
+			for (int side = 0; side < 2; ++side)
+			{
+				// side 0 = 第一个 >= target 的点；side 1 = 它前面的那个点。
+				if (side == 1 && it == times.begin())
+				{
+					continue;
+				}
+				const std::vector<double>::const_iterator pick = (side == 0) ? it : (it - 1);
+				if (pick == times.end())
+				{
+					continue;
+				}
+				const double value = *pick;
+				if (!std::isfinite(value) || value < viewMin || value > viewMax)
+				{
+					continue;
+				}
+				const double distance = std::fabs((value + timeShift) - time);
+				if (distance < bestDistance)
+				{
+					bestDistance = distance;
+					candidate = value + timeShift;
+					found = true;
+				}
+			}
+			return found;
+		}
+
+		// 一般信号：取下标最近的采样点；它若无效（NaN）则向两侧**有界**探测
+		//（NaN 只出现在缺少数据的区段，通常几步内就能找到有效点；找不到就不吸附）。
+		const std::size_t count = std::min(axis.time.size(), signal.values.size());
+		if (count == 0)
+		{
+			return false;
+		}
+		const int center = FindNearestSample(axis, time - timeShift);
+		if (center < 0)
+		{
+			return false;
+		}
+		const int lastIndex = static_cast<int>(count) - 1;
+		for (int step = 0; step <= kSnapSampleProbeSteps; ++step)
+		{
+			for (int direction = 0; direction < 2; ++direction)
+			{
+				if (step == 0 && direction == 1)
+				{
+					continue;		// 中心点只查一次
+				}
+				const int probe = (direction == 0) ? (center - step) : (center + step);
+				if (probe < 0 || probe > lastIndex)
+				{
+					continue;
+				}
+				const double value = signal.values[static_cast<std::size_t>(probe)];
+				const double sampleTime = axis.time[static_cast<std::size_t>(probe)];
+				if (!std::isfinite(value) || !std::isfinite(sampleTime))
+				{
+					continue;
+				}
+				// 只接受**可见区间内**的采样点（按绘制时刻判断）：视界之外的采样点不是合法落点
+				//（否则吸附会把光标一把甩到视界边缘并钉住）。
+				if (sampleTime < viewMin || sampleTime > viewMax)
+				{
+					continue;
+				}
+				candidate = sampleTime + timeShift;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool PlotView::SnapTimeToSample(double time, double& snapped) const
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+
+		// 吸附判定**只针对鼠标所在的网格**（用户明确要求）：
+		// 一个网格内的数据已达“稀疏”标准、另一个没有时，光标只在前者上吸附，
+		// 在后者上仍然完全自由移动。
+		const int laneIndex = LaneAtY(m_mouseY);
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+
+		const int cells = GridMinorCellCount();
+		const double plotWidth = static_cast<double>(m_plotRect.Width);
+		const double viewSpan = Tab().ViewMax() - Tab().ViewMin();
+		if (cells <= 0 || plotWidth <= 1.0 || !(viewSpan > 0.0))
+		{
+			return false;
+		}
+		// 吸附半径 = **一个网格小格的宽度**（与判定用同一套网格定义推出），
+		// 且**不超过半个采样间距** —— 后者保证数据点很稀疏时（一屏只有一两个点）
+		// 光标在点与点之间仍可自由移动，而不是被“死死吸住”
+		//（用户明确要求：吸附只是提示性响应）。
+		const double radiusPixels = kSnapRadiusCells * plotWidth / static_cast<double>(cells);
+		const double radiusTime = radiusPixels / plotWidth * viewSpan;
+
+		bool found = false;
+		double bestDistance = std::numeric_limits<double>::infinity();
+		double bestTime = 0.0;
+
+		// 同一个网格内可能存在多条信号：**所有**符合吸附判定的数据点都参与吸附。
+		for (const SignalRef& ref : m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals)
+		{
+			if (!m_tab->IsVisible(ref))
+			{
+				continue;
+			}
+			const SignalData* signal = m_dataSet->Resolve(ref);
+			const TimeAxis* axis = m_dataSet->Axis(ref);
+			const SignalStyle* style = m_dataSet->Style(ref);
+			if (signal == nullptr || axis == nullptr)
+			{
+				continue;
+			}
+			// ⚠️ 一切吸附判定与查找都在**显示时间**空间进行：采样点 k 画在
+			//    `time[k] + offsetTime` 处，而光标存的也是显示时间。
+			//    少了这一步，信号一旦设置过「调整 → 时间轴偏移」，吸附就会落在**历史位置**
+			//    （用户 2026-10-15 报告“存在时间轴偏移调整时无法吸附到正确位置”）。
+			const double timeShift = (style != nullptr) ? style->offsetTime : 0.0;
+			// 只有“一屏内数据点少于 N×4”的信号参与吸附；判据随视界实时重算，
+			// 因此疏密变化的信号在稀疏区自动吸附、移到稠密区自动恢复自由移动。
+			if (!SignalSnapEnabled(*axis, *signal, timeShift))
+			{
+				continue;
+			}
+			double candidate = 0.0;
+			if (!NearestSnapSample(*axis, *signal, time, timeShift, candidate))
+			{
+				continue;
+			}
+
+			// 吸附半径再受“半个局部采样间距”限制（点很稀疏时不被吸死）。
+			double limitTime = radiusTime;
+			double spacingTime = 0.0;
+			LocalSampleSpacing(*axis, *signal, candidate, timeShift, spacingTime);
+			if (spacingTime > 0.0)
+			{
+				limitTime = std::min(limitTime, spacingTime * 0.5);
+			}
+
+			const double distance = std::fabs(candidate - time);
+			if (distance <= limitTime && distance < bestDistance)
+			{
+				bestDistance = distance;
+				bestTime = candidate;
+				found = true;
+			}
+		}
+
+		if (found)
+		{
+			snapped = bestTime;
+		}
+		return found;
+	}
+
+	void PlotView::PlaceCursorTime(int which, double time)
+	{
+		if (!std::isfinite(time))
+		{
+			// NaN/Inf 会让后面所有比较都失效（`ClampDouble` 也拦不住 NaN），
+			// 光标会被画到画布之外：直接丢弃这次位置更新。
+			return;
+		}
+
+		double snapped = 0.0;
+		if (SnapTimeToSample(time, snapped))
+		{
+			time = snapped;
+		}
+
+		if (which == 2)
+		{
+			Tab().CursorTimeAlt() = time;
+		}
+		else
+		{
+			Tab().CursorTime() = time;
+		}
+		ClampCursorToView(which);
+	}
+
+	PlotZoomMode PlotView::CurrentZoomMode() const
+	{
+		return Tab().ZoomMode();
+	}
+
+	bool PlotView::ToggleZoomMode(PlotZoomMode mode)
+	{
+		const PlotZoomMode current = Tab().ZoomMode();
+		Tab().ZoomMode() = (current == mode) ? PlotZoomMode::NONE : mode;
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+		m_rubberRect = gd::RectF();
+		SetHint(Tab().ZoomMode() == PlotZoomMode::NONE
+		            ? std::wstring()
+		            : L"横向或纵向拖动以放大选择区域，ESC退出选区模式");
+		return true;
+	}
+
+	float PlotView::CursorX(int which) const
+	{
+		const double time = (which == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
+		return TimeToX(time);
+	}
+
+	float PlotView::CursorDisplayX(int which) const
+	{
+		// 光标允许滞留在可视区之外：此时把它"钉"在最近的网格边缘上显示，
+		// 保证它的取值与时间读数始终可见。
+		const float raw = CursorX(which);
+		return std::max(m_plotRect.X + 1.0f * m_scale,
+		                std::min(raw, m_plotRect.X + m_plotRect.Width - 1.0f * m_scale));
+	}
+
+	gd::RectF PlotView::CursorLabelRect(int which) const
+	{
+		if (m_fonts == nullptr || m_fonts->monoSmall == nullptr)
+		{
+			return gd::RectF();
+		}
+
+		// 未经叠放处理的"原始"位置：单条标签独占底部一行。
+		const auto rawRect = [this](int index) -> gd::RectF
+		{
+			const double time = (index == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
+			const std::wstring text = FormatCursorTime(time);
+			const float width =
+			    std::max(64.0f * m_scale, UiMeasureTextWidth(m_fonts->monoSmall, text) + 16.0f * m_scale);
+			const float height = 20.0f * m_scale;
+
+			// 时间读数改到绘图区**底部**：顶部留给网格图例与幅值标尺，避免互相遮挡。
+			float left = CursorDisplayX(index) - width * 0.5f;
+			left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
+
+			// 光标滞留在视界之外时，胶囊外侧还要放一个方向三角（与网格内数据点越界同一套画法）：
+			// 把胶囊整体**向内**让出三角 + 间隙的宽度，否则贴边时三角没有落脚之处、
+			// 只能压在胶囊上（用户报告的"没有间隔、样式不统一"）。
+			bool offRight = false;
+			if (CursorOffViewSide(index, offRight))
+			{
+				const float reserved = (kMarkerTriangleDepth + kMarkerTriangleGap) * m_scale;
+				left = offRight ? (left - reserved) : (left + reserved);
+				left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
+			}
+
+			const float top = m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale;
+
+			return gd::RectF(left, top, width, height);
+		};
+
+		gd::RectF rect = rawRect(which);
+
+		// 双光标靠得很近时，两条时间读数标签会互相覆盖：把它们分两行叠放。
+		// **小值在上、大值在下**（用户明确要求）——按时间值决定行序，
+		// 而不是固定让光标 2 上移。左/右光标被拖动交换后排序依然正确。
+		if (Tab().CursorMode() == PlotCursorMode::DOUBLE)
+		{
+			const gd::RectF first = rawRect(1);
+			const gd::RectF second = rawRect(2);
+			// 方向三角已移到胶囊**外侧**，胶囊之间不再需要额外留白。
+			const float gap = 2.0f * m_scale;
+			const bool overlapX = (first.X < second.X + second.Width + gap) &&
+			                      (second.X < first.X + first.Width + gap);
+			if (overlapX)
+			{
+				const bool firstIsSmaller = (Tab().CursorTime() <= Tab().CursorTimeAlt());
+				// which == 1 是否属于"小值"。
+				const bool whichIsSmaller = (which == 1) ? firstIsSmaller : !firstIsSmaller;
+				const float bottomRow = rawRect(1).Y;
+				const float topRow = std::max(m_plotRect.Y + 2.0f * m_scale,
+				                              bottomRow - rect.Height - gap);
+				rect.Y = whichIsSmaller ? topRow : bottomRow;
+			}
+		}
+
+		return rect;
+	}
+
+	bool PlotView::LaneAutoFitToSelection(int laneIndex) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].fitYToSelection;
+	}
+
+	bool PlotView::AllLanesAutoFitToSelection() const
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		const std::vector<Lane>& lanes = m_tab->Lanes();
+		if (lanes.empty())
+		{
+			return false;
+		}
+		for (const Lane& lane : lanes)
+		{
+			if (!lane.fitYToSelection)
+			{
+				// 任一网格未开启 → 全局项就不是勾选状态。
+				return false;
+			}
+		}
+		return true;
+	}
+
+	bool PlotView::LaneEdgeCount(int laneIndex) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].edgeCount;
+	}
+
+	bool PlotView::SetLaneEdgeCount(int laneIndex, bool enabled)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.edgeCount == enabled)
+		{
+			return false;
+		}
+		lane.edgeCount = enabled;
+		if (enabled)
+		{
+			// 首次开启：把横向光标放到可见幅值范围的中点，并让面板重新展开。
+			if (!lane.edgeValueValid)
+			{
+				double yMin = 0.0;
+				double yMax = 1.0;
+				LaneRange(laneIndex, yMin, yMax);
+				lane.edgeValue = (yMin + yMax) * 0.5;
+				lane.edgeValueValid = true;
+			}
+			lane.edgePanelOpen = true;
+		}
+		else
+		{
+			lane.edgePanelOpen = false;
+		}
+		return true;
+	}
+
+	bool PlotView::ToggleLaneEdgeCount(int laneIndex)
+	{
+		const bool enabled = !LaneEdgeCount(laneIndex);
+		SetLaneEdgeCount(laneIndex, enabled);
+		return enabled;
+	}
+
+	bool PlotView::LaneEdgeCenterCount(int laneIndex) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].edgeCenter;
+	}
+
+	bool PlotView::SetLaneEdgeCenterCount(int laneIndex, bool enabled)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.edgeCenter == enabled)
+		{
+			return false;
+		}
+		lane.edgeCenter = enabled;
+		if (enabled)
+		{
+			// 与「均值滤波」完全一致：默认只勾选网格内**第一个可见信号**。
+			if (lane.edgeCenterItems.empty())
+			{
+				for (const SignalRef& ref : lane.signals)
+				{
+					const ResolvedSignal resolved = ResolveSignal(ref);
+					if (resolved.data != nullptr && resolved.visible)
+					{
+						lane.EnsureEdgeCenterItem(ref);
+						break;
+					}
+				}
+			}
+			lane.edgeCenterPanelOpen = true;
+		}
+		else
+		{
+			lane.edgeCenterPanelOpen = false;
+		}
+		// 关闭后若本标签页**已无任何预览曲线功能**，立即释放派生曲线数据（缓存 + 后台线程的
+		// thread_local 工作缓冲）—— 否则关掉面板后内存不会下降（用户报告）。
+		if (!enabled)
+		{
+			TrimDerivedCurveDataIfIdle();
+		}
+		// 预建「宽缓冲基底」，避免首次拖动参数滑块时的一次性重建尖峰。
+		RebuildWideBuffer();
+		return true;
+	}
+
+	bool PlotView::ToggleLaneEdgeCenterCount(int laneIndex)
+	{
+		const bool enabled = !LaneEdgeCenterCount(laneIndex);
+		SetLaneEdgeCenterCount(laneIndex, enabled);
+		return enabled;
+	}
+
+	bool PlotView::ToggleLaneEdgeCenterSignal(int laneIndex, const SignalRef& ref)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.EdgeCenterEnabled(ref))
+		{
+			lane.RemoveEdgeCenterItem(ref);
+			return false;
+		}
+		lane.EnsureEdgeCenterItem(ref);
+		return true;
+	}
+
+	bool PlotView::LaneEdgeCenterSignalEnabled(int laneIndex, const SignalRef& ref) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].EdgeCenterEnabled(ref);
+	}
+
+	bool PlotView::LaneMeanFilter(int laneIndex) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].meanFilter;
+	}
+
+	bool PlotView::LaneWeakPeak(int laneIndex) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].weakPeak;
+	}
+
+	bool PlotView::SetLaneWeakPeak(int laneIndex, bool enabled)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.weakPeak == enabled)
+		{
+			return false;
+		}
+		lane.weakPeak = enabled;
+		if (enabled)
+		{
+			// 与「均值滤波」完全一致：默认只勾选网格内**第一个可见信号**。
+			if (lane.weakPeakItems.empty())
+			{
+				for (const SignalRef& ref : lane.signals)
+				{
+					const ResolvedSignal resolved = ResolveSignal(ref);
+					if (resolved.data != nullptr && resolved.visible)
+					{
+						lane.EnsureWeakPeakItem(ref);
+						break;
+					}
+				}
+			}
+			lane.weakPeakPanelOpen = true;
+		}
+		else
+		{
+			lane.weakPeakPanelOpen = false;
+		}
+		// 关闭后若本标签页**已无任何预览曲线功能**，立即释放派生曲线数据（缓存 + 后台线程的
+		// thread_local 工作缓冲）—— 否则关掉面板后内存不会下降（用户报告）。
+		if (!enabled)
+		{
+			TrimDerivedCurveDataIfIdle();
+		}
+		// 预建「宽缓冲基底」（不含派生曲线），使用户首次拖动该滑块时无需从零重建（避免一次性尖峰）。
+		RebuildWideBuffer();
+		return true;
+	}
+
+	bool PlotView::ToggleLaneWeakPeak(int laneIndex)
+	{
+		const bool enabled = !LaneWeakPeak(laneIndex);
+		SetLaneWeakPeak(laneIndex, enabled);
+		return enabled;
+	}
+
+	bool PlotView::ToggleLaneWeakPeakSignal(int laneIndex, const SignalRef& ref)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.WeakPeakEnabled(ref))
+		{
+			lane.RemoveWeakPeakItem(ref);
+			return false;
+		}
+		lane.EnsureWeakPeakItem(ref);
+		return true;
+	}
+
+	bool PlotView::LaneWeakPeakSignalEnabled(int laneIndex, const SignalRef& ref) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].WeakPeakEnabled(ref);
+	}
+
+	bool PlotView::TakePendingWeakPeakBuild(int& laneIndex, std::vector<WeakPeakBuild>& items)
+	{
+		if (m_pendingWeakPeakLane < 0)
+		{
+			return false;
+		}
+		laneIndex = m_pendingWeakPeakLane;
+		items = m_pendingWeakPeakItems;
+		m_pendingWeakPeakLane = -1;
+		m_pendingWeakPeakItems.clear();
+		return true;
+	}
+
+	bool PlotView::SetLaneMeanFilter(int laneIndex, bool enabled)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.meanFilter == enabled)
+		{
+			return false;
+		}
+		lane.meanFilter = enabled;
+		if (enabled)
+		{
+			// 默认只勾选网格内**第一个可见信号**（用户明确要求），其余保持未勾选。
+			if (lane.meanFilterItems.empty())
+			{
+				for (const SignalRef& ref : lane.signals)
+				{
+					const ResolvedSignal resolved = ResolveSignal(ref);
+					if (resolved.data != nullptr && resolved.visible)
+					{
+						lane.EnsureMeanFilterItem(ref);
+						break;
+					}
+				}
+			}
+			lane.meanFilterPanelOpen = true;
+		}
+		else
+		{
+			lane.meanFilterPanelOpen = false;
+		}
+		// 关闭后若本标签页**已无任何预览曲线功能**，立即释放派生曲线数据（缓存 + 后台线程的
+		// thread_local 工作缓冲）—— 否则关掉面板后内存不会下降（用户报告）。
+		if (!enabled)
+		{
+			TrimDerivedCurveDataIfIdle();
+		}
+		// 预建「宽缓冲基底」，避免首次拖动参数滑块时的一次性重建尖峰。
+		RebuildWideBuffer();
+		return true;
+	}
+
+	bool PlotView::ToggleLaneMeanFilterSignal(int laneIndex, const SignalRef& ref)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		if (lane.MeanFilterEnabled(ref))
+		{
+			lane.RemoveMeanFilterItem(ref);
+			return false;
+		}
+		lane.EnsureMeanFilterItem(ref);
+		return true;
+	}
+
+	bool PlotView::LaneMeanFilterSignalEnabled(int laneIndex, const SignalRef& ref) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		return m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].MeanFilterEnabled(ref);
+	}
+
+	bool PlotView::ToggleLaneMeanFilter(int laneIndex)
+	{
+		const bool enabled = !LaneMeanFilter(laneIndex);
+		SetLaneMeanFilter(laneIndex, enabled);
+		return enabled;
+	}
+
+	bool PlotView::TakePendingMeanFilterBuild(int& laneIndex, std::vector<MeanFilterBuild>& items)
+	{
+		if (m_pendingMeanFilterLane < 0)
+		{
+			return false;
+		}
+		laneIndex = m_pendingMeanFilterLane;
+		items = m_pendingMeanFilterItems;
+		m_pendingMeanFilterLane = -1;
+		m_pendingMeanFilterItems.clear();
+		return true;
+	}
+
+	bool PlotView::MeanFilterValueAt(const TimeAxis& axis, const SignalData& signal, int points, int iterations,
+	                                 double time, double& value) const
+	{
+		const int index = FindNearestSample(axis, time);
+		if (index < 0)
+		{
+			return false;
+		}
+		// ⚠️ **绝不能调用整条同步的 `MeanFilterCurveFor`**：光标读数在绘制路径上被调用，
+		//    整条曲线（千万级采样）同步计算会让界面停顿数秒（用户报告"程序被卡住很久"）。
+		//    这里只取「需要的那一个下标 ± 保护带」的窗口，并在窗口很大时走后台异步计算
+		//    （本帧取不到就返回 false，读数暂时不显示该曲线的取值）。
+		std::size_t spanBegin = 0;
+		const std::vector<float>* curve = CurveSpanFor(
+		    DerivedCurveKind::MEAN_FILTER, signal, points, iterations, 0,
+		    static_cast<std::size_t>(index), static_cast<std::size_t>(index) + 1, spanBegin, true);
+		if (curve == nullptr || static_cast<std::size_t>(index) < spanBegin ||
+		    (static_cast<std::size_t>(index) - spanBegin) >= curve->size())
+		{
+			return false;
+		}
+		const float sampled = (*curve)[static_cast<std::size_t>(index) - spanBegin];
+		if (!std::isfinite(sampled))
+		{
+			return false;
+		}
+		value = static_cast<double>(sampled);
+		return true;
+	}
+
+	void PlotView::VisibleIndexRange(const TimeAxis& axis, std::size_t count, std::size_t& begin,
+	                                 std::size_t& end, double timeShift) const
+	{
+		begin = 0;
+		end = count;
+		if (!axis.monotonic || count == 0)
+		{
+			return;
+		}
+		// 时间偏移：采样画在 `t + timeShift` 处，因此落在当前视界内的采样其源时刻区间要整体左移。
+		const std::vector<double>& time = axis.time;
+		begin = static_cast<std::size_t>(
+		    std::lower_bound(time.begin(), time.end(), Tab().ViewMin() - timeShift) - time.begin());
+		if (begin > 0)
+		{
+			--begin;
+		}
+		end = static_cast<std::size_t>(
+		    std::lower_bound(time.begin(), time.end(), Tab().ViewMax() - timeShift) - time.begin());
+		if (end < count)
+		{
+			++end;
+		}
+		end = std::max(end, begin);
+		begin = std::min(begin, count);
+		end = std::min(end, count);
+	}
+
+	const std::vector<float>* PlotView::CurveSpanFor(DerivedCurveKind kind, const SignalData& signal,
+	                                                 int points, int iterations, int amountPercent,
+	                                                 std::size_t begin, std::size_t end,
+	                                                 std::size_t& spanBegin,
+	                                                 bool allowAsyncCompute) const
+	{
+		spanBegin = 0;
+		const std::size_t count = signal.values.size();
+		if (count == 0)
+		{
+			return nullptr;
+		}
+		begin = std::min(begin, count);
+		end = std::min(std::max(end, begin), count);
+		if (end <= begin)
+		{
+			return nullptr;
+		}
+
+		const int kindValue = static_cast<int>(kind);
+		const int safePoints = std::max(0, std::min(points, 1000000));
+		const int safeIterations = std::max(1, std::min(iterations, 1000));
+		const int safeLevel = std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, amountPercent));
+
+		// 对齐到粗网格：轻微平移/缩放时可直接复用同一条窗口，避免每帧重算。
+		const std::size_t grid = std::max<std::size_t>(4096, (end - begin) / 4);
+		const std::size_t alignedBegin = (begin / grid) * grid;
+		const std::size_t alignedEnd = std::min(count, ((end + grid - 1) / grid) * grid);
+
+		CurveKey key;
+		key.signal = &signal;
+		key.kind = kindValue;
+		key.points = safePoints;
+		key.iterations = safeIterations;
+		key.amountPercent = safeLevel;
+
+		// 1) 已有覆盖请求区间的最新条目 → 直接复用（钉住，防止本帧被回收）。
+		if (const CurveEntry* hit = AcquireCoveringCurve(key, begin, end, spanBegin))
+		{
+			return &hit->values;
+		}
+
+		// 2) 代价较大时交后台计算，本帧先用最新旧曲线顶替（双缓冲）。
+		//    这样绘制线程永远不做重计算，拖动滑块/光标/视界/缩放的反馈因此始终跟手。
+		//
+		// ⚠️ **超大信号 + 正在拖动参数：不要每帧都排一次"整条信号"的重算**。
+		//    预览曲线一律按整条信号计算（`[0, count]`，与「构建为新信号」逐位一致）；
+		//    当信号极大（`VERY_BIG_DATA` 有 2576 万采样）时，每条曲线都要扫描上亿个采样，
+		//    后台线程会被**持续占满**（实测把可用内存带宽吃光），反过来把前台绘制拖慢
+		//    （用户报告的"深放大下拖预览滑块非常非常卡"——实测前台每帧 14ms，而绘制本身只要 0.4ms）。
+		//    此时沿用旧曲线，等松手（不再处于拖拽）后再算一次最新的即可：反正整条信号的重算
+		//    本来也追不上滑块速度，拖动期间"冻结"与"每帧重排"在观感上没有区别，但后者会拖慢前台。
+		//    小信号（< `kHugeSignalPreviewSamples`）不受影响，仍保留"边拖边算"的实时预览。
+		if (count > kHugeSignalPreviewSamples && m_dragMode != PlotDragMode::NONE)
+		{
+			if (const CurveEntry* stale = AcquireNewestCurve(key, begin, end, spanBegin))
+			{
+				return &stale->values;
+			}
+			return nullptr;
+		}
+
+		// 计算窗口（含保护带）：既用于同步计算，也用于判断是否值得交后台。
+		std::size_t computedBegin = 0;
+		std::size_t computedEnd = 0;
+		DerivedGuardWindow(kind, alignedBegin, alignedEnd, safePoints, safeIterations, count,
+		                   computedBegin, computedEnd);
+		if (computedEnd <= computedBegin)
+		{
+			return nullptr;
+		}
+		const std::size_t computeSamples = computedEnd - computedBegin;
+		if (allowAsyncCompute && computeSamples > kDerivedAsyncWindowThreshold)
+		{
+			ScheduleCurveJob(key, alignedBegin, alignedEnd, count);
+			if (const CurveEntry* stale = AcquireNewestCurve(key, begin, end, spanBegin))
+			{
+				return &stale->values;
+			}
+			return nullptr;	// 尚无任何可显示曲线：本帧跳过该预览曲线（不阻塞绘制）
+		}
+
+		// 3) 代价很小或需要精确取值 → 同步计算并发布（代价可接受，且保证取值精确）。
+		//    ⚠️ 同步路径也要先做内存判断：窗口虽小，但低内存设备上仍可能失败 ——
+		//    宁可这次不画预览，也不能抛 `bad_alloc` 把进程带走。
+		{
+			bool throttle = false;		// 窗口 ≤ 门槛（65536 采样）→ 无需节流
+			if (!DerivedMemoryAllows(computeSamples, throttle))
+			{
+				return nullptr;
+			}
+		}
+		std::vector<float> values = ComputeDerivedWindow(signal, computedBegin, computedEnd, kindValue,
+		                                                 safePoints, safeIterations, safeLevel, nullptr,
+		                                                 false);
+		const CurveEntry* published =
+		    PublishCurve(key, computedBegin, computedEnd, std::move(values), spanBegin);
+		return (published != nullptr) ? &published->values : nullptr;
+	}
+
+	void PlotView::DerivedGuardWindow(DerivedCurveKind kind, std::size_t alignedBegin,
+	                                  std::size_t alignedEnd, int points, int iterations,
+	                                  std::size_t count, std::size_t& begin, std::size_t& end) const
+	{
+		// 保护带取窗口长度的 1/8（夹在 4096~65536）：弱峰调整的修正沿相邻极值向内传播，
+		// 1/8 个可见宽度足以覆盖真实信号的极值间距。
+		// 均值滤波必须额外**覆盖滤波半径**：N 阶共向外传播 X*N 个采样，否则窗口边界取值
+		// 会与「整条曲线」不同（边界上可用采样数更少）。
+		std::size_t guard =
+		    std::clamp((alignedEnd - alignedBegin) / 8, std::size_t(4096), kDerivedCurveGuardMax);
+		if (kind == DerivedCurveKind::MEAN_FILTER)
+		{
+			const std::size_t reach =
+			    static_cast<std::size_t>(points + 1) * static_cast<std::size_t>(iterations) + 64u;
+			guard = std::clamp(std::max(guard, reach), std::size_t(4096), kDerivedCurveGuardMax);
+		}
+		begin = (alignedBegin > guard) ? (alignedBegin - guard) : 0;
+		end = std::min(count, alignedEnd + guard);
+	}
+
+	const PlotView::CurveEntry* PlotView::AcquireCoveringCurve(const CurveKey& key, std::size_t begin,
+	                                                           std::size_t end,
+	                                                           std::size_t& spanBegin) const
+	{
+		std::lock_guard<std::mutex> lock(m_curveMutex);
+		const CurveEntryPtr* best = nullptr;
+		for (const CurveEntryPtr& entry : m_curveEntries)
+		{
+			if (entry->key == key && entry->begin <= begin && entry->end >= end)
+			{
+				if (best == nullptr || entry->serial > (*best)->serial)
+				{
+					best = &entry;
+				}
+			}
+		}
+		if (best == nullptr)
+		{
+			return nullptr;
+		}
+		m_curvePins.push_back(*best);	// 钉住：保证本帧内指针有效
+		spanBegin = (*best)->begin;
+		return best->get();
+	}
+
+	const PlotView::CurveEntry* PlotView::AcquireNewestCurve(const CurveKey& key, std::size_t begin,
+	                                                         std::size_t end,
+	                                                         std::size_t& spanBegin) const
+	{
+		std::lock_guard<std::mutex> lock(m_curveMutex);
+		// ⚠️ **只按「信号 + 曲线种类」匹配**（忽略参数）：拖动参数滑块时每帧参数都在变，
+		// 若要求键完全相同就永远找不到"上一帧的曲线"，于是本帧无曲线可画 → **预览曲线闪烁**、
+		// 甚至短暂消失（用户报告的"滑动滑块时曲线消失一会儿又出现"）。
+		// 旧曲线只是参数略旧，按采样下标映射位置依然完全正确，先顶上再等后台算好新曲线，
+		// 视觉上就是平滑过渡而不是闪烁。
+		//
+		// 优先挑「窗口覆盖所需区间」的：覆盖不到时曲线会缺一段（看起来像被切断）。
+		const CurveEntryPtr* newest = nullptr;
+		const CurveEntryPtr* newestCovering = nullptr;
+		for (const CurveEntryPtr& entry : m_curveEntries)
+		{
+			if (entry->key.signal != key.signal || entry->key.kind != key.kind)
+			{
+				continue;
+			}
+			if (newest == nullptr || entry->serial > (*newest)->serial)
+			{
+				newest = &entry;
+			}
+			if (entry->begin <= begin && entry->end >= end &&
+			    (newestCovering == nullptr || entry->serial > (*newestCovering)->serial))
+			{
+				newestCovering = &entry;
+			}
+		}
+		const CurveEntryPtr* pick = (newestCovering != nullptr) ? newestCovering : newest;
+		if (pick == nullptr)
+		{
+			return nullptr;
+		}
+		m_curvePins.push_back(*pick);
+		spanBegin = (*pick)->begin;
+		return pick->get();
+	}
+
+	const PlotView::CurveEntry* PlotView::PublishCurve(const CurveKey& key, std::size_t begin,
+	                                                   std::size_t end, std::vector<float>&& values,
+	                                                   std::size_t& spanBegin) const
+	{
+		std::shared_ptr<CurveEntry> entry = std::make_shared<CurveEntry>();
+		entry->key = key;
+		entry->begin = begin;
+		entry->end = end;
+		entry->values = std::move(values);
+		{
+			std::lock_guard<std::mutex> lock(m_curveMutex);
+			entry->serial = ++m_curveSerial;
+			m_curveEntries.push_back(entry);
+		}
+		m_curvePins.push_back(entry);
+		spanBegin = begin;
+		return entry.get();
+	}
+
+	bool PlotView::CurveJobIsStale(const CurveKey& key, std::uint64_t requestSerial) const
+	{
+		std::lock_guard<std::mutex> lock(m_curveMutex);
+		const auto found = m_curveLatest.find(std::make_pair(key.signal, key.kind));
+		if (found == m_curveLatest.end())
+		{
+			return true;		// 已经被清理（例如预览被关闭）→ 没有意义，直接作废
+		}
+		return found->second != requestSerial;
+	}
+
+	std::size_t PlotView::DerivedMinimumBytes(std::size_t samples)
+	{
+		// 输出曲线本体（float，占 1 份）+ 内部工作缓冲（「弱峰调整」实测 ≈34 B/采样，
+		// 含两个 float 工作缓冲与极值表）——取 48 B/采样作为「连一条曲线都装不下」的门槛。
+		return samples * 48u + (64u * 1024u * 1024u);
+	}
+
+	bool PlotView::DerivedMemoryAllows(std::size_t samples, bool& throttle) const
+	{
+		throttle = false;
+		const std::size_t minimum = DerivedMinimumBytes(samples);
+		const std::size_t available = AvailablePhysicalBytes();
+		if (available < minimum)
+		{
+			NotifyDerivedLowMemory();
+			return false;
+		}
+		// 低于「舒适线」（最小需求的 4 倍）→ 低内存模式：串行 + 节流，慢慢算完。
+		if (available < minimum * 4u)
+		{
+			throttle = true;
+		}
+		return true;
+	}
+
+	void PlotView::NotifyDerivedLowMemory() const
+	{
+		if (m_curveLowMemoryWarned)
+		{
+			return;		// 同一轮只提示一次，避免反复弹窗
+		}
+		m_curveLowMemoryWarned = true;
+		const HWND host = m_host;
+		if (host != nullptr)
+		{
+			PostMessageW(host, kMessagePlotLowMemory, 0, 0);
+		}
+	}
+
+	void PlotView::ScheduleCurveJob(const CurveKey& key, std::size_t alignedBegin,
+	                                std::size_t alignedEnd, std::size_t count) const
+	{
+		std::size_t windowBegin = 0;
+		std::size_t windowEnd = 0;
+		DerivedGuardWindow(static_cast<DerivedCurveKind>(key.kind), alignedBegin, alignedEnd, key.points,
+		                   key.iterations, count, windowBegin, windowEnd);
+		if (windowEnd <= windowBegin)
+		{
+			return;
+		}
+		// 「大任务」判据：窗口采样数超过大信号门槛（此时工作缓冲会到数百 MB 量级）。
+		const std::size_t windowSamples = windowEnd - windowBegin;
+		const bool huge = (windowSamples >= kHugeSignalPreviewSamples);
+		int hugeLimit = 1;
+		// ⚠️ **内存严重不足时根本不入队**（连一条曲线都装不下）：告警一次并直接放弃本次计算。
+		//    这样“低内存设备”不会因为换页而把整机拖死，也不会抛 `bad_alloc` 逸出线程导致崩溃。
+		if (huge)
+		{
+			bool throttle = false;
+			if (!DerivedMemoryAllows(windowSamples, throttle))
+			{
+				return;
+			}
+			hugeLimit = throttle ? 1 : 2;
+		}
+		{
+			std::lock_guard<std::mutex> lock(m_curveMutex);
+			// 新的计算请求 ⇒ 取消标志必须清零（此前可能因关闭预览/结构变化而被置位）。
+			m_curveCancelAll.store(false, std::memory_order_relaxed);
+			// ⚠️ **幂等**：边沿统计会在“曲线还没算好”时每帧请求一次整条曲线的计算。
+			//    如果每次都当作新请求（自增序号），正在算的那份就会被判为过时而退出 ——
+			//    于是永远算不完（请求 → 作废 → 重请求 的死循环）。
+			for (const CurveKey& running : m_curveRunningKeys)
+			{
+				if (running == key)
+				{
+					return;		// 同一份曲线正在算，无需重复排队
+				}
+			}
+			for (const CurveJob& pending : m_curveJobs)
+			{
+				if (pending.key == key)
+				{
+					return;	// 同一份曲线已在队列里等待
+				}
+			}
+			// 全局请求序号：这次请求之后，同一 (信号, 种类) 的旧任务就都过时了。
+			const std::uint64_t requestSerial = ++m_curveRequestSerial;
+			m_curveLatest[std::make_pair(key.signal, key.kind)] = requestSerial;
+			// 同一「信号 + 曲线种类」的**其它参数**的待算任务全部移除：参数已被取代，
+			// 正在计算的那个会在下一阶处看到自己已过时并**立即退出**。
+			for (auto iterator = m_curveJobs.begin(); iterator != m_curveJobs.end();)
+			{
+				if (iterator->key.signal == key.signal && iterator->key.kind == key.kind)
+				{
+					iterator = m_curveJobs.erase(iterator);
+				}
+				else
+				{
+					++iterator;
+				}
+			}
+			CurveJob job;
+			job.key = key;
+			job.windowBegin = windowBegin;
+			job.windowEnd = windowEnd;
+			job.generation = m_curveGeneration;
+			job.requestSerial = requestSerial;
+			job.huge = huge;
+			job.hugeLimit = hugeLimit;
+			m_curveJobs.push_back(job);
+		}
+		EnsureCurveWorker();
+		m_curveCv.notify_all();
+	}
+
+	void PlotView::EnsureCurveWorker() const
+	{
+		if (!m_curveWorkers.empty())
+		{
+			return;
+		}
+		// **多核并行**：后台线程池并发计算多条派生曲线（5 个网格各一条时，
+		// 串行要 5×368ms，并行只要约 1×368ms），预览曲线因此能很快出现。
+		// 线程数 = 硬件并发 - 1（给 UI/绘制线程留一个核），夹在 1~4。
+		unsigned int hardware = std::thread::hardware_concurrency();
+		int workers = static_cast<int>(hardware == 0 ? 2u : hardware) - 1;
+		workers = std::max(1, std::min(workers, 4));
+		m_curveWorkerStop = false;
+		m_curveWorkers.reserve(static_cast<std::size_t>(workers));
+		for (int index = 0; index < workers; ++index)
+		{
+			m_curveWorkers.emplace_back([this]() { CurveWorkerLoop(); });
+		}
+	}
+
+	void PlotView::StopCurveWorker() const
+	{
+		// 先请所有在算任务尽快退出（每阶 / 每 1M 采样检查一次），再等线程结束 ——
+		// 这是「过时任务立即清退并释放资源」的关键一步：千万级采样的一条曲线工作缓冲
+		// 可达数百 MB，必须尽早归还。
+		m_curveCancelAll.store(true, std::memory_order_relaxed);
+		if (m_curveWorkers.empty())
+		{
+			return;
+		}
+		{
+			std::lock_guard<std::mutex> lock(m_curveMutex);
+			m_curveWorkerStop = true;
+			m_curveJobs.clear();
+			m_curveLatest.clear();
+			m_curveRunningKeys.clear();
+		}
+		m_curveCv.notify_all();
+		for (std::thread& worker : m_curveWorkers)
+		{
+			if (worker.joinable())
+			{
+				worker.join();
+			}
+		}
+		m_curveWorkers.clear();
+		m_curveHugeActive = 0;
+	}
+
+	void PlotView::CurveWorkerLoop() const
+	{
+		// 后台计算线程的优先级降到「低于正常」：派生曲线计算是**可延迟的后台工作**，
+		// 绝不能让它在拖动时与 UI / 绘制线程抢 CPU。降低优先级后，只要 UI 线程要运行，
+		// 系统就会优先调度 UI；计算只在 UI 空闲时占用 CPU，从而保证交互始终跟手
+		//（用户明确要求"无论如何 UI 及控件的响应需要是跟手的"）。
+		SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
+		for (;;)
+		{
+			CurveJob job;
+			{
+				std::unique_lock<std::mutex> lock(m_curveMutex);
+				m_curveCv.wait(lock, [this]()
+				               { return m_curveWorkerStop || !m_curveJobs.empty(); });
+				if (m_curveJobs.empty())
+				{
+					return;	// 仅在 stop 且队列为空时到达
+				}
+				job = m_curveJobs.front();
+				// ⚠️ **大窗口任务不能无限并发**：一条「整段信号」的弱峰调整工作缓冲可达数百 MB，
+				//    多个同时算就是 GB 级峰值（用户报告的 4.4GB）。上限由调度时的内存压力决定：
+				//    内存充足时允许 2 条（仍然很快，但峰值封顶）；内存紧张时只允许 1 条。
+				if (job.huge && m_curveHugeActive >= std::max(1, job.hugeLimit))
+				{
+					m_curveCv.wait_for(lock, std::chrono::milliseconds(5));
+					continue;
+				}
+				m_curveJobs.pop_front();
+				if (job.generation != m_curveGeneration)
+				{
+					continue;	// 代次已变化：丢弃过期任务
+				}
+				if (job.huge)
+				{
+					++m_curveHugeActive;
+				}
+				// 记录“正在计算的曲线键”：`ScheduleCurveJob` 靠它保持幂等
+				//（边沿统计会每帧请求同一份整条曲线，不能每次都当作新请求）。
+				m_curveRunningKeys.push_back(job.key);
+			}
+
+			// 计算在锁外进行：读取的采样在「结构未变」期间只读、且地址稳定
+			//（结构变化前宿主会先 `PauseDerivedAsync`）。
+			// ⚠️ 传入取消标志：一旦同一 (信号, 种类) 有了更新的请求、或发生了结构变化/关闭预览，
+			//    计算会在下一阶（或每 1M 采样）处**立即退出**，尽早归还工作缓冲。
+			bool throttle = false;
+			if (job.huge)
+			{
+				DerivedMemoryAllows(job.windowEnd - job.windowBegin, throttle);
+			}
+			std::vector<float> values = ComputeDerivedWindow(
+			    *job.key.signal, job.windowBegin, job.windowEnd, job.key.kind, job.key.points,
+			    job.key.iterations, job.key.amountPercent, &m_curveCancelAll, throttle);
+
+			if (job.huge)
+			{
+				std::lock_guard<std::mutex> lock(m_curveMutex);
+				m_curveHugeActive = std::max(0, m_curveHugeActive - 1);
+				for (auto iterator = m_curveRunningKeys.begin(); iterator != m_curveRunningKeys.end();
+				     ++iterator)
+				{
+					if (*iterator == job.key)
+					{
+						m_curveRunningKeys.erase(iterator);
+						break;
+					}
+				}
+				m_curveCv.notify_all();
+			}
+			else
+			{
+				std::lock_guard<std::mutex> lock(m_curveMutex);
+				for (auto iterator = m_curveRunningKeys.begin(); iterator != m_curveRunningKeys.end();
+				     ++iterator)
+				{
+					if (*iterator == job.key)
+					{
+						m_curveRunningKeys.erase(iterator);
+						break;
+					}
+				}
+			}
+
+			// ⚠️ **过时结果一律不发布，并立即可回收**：
+			//    * 代次变化（结构变化）→ 丢弃；
+			//    * 同一 (信号, 种类) 已有更新的请求 → 本结果参数已过时，丢弃（后台很快会有新的）。
+			//    * 被取消（`m_curveCancelAll`）→ 曲线可能只算了一部分，绝不能发布。
+			if (m_curveCancelAll.load(std::memory_order_relaxed) ||
+			    CurveJobIsStale(job.key, job.requestSerial))
+			{
+				continue;
+			}
+			{
+				std::lock_guard<std::mutex> lock(m_curveMutex);
+				if (job.generation != m_curveGeneration)
+				{
+					continue;	// 计算期间发生了结构变化：丢弃，避免发布过期结果
+				}
+				if (values.empty())
+				{
+					continue;
+				}
+				std::shared_ptr<CurveEntry> entry = std::make_shared<CurveEntry>();
+				entry->key = job.key;
+				entry->begin = job.windowBegin;
+				entry->end = job.windowEnd;
+				entry->serial = ++m_curveSerial;
+				entry->values = std::move(values);
+				m_curveEntries.push_back(std::move(entry));
+			}
+
+			// 通知宿主重绘：下一帧会取到刚发布的曲线（双缓冲切换）。
+			m_curveSceneDirty.store(true, std::memory_order_relaxed);
+			const HWND host = m_host;
+			if (host != nullptr)
+			{
+				PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
+			}
+		}
+	}
+
+	void PlotView::PruneCurveEntriesLocked() const
+	{
+		// 1) 去掉被「同键、更新、且完全覆盖」的条目取代的旧条目。
+		std::deque<CurveEntryPtr> kept;
+		for (const CurveEntryPtr& entry : m_curveEntries)
+		{
+			bool superseded = false;
+			for (const CurveEntryPtr& other : m_curveEntries)
+			{
+				if (other.get() == entry.get())
+				{
+					continue;
+				}
+				if (other->key == entry->key && other->serial > entry->serial &&
+				    other->begin <= entry->begin && other->end >= entry->end)
+				{
+					superseded = true;
+					break;
+				}
+			}
+			if (!superseded)
+			{
+				kept.push_back(entry);
+			}
+		}
+		m_curveEntries.swap(kept);
+
+		// 2) 条目数与总字节数双重约束（最旧优先淘汰）。
+		const auto bytes = [this]() -> std::size_t
+		{
+			std::size_t total = 0;
+			for (const CurveEntryPtr& entry : m_curveEntries)
+			{
+				total += entry->values.size() * sizeof(float);
+			}
+			return total;
+		};
+		while (!m_curveEntries.empty() &&
+		       (m_curveEntries.size() > kCurveSpanCacheLimit || bytes() > kCurveSpanCacheMaxBytes))
+		{
+			m_curveEntries.pop_front();
+		}
+	}
+
+	const std::vector<float>& PlotView::MeanFilterCurveFor(const SignalData& signal, int points,
+	                                                      int iterations) const
+	{
+		const int radius = std::max(0, points);
+		const int stages = std::max(1, iterations);
+		for (const MeanCurveEntry& entry : m_meanCurveCache)
+		{
+			if (entry.signal == &signal && entry.points == radius && entry.iterations == stages)
+			{
+				return entry.values;
+			}
+		}
+
+		MeanCurveEntry entry;
+		entry.signal = &signal;
+		entry.points = radius;
+		entry.iterations = stages;
+		// 与「构建为新信号」共用同一实现（Utilities 内的自由函数），
+		// 因此预览曲线与构建出的采样值逐位一致。
+		ComputeMovingAverageIterated(signal.values, radius, stages, entry.values);
+
+		m_meanCurveCache.push_back(std::move(entry));
+		return m_meanCurveCache.back().values;
+	}
+
+	const std::vector<float>& PlotView::WeakPeakCurveFor(const SignalData& signal,
+	                                                      int amountPercent, int iterations) const
+	{
+		const int level = std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, amountPercent));
+		const int stages = std::max(kWeakPeakIterationsMin, std::min(kWeakPeakIterationsMaxLimit, iterations));
+		for (const WeakPeakCurveEntry& entry : m_weakPeakCurveCache)
+		{
+			if (entry.signal == &signal && entry.amountPercent == level && entry.iterations == stages)
+			{
+				return entry.values;
+			}
+		}
+
+		WeakPeakCurveEntry entry;
+		entry.signal = &signal;
+		entry.amountPercent = level;
+		entry.iterations = stages;
+		// 与「构建为新信号」共用同一实现（Utilities 内的自由函数），
+		// 因此预览曲线与构建出的采样值逐位一致。
+		ComputeWeakPeakAdjust(signal.values, static_cast<double>(level) / 100.0, stages, entry.values);
+
+		m_weakPeakCurveCache.push_back(std::move(entry));
+		return m_weakPeakCurveCache.back().values;
+	}
+
+	bool PlotView::WeakPeakValueAt(const TimeAxis& axis, const SignalData& signal, int amountPercent,
+	                                int iterations, double time, double& value) const
+	{
+		const int index = FindNearestSample(axis, time);
+		if (index < 0)
+		{
+			return false;
+		}
+		std::size_t spanBegin = 0;
+		const std::vector<float>* curve = CurveSpanFor(
+		    DerivedCurveKind::WEAK_PEAK, signal, 0, iterations, amountPercent,
+		    static_cast<std::size_t>(index), static_cast<std::size_t>(index) + 1, spanBegin);
+		if (curve == nullptr || static_cast<std::size_t>(index) < spanBegin ||
+		    (static_cast<std::size_t>(index) - spanBegin) >= curve->size())
+		{
+			return false;
+		}
+		const float sampled = (*curve)[static_cast<std::size_t>(index) - spanBegin];
+		if (!std::isfinite(sampled))
+		{
+			return false;
+		}
+		value = static_cast<double>(sampled);
+		return true;
+	}
+
+	void PlotView::RequestEdgeScanFrame() const
+	{
+		// 统计还没扫完时主动请宿主再送一帧 —— 否则用户不移动鼠标就不会有任何重绘，
+		// 预算也就永远不推进（用户报告："面板过去很久都一直显示统计中，
+		// 只有当鼠标瞄到浮动面板上时才会显示统计好的值"）。
+		// 与派生曲线就绪用同一条消息（宿主只失效绘图区、不置脏，代价极小）。
+		const HWND host = m_host;
+		if (host != nullptr)
+		{
+			PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
+		}
+	}
+
+	void PlotView::InvalidateEdgeScansFor(const SignalData* signal, bool centreOnly)
+	{
+		// ⚠️ **定向作废**：只有被改动的那个信号（并且只限需要的那一类）要重算，
+		// 其它信号的键没有变化、累计的块和依然有效 → 必须原样保留。
+		// 否则（过去用 `m_edgeScans.clear()`）会连**普通边沿计数**与**其它信号的中心轴统计**
+		// 一起丢掉，于是两个浮动面板里的每一个数字都要从头重新扫描：
+		// 用户报告“改变一个信号的中心轴参数，其它未改变参数的统计也重新计算了”。
+		if (signal == nullptr)
+		{
+			return;
+		}
+		m_edgeScans.erase(std::remove_if(m_edgeScans.begin(), m_edgeScans.end(),
+		                                 [signal, centreOnly](const EdgeScanState& state)
+		                                 {
+			                                 if (state.signal != signal)
+			                                 {
+				                                 return false;	// 别的信号：原样保留
+			                                 }
+			                                 return !centreOnly || state.centre;
+		                                 }),
+		                  m_edgeScans.end());
+	}
+
+	void PlotView::EdgeScanFor(const TimeAxis& axis, const SignalData& signal, const SignalStyle& style,
+	                           bool centre, double threshold, int points, int iterations, bool hasRange,
+	                           double rangeMin, double rangeMax, std::size_t& rising, std::size_t& falling,
+	                           bool& complete) const
+	{
+		rising = 0;
+		falling = 0;
+		complete = false;
+
+		const std::size_t count = signal.values.size();
+		if (count < 2)
+		{
+			complete = true;
+			return;
+		}
+		const bool monotonic = axis.monotonic;
+		// 非单调时间轴无法用「采样对下标区间」表达统计范围，只能逐点按时间过滤 →
+		// 此时区间必须进键（否则会混用别的区间结果）。
+		const bool rangeInKey = hasRange && !monotonic;
+		const std::uint64_t styleKey = EdgeStyleKey(style);
+		const int safePoints = std::max(0, std::min(points, 1000000));
+		const int safeIterations = std::max(1, std::min(iterations, 1000));
+		const bool mirrored = style.mirrorHorizontal;
+		const bool transform = (style.gain != 1.0f || style.absolute || style.mirrorVertical ||
+		                        style.offsetY != 0.0f);
+
+		// 请求的「采样对」区间 [pairFirst, pairLast]（pair k = 采样 k-1 → k，k ≥ 1）。
+		// ⚠️ 只有**两个端点都落在区间内**的采样对才计入（非单调时由 deltaAt 过滤）。
+		std::size_t pairFirst = 1;
+		std::size_t pairLast = count - 1;
+		if (hasRange && monotonic)
+		{
+			std::size_t indexBegin = 0;
+			std::size_t indexEnd = 0;
+			EdgeIndexRange(axis, count, hasRange, rangeMin, rangeMax, indexBegin, indexEnd);
+			pairFirst = (indexBegin + 1 < count) ? (indexBegin + 1) : count;
+			pairLast = (indexEnd > 0) ? (indexEnd - 1) : 0;
+			if (pairLast < pairFirst)
+			{
+				complete = true;
+				return;
+			}
+		}
+
+		// ---- 定位累积状态 -------------------------------------------------------
+		EdgeScanState* state = nullptr;
+		for (EdgeScanState& candidate : m_edgeScans)
+		{
+			if (candidate.axis == &axis && candidate.signal == &signal && candidate.centre == centre &&
+			    candidate.styleKey == styleKey && candidate.points == safePoints &&
+			    candidate.iterations == safeIterations && candidate.hasRange == rangeInKey &&
+			    (!rangeInKey || (candidate.rangeMin == rangeMin && candidate.rangeMax == rangeMax)))
+			{
+				state = &candidate;
+				break;
+			}
+		}
+		if (state == nullptr)
+		{
+			if (m_edgeScans.size() >= kEdgeScanStateLimit)
+			{
+				// ⚠️ 超限时**优先淘汰「已扫完」的最旧状态**（它重算很快、而且通常已经不需要再变），
+				//    绝不淘汰正在推进的那个 —— 否则其它信号会被迫从头重扫
+				//（那正是“改一个参数、其它几个信号也重新统计”这类现象）。
+				std::size_t victim = 0;
+				bool foundVictim = false;
+				for (std::size_t index = 0; index < m_edgeScans.size(); ++index)
+				{
+					if (m_edgeScans[index].complete)
+					{
+						victim = index;
+						foundVictim = true;
+						break;
+					}
+				}
+				if (!foundVictim)
+				{
+					victim = 0;
+				}
+				m_edgeScans.erase(m_edgeScans.begin() + static_cast<std::ptrdiff_t>(victim));
+			}
+			EdgeScanState created;
+			created.axis = &axis;
+			created.signal = &signal;
+			created.centre = centre;
+			created.styleKey = styleKey;
+			created.points = safePoints;
+			created.iterations = safeIterations;
+			created.hasRange = rangeInKey;
+			created.rangeMin = rangeMin;
+			created.rangeMax = rangeMax;
+			created.threshold = threshold;
+			const std::size_t blocks = (count - 1) / kEdgeBlockSamples + 2;
+			created.blockRising.assign(blocks, 0);
+			created.blockFalling.assign(blocks, 0);
+			created.justReset = true;
+			m_edgeScans.push_back(std::move(created));
+			state = &m_edgeScans.back();
+		}
+		else if (!centre && state->threshold != threshold)
+		{
+			// 阈值变了（横向光标正在拖动）：**就地重新开始**，不新建条目（避免拖动时状态爆炸）。
+			// ⚠️ 本 tick 不展示部分值（`justReset`）：部分计数每帧都会被重置，
+			//    显示出来就是"错误且不更新的数字"（用户报告过这个现象）。
+			state->threshold = threshold;
+			state->scannedPair = 1;
+			state->rising = 0;
+			state->falling = 0;
+			state->complete = false;
+			state->justReset = true;
+			std::fill(state->blockRising.begin(), state->blockRising.end(), 0);
+			std::fill(state->blockFalling.begin(), state->blockFalling.end(), 0);
+		}
+
+		// ---- 中心轴：**就地**计算所需的那一小段均值滤波曲线 ---------------------
+		// ⚠️ 过去这里用 `AcquireCoveringCurve`/`ScheduleCurveJob` 拿**整条**曲线，带来两个问题：
+		//    1. 千万级信号的一条曲线 ≈103MB，多条信号叠加会超出曲线缓存预算（768MB）→ 条目被
+		//       淘汰后该信号被判为“曲线未就绪”，界面显示“统计中…”并从头重扫 ——
+		//       **偶发**（取决于当时缓存里积了多少条目，用户报告“改一个参数其它几个信号也重新统计”）；
+		//    2. 几个信号的统计通过这块共享缓存互相牵连。
+		//    现在只算「当前扫描块 ± 滤波半径」：`points * iterations` 就足以让块内取值与整条曲线
+		//    完全一致（迭代 N 次、半径 X 的均值滤波最多向两侧传播 X*N 个采样），内存只有几十 KB，
+		//    且与其它信号、其它曲线彻底解耦。
+		std::size_t localReach = 0;
+		if (centre)
+		{
+			localReach = static_cast<std::size_t>(safePoints) * static_cast<std::size_t>(safeIterations) + 2u;
+			localReach = std::min(localReach, kDerivedCurveGuardMax);
+		}
+		const std::vector<double>& values = signal.values;
+		const bool filterByTime = hasRange && !monotonic;
+
+		/** 把显示下标区间映射为源下标区间（水平镜像时头尾对调）。 */
+		const auto toSourceRange = [&](std::size_t displayFirst, std::size_t displayLast,
+		                               std::size_t& srcFirst, std::size_t& srcLast)
+		{
+			if (mirrored)
+			{
+				srcFirst = (count - 1) - displayLast;
+				srcLast = (count - 1) - displayFirst;
+			}
+			else
+			{
+				srcFirst = displayFirst;
+				srcLast = displayLast;
+			}
+		};
+		/** 确保本地曲线覆盖显示下标区间 [displayFirst, displayLast]（含端点）。 */
+		const auto ensureLocalCurve = [&](std::size_t displayFirst, std::size_t displayLast) -> bool
+		{
+			if (!centre)
+			{
+				return true;
+			}
+			std::size_t srcFirst = 0;
+			std::size_t srcLast = 0;
+			toSourceRange(displayFirst, displayLast, srcFirst, srcLast);
+			if (state->localValid && state->localBegin <= srcFirst && state->localEnd > srcLast)
+			{
+				return true;
+			}
+			const std::size_t windowBegin = (srcFirst > localReach) ? (srcFirst - localReach) : 0;
+			std::size_t windowEnd = std::min(count, srcLast + 1u + localReach);
+			// 至少覆盖 8 个扫描块：迭代均值滤波每算一次窗口要 O(窗口 × 迭代次数)，
+			// 只覆盖一个块会让参数较大时每块都重算一遍（摊薄到 8 个块上就便宜得多）。
+			const std::size_t minSpan = kEdgeBlockSamples * 8u;
+			windowEnd = std::min(count, std::max(windowEnd, windowBegin + minSpan));
+			if (windowEnd <= windowBegin)
+			{
+				return false;
+			}
+			std::vector<float> local =
+			    ComputeDerivedWindow(signal, windowBegin, windowEnd,
+			                         static_cast<int>(DerivedCurveKind::MEAN_FILTER), safePoints,
+			                         safeIterations, 0, nullptr, false);
+			if (local.size() != (windowEnd - windowBegin))
+			{
+				++m_edgeScanLocalCurveFails;
+				return false;		// 计算失败（例如内存不足）：本帧不推进，下帧重试
+			}
+			state->localCurve = std::move(local);
+			state->localBegin = windowBegin;
+			state->localEnd = windowEnd;
+			state->localValid = true;
+			// 本地窗口的计算成本也计入预算（按「采样数 × 迭代次数」折算），避免一帧算太多。
+			const std::size_t cost =
+			    (windowEnd - windowBegin) * static_cast<std::size_t>(safeIterations);
+			m_edgeScanBudget -= std::min(m_edgeScanBudget, cost);
+			return true;
+		};
+
+		// 判定基准：**绘制后**的值相对阈值 / 中心曲线的偏差（区间之外 / 缺失值 → NaN）。
+		const auto deltaAt = [&](std::size_t index) -> double
+		{
+			const double nan = std::numeric_limits<double>::quiet_NaN();
+			if (index >= count)
+			{
+				return nan;
+			}
+			if (filterByTime && index < axis.time.size())
+			{
+				const double time = axis.time[index];
+				if (time < rangeMin || time > rangeMax)
+				{
+					return nan;
+				}
+			}
+			const std::size_t sourceIndex = mirrored ? ((count - 1) - index) : index;
+			if (sourceIndex >= count)
+			{
+				return nan;
+			}
+			const double raw = values[sourceIndex];
+			if (!std::isfinite(raw))
+			{
+				return nan;
+			}
+			const double drawn = transform ? ApplyDrawTransform(style, raw) : raw;
+			if (!std::isfinite(drawn))
+			{
+				return nan;
+			}
+			if (!centre)
+			{
+				return drawn - threshold;
+			}
+			if (!state->localValid || sourceIndex < state->localBegin ||
+			    sourceIndex >= state->localEnd)
+			{
+				return nan;
+			}
+			const float centerSample = state->localCurve[sourceIndex - state->localBegin];
+			if (!std::isfinite(centerSample))
+			{
+				return nan;
+			}
+			const double drawnCenter =
+			    transform ? ApplyDrawTransform(style, static_cast<double>(centerSample))
+			              : static_cast<double>(centerSample);
+			return std::isfinite(drawnCenter) ? (drawn - drawnCenter) : nan;
+		};
+
+		// ---- 推进（受「每帧总量 + 每状态配额」双重限制）--------------------------
+		// ⚠️ 预算在 `Paint` 开头**按帧**重置（不再按 `GetTickCount64()` 分桶）：系统时钟
+		//    粒度约 15.6ms，帧率一高就会在同一 tick 内连画多帧而完全不推进 —— 用户报告的
+		//    “按住横向光标不动时统计卡在统计中”“回车确认参数后不移动鼠标就一直停在部分值”
+		//    就是这个原因。
+		// ⚠️ 同时**每个状态各自持有配额**：否则推进总从列表第一个状态扫起，多条信号时
+		//    只有第一条有进展、其余长期显示“统计中…”（用户报告“很多项都停在统计中不更新”）。
+		const bool suppressPartial = state->justReset && !state->complete;
+		if (!state->complete && !state->blockRising.empty())
+		{
+			const std::size_t activeStates = std::max<std::size_t>(1, m_edgeScans.size());
+			const std::size_t share = std::max<std::size_t>(kEdgeScanFairShare, activeStates);
+			const std::size_t perState =
+			    std::max<std::size_t>(kEdgeScanPairsPerStateMin, kEdgeScanPairsPerFrame / share);
+			if (state->pumpedFrame != m_edgeScanFrame)
+			{
+				state->pumpedFrame = m_edgeScanFrame;
+				state->pumpedPairs = 0;
+			}
+			std::size_t quota = (perState > state->pumpedPairs) ? (perState - state->pumpedPairs) : 0;
+			quota = std::min(quota, m_edgeScanBudget);
+			if (quota > 0)
+			{
+				state->justReset = false;
+				// 快路径：时间单调、无水平镜像、无「调整」变换、非中心轴 ⇒ 直接比较采样值与阈值。
+				// （NaN 与任何数比较都为 false ⇒ 天然满足"NaN 不参与且打断连续"的语义。）
+				// 绝大多数信号都走这条，单次预算的耗时因此从 ~18ms 降到 ~2ms。
+				const bool plainFast = monotonic && !mirrored && !transform && !centre;
+				std::size_t scanned = 0;
+				std::size_t pair = state->scannedPair;
+				std::size_t block = (pair > 0) ? ((pair - 1) / kEdgeBlockSamples) : 0;
+				while (pair < count && scanned < quota && m_edgeScanBudget > 0)
+				{
+					const std::size_t blockFirst = block * kEdgeBlockSamples + 1;
+					const std::size_t blockLast = std::min(count - 1, (block + 1) * kEdgeBlockSamples);
+					const std::size_t from = std::max(pair, blockFirst);
+					const std::size_t avail = std::min(quota - scanned, m_edgeScanBudget);
+					const std::size_t to = std::min(blockLast, from + avail - 1);
+					if (to < from)
+					{
+						break;
+					}
+					// 中心轴：先确保本地区间曲线覆盖本块（含两端各一个采样点，供边界比较）。
+					if (!ensureLocalCurve(from - 1, to))
+					{
+						break;		// 算不出来（内存不足等）：本帧到此为止，下帧重试
+					}
+					std::size_t localRising = 0;
+					std::size_t localFalling = 0;
+					if (plainFast)
+					{
+						double previous = values[from - 1] - threshold;
+						for (std::size_t index = from; index <= to; ++index)
+						{
+							const double current = values[index] - threshold;
+							if (previous < 0.0 && current >= 0.0)
+							{
+								++localRising;
+							}
+							else if (previous > 0.0 && current <= 0.0)
+							{
+								++localFalling;
+							}
+							previous = current;
+						}
+					}
+					else
+					{
+						double previous = deltaAt(from - 1);
+						for (std::size_t index = from; index <= to; ++index)
+						{
+							const double current = deltaAt(index);
+							if (std::isfinite(previous) && std::isfinite(current))
+							{
+								if (previous < 0.0 && current >= 0.0)
+								{
+									++localRising;
+								}
+								else if (previous > 0.0 && current <= 0.0)
+								{
+									++localFalling;
+								}
+							}
+							previous = current;
+						}
+					}
+					if (block < state->blockRising.size())
+					{
+						state->blockRising[block] += localRising;
+						state->blockFalling[block] += localFalling;
+					}
+					state->rising += localRising;
+					state->falling += localFalling;
+					scanned += (to - from + 1);
+					pair = to + 1;
+					if (to == blockLast)
+					{
+						++block;
+					}
+				}
+				state->scannedPair = pair;
+				state->complete = (pair >= count);
+				if (state->complete)
+				{
+					// 扫完后**释放**本地曲线（区间查询需要时会按需重算）——
+					// 否则多信号网格下每个状态都要常驻几十 KB~几 MB。
+					state->localCurve.clear();
+					state->localCurve.shrink_to_fit();
+					state->localBegin = 0;
+					state->localEnd = 0;
+					state->localValid = false;
+				}
+				state->pumpedPairs += scanned;
+				m_edgeScanBudget -= std::min(m_edgeScanBudget, scanned);
+			}
+		}
+
+		// ---- 汇总请求区间 -------------------------------------------------------
+		// 内部整块用块和相加，只有两端边界块（≤ 2 块）需要就地精确扫描
+		// ⇒ 拖动**时间**光标时单帧代价与区间长度无关。
+		if (!suppressPartial)
+		{
+			const std::size_t limit =
+			    (state->scannedPair > 0) ? std::min(pairLast, state->scannedPair - 1) : 0;
+			if (limit >= pairFirst)
+			{
+				const std::size_t firstBlock = (pairFirst - 1) / kEdgeBlockSamples;
+				const std::size_t lastBlock = (limit - 1) / kEdgeBlockSamples;
+				bool boundaryOk = true;
+				for (std::size_t block = firstBlock; block <= lastBlock && boundaryOk; ++block)
+				{
+					const std::size_t blockFirst = block * kEdgeBlockSamples + 1;
+					const std::size_t blockLast = std::min(count - 1, (block + 1) * kEdgeBlockSamples);
+					const std::size_t low = std::max(pairFirst, blockFirst);
+					const std::size_t high = std::min(limit, blockLast);
+					const bool wholeBlock = (low == blockFirst) && (high == blockLast) &&
+					                        (state->scannedPair > blockLast) &&
+					                        (block < state->blockRising.size());
+					if (wholeBlock)
+					{
+						rising += state->blockRising[block];
+						falling += state->blockFalling[block];
+						continue;
+					}
+					// 边界块 / 尚未扫完的块：就地精确扫描这一小段（≤ 1 个块）。
+					if (!ensureLocalCurve(low - 1, high))
+					{
+						boundaryOk = false;		// 中心轴曲线算不出来：本帧不展示（下帧重试）
+						break;
+					}
+					double previous = deltaAt(low - 1);
+					for (std::size_t index = low; index <= high; ++index)
+					{
+						const double current = deltaAt(index);
+						if (std::isfinite(previous) && std::isfinite(current))
+						{
+							if (previous < 0.0 && current >= 0.0)
+							{
+								++rising;
+							}
+							else if (previous > 0.0 && current <= 0.0)
+							{
+								++falling;
+							}
+						}
+						previous = current;
+					}
+				}
+				// 边界块扫描失败（中心轴曲线算不出来）时不展示结果：保持 complete=false。
+				complete = boundaryOk && (pairLast < state->scannedPair);
+			}
+			else
+			{
+				complete = (pairLast < state->scannedPair);
+			}
+		}
+		if (!complete)
+		{
+			RequestEdgeScanFrame();
+		}
+	}
+
+	void PlotView::EdgeCountsFor(const TimeAxis& axis, const SignalData& signal, const SignalStyle& style,
+	                             double edgeValue, bool hasRange, double rangeMin, double rangeMax,
+	                             std::size_t& rising, std::size_t& falling, bool& complete) const
+	{
+		EdgeScanFor(axis, signal, style, false, edgeValue, 0, 1, hasRange, rangeMin, rangeMax, rising,
+		            falling, complete);
+	}
+
+	void PlotView::EdgeCenterCountsFor(const TimeAxis& axis, const SignalData& signal,
+	                                   const SignalStyle& style, int points, int iterations,
+	                                   bool hasRange, double rangeMin, double rangeMax,
+	                                   std::size_t& rising, std::size_t& falling, bool& complete) const
+	{
+		// 与普通边沿计数完全共用同一套「逐块累积 + 每 tick 预算推进」机制；
+		// 区别只在判定基准（信号 − 中心平均值曲线）与所需曲线（均值滤波，需整条）。
+		EdgeScanFor(axis, signal, style, true, 0.0, points, iterations, hasRange, rangeMin, rangeMax,
+		            rising, falling, complete);
+	}
+
+
+	bool PlotView::EdgeRangeActive() const
+	{
+		return m_tab != nullptr && Tab().CursorMode() == PlotCursorMode::DOUBLE;
+	}
+
+	double PlotView::EdgeRangeMin() const
+	{
+		if (m_tab == nullptr)
+		{
+			return 0.0;
+		}
+		// 左右光标可能被拖动交换：始终取较小者为区间左端。
+		return std::min(Tab().CursorTime(), Tab().CursorTimeAlt());
+	}
+
+	double PlotView::EdgeRangeMax() const
+	{
+		if (m_tab == nullptr)
+		{
+			return 0.0;
+		}
+		return std::max(Tab().CursorTime(), Tab().CursorTimeAlt());
+	}
+
+	std::wstring PlotView::EdgeRangeSuffix() const
+	{
+		return EdgeRangeActive() ? std::wstring(L"（光标区间内）") : std::wstring();
+	}
+
+	bool PlotView::ToggleLaneAutoFitToSelection(int laneIndex)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return false;
+		}
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		lane.fitYToSelection = !lane.fitYToSelection;
+		if (lane.fitYToSelection)
+		{
+			// 打开时立即按当前视图自适应一次，否则当前量程不合适时看不到任何变化。
+			AutoRangeLaneToView(laneIndex);
+		}
+		return lane.fitYToSelection;
+	}
+
+	void PlotView::ApplyAutoFitToSelectionNow(int laneIndex)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return;
+		}
+		if (!m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].fitYToSelection)
+		{
+			return;
+		}
+		AutoRangeLaneToView(laneIndex);
+	}
+
+	void PlotView::ApplyAllAutoFitToSelectionNow()
+	{
+		if (m_tab == nullptr)
+		{
+			return;
+		}
+		const std::size_t count = m_tab->Lanes().size();
+		for (std::size_t index = 0; index < count; ++index)
+		{
+			ApplyAutoFitToSelectionNow(static_cast<int>(index));
+		}
+	}
+
+	bool PlotView::SetAllLanesAutoFitToSelection(bool enabled, bool applyNow)
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		bool changed = false;
+		for (Lane& lane : m_tab->Lanes())
+		{
+			if (lane.fitYToSelection != enabled)
+			{
+				lane.fitYToSelection = enabled;
+				changed = true;
+			}
+		}
+		if (enabled && applyNow)
+		{
+			// 全局打开时立刻让每个网格都自适应一次，保证界面立刻反映开关状态。
+			ApplyAllAutoFitToSelectionNow();
+		}
+		return changed;
+	}
+
+	bool PlotView::AutoRangeLaneToView(int laneIndex)
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return false;
+		}
+
+		const std::vector<Lane>& lanes = m_tab->Lanes();
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(lanes.size()))
+		{
+			return false;
+		}
+
+		const double viewMin = Tab().ViewMin();
+		const double viewMax = Tab().ViewMax();
+		if (!(viewMax > viewMin))
+		{
+			return false;
+		}
+
+		// 只统计时间轴当前可见区间内的采样点，因此放大局部波形后可以快速把该段铺满网格。
+		double low = std::numeric_limits<double>::infinity();
+		double high = -std::numeric_limits<double>::infinity();
+
+		for (const SignalRef& ref : lanes[static_cast<std::size_t>(laneIndex)].signals)
+		{
+			if (!Tab().IsVisible(ref))
+			{
+				continue;
+			}
+			const SignalData* signal = m_dataSet->Resolve(ref);
+			const TimeAxis* axis = m_dataSet->Axis(ref);
+			if (signal == nullptr || axis == nullptr)
+			{
+				continue;
+			}
+
+			const std::size_t count = std::min(axis->time.size(), signal->values.size());
+			const SignalStyle* style = m_dataSet->Style(ref);
+			// 时间偏移：可见采样对应的源时刻区间要整体左移（画在 t + shift 处）。
+			const double timeShift = (style != nullptr) ? style->offsetTime : 0.0;
+			const double sourceMin = viewMin - timeShift;
+			const double sourceMax = viewMax - timeShift;
+			std::size_t begin = 0;
+			std::size_t end = count;
+			if (axis->monotonic)
+			{
+				// 时间单调时直接二分定位区间，百万级采样也只需扫过可见段。
+				begin = static_cast<std::size_t>(
+				    std::lower_bound(axis->time.begin(), axis->time.end(), sourceMin) - axis->time.begin());
+				if (begin > 0)
+				{
+					--begin;
+				}
+				end = static_cast<std::size_t>(
+				    std::lower_bound(axis->time.begin(), axis->time.end(), sourceMax) - axis->time.begin());
+				if (end < count)
+				{
+					++end;
+				}
+			}
+
+			// ⚠️ **性能：把样式指针提到循环之外**。`DataSet::Style(ref)` 每次调用都要做
+			// 指针解析与边界检查；放在循环体里等于**每个采样点解析两次**
+			//（实测全段自适应因此从 147ms 劣化到 1200ms —— 8 倍回归）。
+			const SignalStyle* resolvedStyle = style;	// 可能为 nullptr（视为无变换）
+			const bool mirrored = (resolvedStyle != nullptr) && resolvedStyle->mirrorHorizontal;
+			const bool transform = (resolvedStyle != nullptr) &&
+			                       (resolvedStyle->gain != 1.0f || resolvedStyle->absolute ||
+			                        resolvedStyle->mirrorVertical || resolvedStyle->offsetY != 0.0f);
+
+			// ⚠️ **整段自适应直接取信号已缓存的 min/max**（O(1)）：
+			// 当视界覆盖整条信号、且该信号没有任何数值变换时，逐点扫描的结果与
+			// `ComputeStats` 预存的 min/max 完全一致。工具栏「Y 轴自适应」开关在全视图下
+			// 会一次性对全部网格做这件事 —— 逐点扫描 2580 万 × 5 是秒级卡顿（实测 1200ms），
+			// 这里改为 O(1)。
+			if (axis->monotonic && begin == 0 && end == count && !mirrored && !transform &&
+			    signal->finiteCount > 0)
+			{
+				low = std::min(low, signal->minValue);
+				high = std::max(high, signal->maxValue);
+				continue;
+			}
+
+			if (!mirrored && !transform)
+			{
+				// 无变换：与既有实现完全一致的紧凑循环（无逐点分支，便于向量化）。
+				for (std::size_t index = begin; index < end; ++index)
+				{
+					if (!axis->monotonic)
+					{
+						const double t = axis->time[index];
+						if (!std::isfinite(t) || t < sourceMin || t > sourceMax)
+						{
+							continue;
+						}
+					}
+					const double value = signal->values[index];
+					if (!std::isfinite(value))
+					{
+						continue;
+					}
+					low = std::min(low, value);
+					high = std::max(high, value);
+				}
+				continue;
+			}
+
+			// 有变换（系数 / 绝对值 / 镜像 / Y 偏移）或水平镜像：逐点套用与绘制**相同**的变换。
+			// ⚠️ 自适应必须基于**画出来的曲线**，否则调整系数/镜像后自适应范围会按原始数据算错
+			//（用户报告"自适应区域错误，看上去还是按照原始数据来的"）。
+			// 水平镜像时画面上的第 index 个位置取源下标 count-1-index 的值。
+			for (std::size_t index = begin; index < end; ++index)
+			{
+				if (!axis->monotonic)
+				{
+					const double t = axis->time[index];
+					if (!std::isfinite(t) || t < sourceMin || t > sourceMax)
+					{
+						continue;
+					}
+				}
+				const std::size_t sourceIndex =
+				    (mirrored && count > 0) ? ((count - 1) - index) : index;
+				if (sourceIndex >= count)
+				{
+					continue;
+				}
+				const double raw = signal->values[sourceIndex];
+				if (!std::isfinite(raw))
+				{
+					continue;
+				}
+				const double value = transform ? ApplyDrawTransform(*resolvedStyle, raw) : raw;
+				if (std::isfinite(value))
+				{
+					low = std::min(low, value);
+					high = std::max(high, value);
+				}
+			}
+		}
+
+		if (!std::isfinite(low) || !std::isfinite(high))
+		{
+			return false;
+		}
+
+		// ⚠️ 留白必须与整段自适应（`TabConfig::ComputeLaneRange` → `PadRange`）**共用同一规则**
+		//（`PadValueRange`）：否则「点过适应视图后再打开 Y 轴自适应」会因为留白不同
+		//（6% vs 5%）而算出不一样的区间，网格被无意义地重绘一次；
+		// 反向（关掉 Y 轴自适应再点适应视图）同样会变。
+		PadValueRange(low, high);
+
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		lane.autoRange = false;
+		lane.yMin = low;
+		lane.yMax = high;
+		BuildLaneVisuals();
+		return true;
+	}
+
+	void PlotView::ApplySelectionAutoFit()
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+
+		const std::vector<Lane>& lanes = m_tab->Lanes();
+		bool any = false;
+		for (const Lane& lane : lanes)
+		{
+			if (lane.fitYToSelection)
+			{
+				any = true;
+				break;
+			}
+		}
+		if (!any)
+		{
+			return;
+		}
+
+		// 只对开启了「选区 Y 轴自适应」的网格重新匹配 Y 轴；
+		// 重新匹配依据的是刚刚更新过的时间视图范围。
+		for (std::size_t index = 0; index < lanes.size(); ++index)
+		{
+			if (m_tab->Lanes()[index].fitYToSelection)
+			{
+				AutoRangeLaneToView(static_cast<int>(index));
+			}
+		}
+	}
+
+	void PlotView::ReapplyGlobalAutoFitIfEnabled()
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+		// 与工具栏「Y 轴自适应」按钮的勾选判据完全一致（全部网格都开启才叫“全局开启”）。
+		if (!AllLanesAutoFitToSelection())
+		{
+			return;
+		}
+		// 结构变化后重新匹配一次：新网格要按当前视界自适应，
+		// 移除信号后的网格也要按剩下信号重新收敛（旧幅值区间是按旧信号集合算的）。
+		ApplyAllAutoFitToSelectionNow();
+	}
+
+	bool PlotView::UpdateAutoScatterStyles()
+	{
+		if (m_dataSetWritable == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+
+		bool changed = false;
+		// 只处理当前标签页里**可见**的信号：绘制方式的自动切换是「视界」驱动的，
+		// 看不见的信号与当前视界无关（它们可见时会经 `RefreshLanes` 再判一次）。
+		for (const Lane& lane : m_tab->Lanes())
+		{
+			for (const SignalRef& ref : lane.signals)
+			{
+				if (!m_tab->IsVisible(ref))
+				{
+					continue;
+				}
+				const TimeAxis* axis = m_dataSetWritable->Axis(ref);
+				const SignalData* data = m_dataSetWritable->Resolve(ref);
+				SignalStyle* style = m_dataSetWritable->Style(ref);
+				if (axis == nullptr || data == nullptr || style == nullptr)
+				{
+					continue;
+				}
+
+				// ⚠️ **先**判定“用户是否手动改过绘制方式”：本机制只会写入「点线」，
+				// 所以自动启用期间 mode 不等于「点线」只可能是用户改的。
+				// 这一步必须在下面的分支之前做 —— 用户改完样式可能**紧接着就缩出去**
+				// （例如直接点适应视图），那次调用的视界已经不再满足条件，若等到那时才判定，
+				// 恢复逻辑会先把用户的修改覆盖掉（用户明确要求不能这样）。
+				if (style->autoScatterActive && style->mode != DrawMode::LINE_SCATTER)
+				{
+					style->autoScatterUserOverride = true;
+				}
+
+				// 判定与**光标吸附完全同源**（用户 2026-10-15 明确要求）：
+				// 只有“一屏内数据点少于 N×4”的信号才自动切「点线」，
+				// 不再满足时（适应视图、或把视界移到信号的稠密区）自动恢复原样式。
+				// ⚠️ 可见性同样按**显示时间**判断（含 `offsetTime`），与吸附保持一致。
+				if (SignalSnapEnabled(*axis, *data, style->offsetTime))
+				{
+					if (!style->autoScatterActive)
+					{
+						// 进入阈值：保存原绘制方式并自动切到「点线」提示用户数据点位置。
+						style->autoScatterSavedMode = style->mode;
+						style->autoScatterActive = true;
+						style->autoScatterUserOverride = false;
+						if (style->mode != DrawMode::LINE_SCATTER)
+						{
+							style->mode = DrawMode::LINE_SCATTER;
+							changed = true;
+						}
+					}
+				}
+				else if (style->autoScatterActive)
+				{
+					// 退出阈值（例如适应视图）：恢复自动启用之前的绘制方式；
+					// 但用户手动改过时**不恢复**（尊重用户的选择）。
+					style->autoScatterActive = false;
+					if (!style->autoScatterUserOverride && style->mode != style->autoScatterSavedMode)
+					{
+						style->mode = style->autoScatterSavedMode;
+						changed = true;
+					}
+					style->autoScatterUserOverride = false;
+				}
+			}
+		}
+		return changed;
+	}
+
+	float PlotView::SinglePointDotRadius(const ResolvedSignal& resolved) const
+	{
+		if (resolved.style == nullptr)
+		{
+			return kMinScatterRadius * m_scale;
+		}
+		// 与 `PaintLane` / 拖拽虚影画那个点时的半径**完全同源**（散点半径随线宽线性增长），
+		// 命中判定与光晕半径都复用它，三者不会出现“看着点中了却没反应”。
+		const double radius = ClampDouble(static_cast<double>(resolved.style->lineWidth) * kScatterRadiusScale,
+		                                 static_cast<double>(kMinScatterRadius),
+		                                 static_cast<double>(kMaxScatterRadius));
+		return static_cast<float>(radius) * m_scale;
+	}
+
+	bool PlotView::SinglePointScreenPos(const ResolvedSignal& resolved, const LaneVisual& lane,
+	                                    gd::PointF& out) const
+	{
+		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
+		{
+			return false;
+		}
+		if (resolved.data->finiteCount != 1)
+		{
+			return false;
+		}
+		double time = 0.0;
+		double value = 0.0;
+		if (!SinglePointOfSignal(*resolved.data, *resolved.axis, time, value))
+		{
+			return false;
+		}
+		// 与绘制一致：采样画在 `t + offsetTime` 处，取值先过「调整」变换。
+		const double displayTime = time + resolved.style->offsetTime;
+		const double drawValue = ApplyDrawTransform(*resolved.style, value);
+		if (!std::isfinite(displayTime) || !std::isfinite(drawValue))
+		{
+			return false;
+		}
+		out.X = TimeToX(displayTime);
+		out.Y = ValueToY(drawValue, lane);
+		return true;
+	}
+
+
+} // namespace jdi
+
diff --git a/Components/PlotView/Src/PlotViewInteraction.cpp b/Components/PlotView/Src/PlotViewInteraction.cpp
new file mode 100644
index 0000000..8956f6d
--- /dev/null
+++ b/Components/PlotView/Src/PlotViewInteraction.cpp
@@ -0,0 +1,2715 @@
+// PlotView 实现分片 —— 本文件只包含 PlotView 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与工具函数在 PlotViewInternal.hpp（命名空间 `pvdetail`，全部 inline）。
+// 四个分片的职责划分（按功能）：
+//   core        视图核心：构造/析构、上下文绑定、布局、坐标映射、视界与平移、网格结构与归属、
+//               选区/网格划分、拖动取消
+//   paint       渲染与像素缓存：全部绘制（Paint*/Render*）、场景缓存、装饰缓存、每网格图层、
+//               宽基底与滚动补条、并行图层重建
+//   interaction 交互与编辑：命中测试、鼠标与键盘处理、光标形状、内联输入框、浮动面板层序与命中
+//   features    视图特性与派生数据：光标状态与读数、提示浮层、缩放模式、自适应、光标吸附、
+//               单点信号、派生曲线线程池、边沿统计、实验性功能（均值滤波 / 弱峰调整）参数
+#include "PlotViewInternal.hpp"
+
+namespace jdi
+{
+
+	const SignalRef& PlotView::SelectedRef() const
+	{
+		static const SignalRef fallback;
+		return (m_dataSet != nullptr) ? m_dataSet->Selected() : fallback;
+	}
+
+	void PlotView::SelectSignal(const SignalRef& ref)
+	{
+		if (m_dataSetWritable != nullptr)
+		{
+			m_dataSetWritable->SetSelected(ref);
+		}
+		// 联动（用户 2026-10-15 要求）：绘图区内把某条信号选为当前目标时，
+		// 请求宿主把信号列表**平滑滚动**到它，保证在长列表里也能看到它。
+		if (ref.IsValid())
+		{
+			m_pendingPanelScroll = ref;
+			m_pendingPanelScrollFlag = true;
+		}
+	}
+
+	void PlotView::SetExternalHoverSignal(const SignalRef& ref)
+	{
+		if (m_externalHoverSignal == ref)
+		{
+			return;
+		}
+		m_externalHoverSignal = ref;
+	}
+
+	int PlotView::EffectiveHoverLane() const
+	{
+		if (m_hoverLane >= 0)
+		{
+			return m_hoverLane;
+		}
+		// 外部悬停信号（信号列表 / 样式区「目标」行）：只在该信号确实绘制到某个网格时生效。
+		if (m_tab != nullptr && m_externalHoverSignal.IsValid())
+		{
+			return m_tab->LaneOfSignal(m_externalHoverSignal);
+		}
+		return -1;
+	}
+
+	int PlotView::LaneAtY(int y) const
+	{
+		const float fy = static_cast<float>(y);
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			const gd::RectF& rect = m_lanes[index].rect;
+			if (fy >= rect.Y && fy <= rect.Y + rect.Height)
+			{
+				return static_cast<int>(index);
+			}
+		}
+		return -1;
+	}
+
+	bool PlotView::CancelDrag(bool showHint)
+	{
+		if (m_dragMode == PlotDragMode::NONE)
+		{
+			return false;
+		}
+
+		// 放弃当前拖拽：清空拖拽状态与尚未生效的缩放选区，不改动任何视图范围。
+		// 调用方仍持有鼠标捕获，松开左键时会走 OnLButtonUp，
+		// 此时拖拽模式已是 NONE，选区不会被应用到时间轴/幅值轴上。
+		const bool wasRubber = (m_dragMode == PlotDragMode::RUBBER_SELECT);
+		m_dragMode = PlotDragMode::NONE;
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+		m_dragLane = -1;
+		m_dragMoved = false;
+		m_rubberRect = gd::RectF();
+		m_dragSignal = SignalRef();
+		m_dragTargetLane = -1;
+		if (showHint && wasRubber)
+		{
+			SetHint(L"已放弃当前选区（右键放弃选区，Esc 退出选区放大）");
+		}
+		return true;
+	}
+
+	bool PlotView::ExitZoomModes()
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+
+		// 退出缩放模式：工具栏的「选区放大」按钮会在 Application::Render 中同步为未选中态。
+		if (Tab().ZoomMode() == PlotZoomMode::NONE)
+		{
+			return false;
+		}
+		Tab().ZoomMode() = PlotZoomMode::NONE;
+		SetHint(std::wstring());
+		return true;
+	}
+
+	bool PlotView::IsOnCursorLine(int x, int& which) const
+	{
+		which = 0;
+		if (!Tab().CursorEnabled() || m_plotRect.Width <= 0.0f)
+		{
+			return false;
+		}
+
+		const float tolerance = 6.0f * m_scale;
+		const float fx = static_cast<float>(x);
+
+		// 双光标重叠时优先命中光标 1，避免出现“抓不起来第二条”的情况。
+		// 使用"显示横坐标"：滞留在可视区外的光标被钉在边缘，也应该可以被抓住拖回来。
+		if (std::fabs(fx - CursorDisplayX(1)) <= tolerance)
+		{
+			which = 1;
+			return true;
+		}
+		if (Tab().CursorMode() == PlotCursorMode::DOUBLE && std::fabs(fx - CursorDisplayX(2)) <= tolerance)
+		{
+			which = 2;
+			return true;
+		}
+		return false;
+	}
+
+	bool PlotView::IsOnCursorTimeLabel(int x, int y, int& which) const
+	{
+		which = 0;
+		if (!Tab().CursorEnabled())
+		{
+			return false;
+		}
+
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+
+		// 双光标重叠时优先命中光标 1（与光标线的命中顺序一致）。
+		const int count = (Tab().CursorMode() == PlotCursorMode::DOUBLE) ? 2 : 1;
+		for (int index = 1; index <= count; ++index)
+		{
+			const gd::RectF rect = CursorLabelRect(index);
+			if (rect.Width > 0.0f && UiPointInRect(rect, fx, fy))
+			{
+				which = index;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool PlotView::IsOnCursorSpanLabel(int x, int y) const
+	{
+		if (Tab().CursorMode() != PlotCursorMode::DOUBLE || m_cursorSpanRect.Width <= 0.0f)
+		{
+			return false;
+		}
+		return UiPointInRect(m_cursorSpanRect, static_cast<float>(x), static_cast<float>(y));
+	}
+
+	int PlotView::LaneIndexAt(int x, int y) const
+	{
+		if (!UiPointInRect(m_plotRect, static_cast<float>(x), static_cast<float>(y)))
+		{
+			return -1;
+		}
+		return LaneAtY(y);
+	}
+
+	SignalRef PlotView::HitTestSignal(int x, int y) const
+	{
+		SignalRef empty;
+		if (m_tab == nullptr || m_dataSet == nullptr || !HasDrawableContent())
+		{
+			return empty;
+		}
+		if (!UiPointInRect(m_plotRect, static_cast<float>(x), static_cast<float>(y)))
+		{
+			return empty;
+		}
+
+		const int laneIndex = LaneAtY(y);
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return empty;
+		}
+
+		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
+		const float tolerance = kSignalHitTolerance * m_scale;
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+
+		SignalRef best;
+		float bestDistance = tolerance;
+
+		// 只为当前网格内的可见信号做精确的点到线段距离检测，避免跨网格误命中。
+		for (const SignalRef& ref : m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals)
+		{
+			const ResolvedSignal resolved = ResolveSignal(ref);
+			if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
+			{
+				continue;
+			}
+
+			// ⚠️ **只有单个有效数据点**的信号没有“折线”可测距（`AcquirePolyline` 给不出两点的
+			// 线段），必须直接用数据点的屏幕坐标判定。否则用户永远无法悬停/拖动单点信号
+			//（用户 2026-10-15 报告：“光标瞄到数据点没有高亮、也不能拖拽换网格”）。
+			if (resolved.data->finiteCount == 1)
+			{
+				gd::PointF dot;
+				if (!SinglePointScreenPos(resolved, lane, dot))
+				{
+					continue;
+				}
+				const float dx = dot.X - fx;
+				const float dy = dot.Y - fy;
+				const float distance = std::sqrt(dx * dx + dy * dy);
+				// 容差取“常规命中容差”与“该点绘制半径”的较大者：点本身很粗时更好点中。
+				const float dotRadius = SinglePointDotRadius(resolved);
+				const float limit = std::max(tolerance, dotRadius);
+				if (distance <= limit && distance <= bestDistance + dotRadius)
+				{
+					bestDistance = distance;
+					best = ref;
+				}
+				continue;
+			}
+
+			// 复用绘制阶段的折线顶点：悬停检测通常与上一帧几何完全相同，
+			// 不再为“鼠标移动但命中结果未变”重复扫描全量采样点。
+			const PolylineCacheEntry* cached = AcquirePolyline(ref, resolved, lane);
+			if (cached == nullptr)
+			{
+				continue;
+			}
+			const std::vector<gd::PointF>& points = cached->points;
+			const std::vector<std::size_t>& breaks = cached->breaks;
+			if (points.size() < 2)
+			{
+				continue;
+			}
+
+			// 横向先行裁剪：点到线段的距离必然不小于横向距离本身，
+			// 因此只有横向落在容差范围内的顶点才可能命中。
+			// 时间单调时折线顶点按 x 递增，可二分定位后只扫描这一小段；
+			// 否则每次鼠标移动都要遍历上万个顶点（悬停卡顿的来源之一）。
+			std::size_t windowFirst = 0;
+			std::size_t windowLast = points.size();
+			if (resolved.axis->monotonic)
+			{
+				const auto byX = [](const gd::PointF& point, float limit) { return point.X < limit; };
+				windowFirst = static_cast<std::size_t>(
+				    std::lower_bound(points.begin(), points.end(), fx - tolerance, byX) - points.begin());
+				windowLast = static_cast<std::size_t>(
+				    std::upper_bound(points.begin(), points.end(), fx + tolerance,
+				                     [](float limit, const gd::PointF& point) { return limit < point.X; }) -
+				    points.begin());
+			}
+			if (windowFirst >= windowLast)
+			{
+				continue;
+			}
+			// 散点模式下把采样点本身也视为可命中目标。
+			if (resolved.style->mode == DrawMode::SCATTER)
+			{
+				for (std::size_t index = windowFirst; index < windowLast; ++index)
+				{
+					const gd::PointF& point = points[index];
+					const float dx = point.X - fx;
+					const float dy = point.Y - fy;
+					const float distance = std::sqrt(dx * dx + dy * dy);
+					if (distance <= bestDistance)
+					{
+						bestDistance = distance;
+						best = ref;
+					}
+				}
+				continue;
+			}
+
+			for (std::size_t k = 0; k < breaks.size(); ++k)
+			{
+				const std::size_t start = breaks[k];
+				const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
+				const std::size_t scanBegin = std::max(start + 1, windowFirst);
+				const std::size_t scanEnd = std::min(stop, windowLast);
+				for (std::size_t index = scanBegin; index < scanEnd; ++index)
+				{
+					const gd::PointF& a = points[index - 1];
+					const gd::PointF& b = points[index];
+
+					const float vx = b.X - a.X;
+					const float vy = b.Y - a.Y;
+					const float wx = fx - a.X;
+					const float wy = fy - a.Y;
+
+					const float lengthSquared = vx * vx + vy * vy;
+					float t = 0.0f;
+					if (lengthSquared > 1.0e-6f)
+					{
+						t = (wx * vx + wy * vy) / lengthSquared;
+						t = std::max(0.0f, std::min(1.0f, t));
+					}
+
+					const float dx = wx - t * vx;
+					const float dy = wy - t * vy;
+					const float distance = std::sqrt(dx * dx + dy * dy);
+					if (distance < bestDistance)
+					{
+						bestDistance = distance;
+						best = ref;
+					}
+				}
+			}
+		}
+
+		return best;
+	}
+
+	gd::RectF PlotView::EditFieldRect() const
+	{
+		if (m_editTarget == PlotEditTarget::NONE || m_fonts == nullptr || m_fonts->monoSmall == nullptr)
+		{
+			return gd::RectF();
+		}
+
+		const float height = 22.0f * m_scale;
+		float width = std::max(90.0f * m_scale,
+		                       UiMeasureTextWidth(m_fonts->monoSmall, m_edit.Text()) + 24.0f * m_scale);
+
+		if (m_editTarget == PlotEditTarget::CURSOR_TIME)
+		{
+			// 与显示态标签取相同宽度与位置（底部），避免进入编辑时框体跳动。
+			const int which = (m_editCursor == 2) ? 2 : 1;
+			const gd::RectF displayRect = CursorLabelRect(which);
+			width = std::max(width, displayRect.Width);
+			float left = CursorX(which) - width * 0.5f;
+			left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
+			return gd::RectF(left, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale, width,
+			                 height);
+		}
+
+		if (m_editTarget == PlotEditTarget::CURSOR_SPAN)
+		{
+			// 差值输入框落在差值标签处（时间轴上方或时间轴内部）。
+			bool insideAxis = false;
+			const gd::RectF displayRect = CursorSpanRect(insideAxis);
+			if (displayRect.Width <= 0.0f)
+			{
+				return gd::RectF();
+			}
+			width = std::max(width, displayRect.Width);
+			float left = displayRect.X + displayRect.Width * 0.5f - width * 0.5f;
+			left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - width));
+			return gd::RectF(left, displayRect.Y, width, height);
+		}
+
+		if (m_editTarget == PlotEditTarget::SIGNAL_NAME)
+		{
+			// 图例改名：输入框直接落在被双击的图例条目位置上。
+			if (m_editFieldRect.Width <= 0.0f)
+			{
+				return gd::RectF();
+			}
+			const float nameWidth = std::max(width, m_editFieldRect.Width);
+			return gd::RectF(m_editFieldRect.X, m_editFieldRect.Y, nameWidth, height);
+		}
+
+		if (m_editTarget == PlotEditTarget::EDGE_CENTER_POINTS ||
+		    m_editTarget == PlotEditTarget::EDGE_CENTER_ITERATIONS ||
+		    m_editTarget == PlotEditTarget::MEAN_FILTER_POINTS ||
+		    m_editTarget == PlotEditTarget::MEAN_FILTER_ITERATIONS ||
+		    m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX)
+		{
+			// 「均值点数 X」/「迭代次数 N」（均值滤波、中心轴）与「迭代次数 N 上限」（弱峰调整）：
+			// 输入框都落在对应的字段/滑块行矩形上。
+			if (m_editFieldRect.Width <= 0.0f)
+			{
+				return gd::RectF();
+			}
+			const float fieldHeight = std::max(height, m_editFieldRect.Height - 4.0f * m_scale);
+			return gd::RectF(m_editFieldRect.X, m_editFieldRect.Y + 2.0f * m_scale,
+			                 m_editFieldRect.Width, fieldHeight);
+		}
+
+		// 网格 Y 轴上下限输入框：优先落在被点击的菜单条目位置，保证"就地编辑"的观感。
+		if (m_editFieldRect.Width > 0.0f && m_editFieldRect.Height > 0.0f)
+		{			float left = m_editFieldRect.X;
+			float top = m_editFieldRect.Y;
+			left = std::max(m_area.X + 2.0f * m_scale,
+			                std::min(left, m_area.X + m_area.Width - width - 2.0f * m_scale));
+			top = std::max(m_area.Y + 2.0f * m_scale,
+			               std::min(top, m_area.Y + m_area.Height - height - 2.0f * m_scale));
+			return gd::RectF(left, top, width, height);
+		}
+
+		if (m_editLane < 0 || m_editLane >= static_cast<int>(m_lanes.size()))
+		{
+			return gd::RectF();
+		}
+		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(m_editLane)];
+		const float left = lane.rect.X + kLaneLabelPad * m_scale;
+		const float top = lane.rect.Y + kLaneLabelPad * m_scale;
+		return gd::RectF(left, top, std::min(width, lane.rect.Width - 2.0f * kLaneLabelPad * m_scale), height);
+	}
+
+	bool PlotView::BeginEdit(PlotEditTarget target, int laneIndex, const std::wstring& initialText,
+	                         const gd::RectF& anchorRect)
+	{
+		if (target == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+		// 切换编辑目标时清掉上一轮残留（图例改名需由调用方在进入前先设置 m_editSignal）。
+		if (target != PlotEditTarget::SIGNAL_NAME)
+		{
+			m_editSignal = SignalRef();
+		}
+		// 调用方可以用锚点矩形指定输入框位置（如菜单条目、图例条目）；
+		// 未提供锚点时由 EditFieldRect() 按目标类型自动推导。
+		if (anchorRect.Width > 0.0f && anchorRect.Height > 0.0f)
+		{
+			m_editFieldRect = anchorRect;
+		}
+		else if (target != PlotEditTarget::SIGNAL_NAME)
+		{
+			m_editFieldRect = gd::RectF();
+		}
+		m_editTarget = target;
+		m_editLane = laneIndex;
+		// 名称与数值均不限长度（数值在提交时会做范围夹取）。
+		const bool nameField = (target == PlotEditTarget::SIGNAL_NAME);
+		m_edit.Begin(initialText, true, nameField ? EditFilter::ANY : EditFilter::NUMBER, 0u);
+		return true;
+	}
+
+	bool PlotView::TakePendingRename(SignalRef& ref, std::wstring& name)
+	{
+		if (!m_pendingRename)
+		{
+			return false;
+		}
+		ref = m_pendingRenameRef;
+		name = m_pendingRenameName;
+		m_pendingRename = false;
+		m_pendingRenameRef = SignalRef();
+		m_pendingRenameName.clear();
+		return true;
+	}
+
+	bool PlotView::EndEdit(bool commit)
+	{
+		if (m_editTarget == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+
+		const PlotEditTarget target = m_editTarget;
+		const int laneIndex = m_editLane;
+		const SignalRef editSignal = m_editSignal;
+		const std::wstring text = Trim(m_edit.Text());
+
+		m_editTarget = PlotEditTarget::NONE;
+		m_editLane = -1;
+		m_editSignal = SignalRef();
+		m_editFieldRect = gd::RectF();
+		m_peakEditCurrentMax = 0;	// 退出编辑：清除“迭代上限”输入框的灰色提示值
+		m_edit.End();
+
+		// 信号改名：交给宿主窗口落到数据层，绘图区只持有只读数据。
+		if (target == PlotEditTarget::SIGNAL_NAME)
+		{
+			if (commit && !text.empty() && editSignal.IsValid())
+			{
+				m_pendingRenameRef = editSignal;
+				m_pendingRenameName = text;
+				m_pendingRename = true;
+			}
+			return true;
+		}
+
+		double parsed = 0.0;
+		bool parsedOk = false;
+		if (commit && !text.empty())
+		{
+			wchar_t* stop = nullptr;
+			parsed = std::wcstod(text.c_str(), &stop);
+			parsedOk = (stop != text.c_str()) && (parsed == parsed) && std::isfinite(parsed);
+		}
+
+		if (!parsedOk)
+		{
+			return true;
+		}
+
+		if (target == PlotEditTarget::CURSOR_TIME)
+		{
+			double low = 0.0;
+			double high = 1.0;
+			TimeBounds(low, high);
+			const double span = std::max(high - low, kMinTimeSpan);
+			const double clamped = ClampDouble(parsed, low - span * 10.0, high + span * 10.0);
+			if (m_editCursor == 2 && Tab().CursorMode() == PlotCursorMode::DOUBLE)
+			{
+				Tab().CursorTimeAlt() = clamped;
+			}
+			else
+			{
+				Tab().CursorTime() = clamped;
+			}
+			m_activeCursor = (m_editCursor == 2) ? 2 : 1;
+			return true;
+		}
+
+		if (target == PlotEditTarget::CURSOR_SPAN)
+		{
+			// 差值编辑：输入值**始终以秒为单位**（即使界面上显示为 1.5min，编辑内容也是 90）。
+			// **前方（时间较小）的光标不动**，后方光标向后移动到"前方 + 输入差值"。
+			const double span = std::fabs(parsed);
+			const double front = std::min(Tab().CursorTime(), Tab().CursorTimeAlt());
+			const bool secondIsBack = (Tab().CursorTimeAlt() >= Tab().CursorTime());
+			const double moved = front + span;
+			if (secondIsBack)
+			{
+				Tab().CursorTime() = front;
+				Tab().CursorTimeAlt() = moved;
+			}
+			else
+			{
+				Tab().CursorTimeAlt() = front;
+				Tab().CursorTime() = moved;
+			}
+			m_activeCursor = secondIsBack ? 2 : 1;
+			return true;
+		}
+
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return true;
+		}
+
+		// 「弱峰调整」迭代次数滑块的**上限**：用户可直接输入一个正整数作为新的量程上限。
+		// 规则（用户明确要求）：
+		//   * 输入框只允许输入正整数（过滤策略为 BYTE = 纯数字，粘贴同样会被清洗）；
+		//   * 空内容 / 非法值（0、超出允许范围）→ 保持原上限不变；
+		//   * 生效后若当前迭代次数超过新上限，则自动夹到新上限。
+		if (target == PlotEditTarget::PEAK_ITERATIONS_MAX)
+		{
+			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+			const Lane::WeakPeakItem* existing = lane.FindWeakPeakItem(m_editMeanRef);
+			if (existing == nullptr)
+			{
+				return true;
+			}
+			if (parsedOk)
+			{
+				const long long value = static_cast<long long>(std::llround(parsed));
+				if (value >= kWeakPeakIterationsMin && value <= kWeakPeakIterationsMaxLimit)
+				{
+					Lane::WeakPeakItem& item = lane.EnsureWeakPeakItem(m_editMeanRef);
+					item.maxIterations = static_cast<int>(value);
+					// 当前值超出新上限 → 自动替换为上界。
+					item.iterations = std::max(kWeakPeakIterationsMin,
+					                           std::min(item.maxIterations, item.iterations));
+					// 曲线可能因迭代次数被夹取而变化，缓存整体作废最稳妥。
+					m_weakPeakCurveCache.clear();
+				}
+			}
+			return true;
+		}
+
+		// 「均值点数 X」/「迭代次数 N」：作用于被勾选信号的均值滤波曲线，夹在合理范围内。
+		// 「中心轴边沿计数」用**完全相同的参数与语义**，只是作用于自己的条目列表。
+		const bool centerTarget =
+		    (target == PlotEditTarget::EDGE_CENTER_POINTS || target == PlotEditTarget::EDGE_CENTER_ITERATIONS);
+		if (target == PlotEditTarget::MEAN_FILTER_POINTS || target == PlotEditTarget::MEAN_FILTER_ITERATIONS ||
+		    centerTarget)
+		{
+			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+			const bool isPoints = (target == PlotEditTarget::MEAN_FILTER_POINTS ||
+			                       target == PlotEditTarget::EDGE_CENTER_POINTS);
+			const Lane::MeanFilterItem* existing = centerTarget ? lane.FindEdgeCenterItem(m_editMeanRef)
+			                                                   : lane.FindMeanFilterItem(m_editMeanRef);
+			if (existing == nullptr)
+			{
+				return true;
+			}
+			const int maximum = isPoints ? 1000000 : 1000;
+			int value = static_cast<int>(std::lround(parsed));
+			// 迭代次数至少为 1（1 次迭代等于不做滤波）；均值点数可以为 0。
+			value = isPoints ? std::max(0, std::min(value, maximum))
+			                 : std::max(1, std::min(value, maximum));
+
+			Lane::MeanFilterItem& item = centerTarget ? lane.EnsureEdgeCenterItem(m_editMeanRef)
+			                                         : lane.EnsureMeanFilterItem(m_editMeanRef);
+			if (isPoints)
+			{
+				item.points = value;
+			}
+			else
+			{
+				item.iterations = value;
+			}
+			// ⚠️ **只作废被改动的那个信号**的统计状态。
+			//    过去的 `m_edgeScans.clear()` 会把两个面板里**所有**信号的统计一起丢掉，
+			//    于是改一个信号的参数会让其余未改参数的统计也从头重扫（用户报告的缺陷）。
+			m_meanCurveCache.clear();
+			if (centerTarget)
+			{
+				InvalidateEdgeScansFor(ResolveSignal(m_editMeanRef).data, true);
+			}
+			return true;
+		}
+
+		// 直接输入上下限：先固化当前范围，再用新值替换对应端点（保证 max > min）。
+		if (laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return true;
+		}
+		const LaneVisual& visual = m_lanes[static_cast<std::size_t>(laneIndex)];
+		Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		// 直接输入上下限属于手动调整幅值：关闭本网格的「选区 Y 轴自适应」。
+		lane.fitYToSelection = false;
+		if (lane.autoRange)
+		{
+			lane.autoRange = false;
+			lane.yMin = visual.yMin;
+			lane.yMax = visual.yMax;
+		}
+
+		const double magnitude = std::max(std::fabs(lane.yMin), std::fabs(lane.yMax));
+		const double minimumGap = std::max(magnitude * 1.0e-6, 1.0e-12);
+
+		if (target == PlotEditTarget::LANE_Y_MAX)
+		{
+			if (parsed <= lane.yMin)
+			{
+				parsed = lane.yMin + minimumGap;
+			}
+			lane.yMax = parsed;
+		}
+		else
+		{
+			if (parsed >= lane.yMax)
+			{
+				parsed = lane.yMax - minimumGap;
+			}
+			lane.yMin = parsed;
+		}
+
+		BuildLaneVisuals();
+		return true;
+	}
+
+	bool PlotView::OnEditChar(wchar_t character)
+	{
+		if (m_editTarget == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+
+		// 剪贴板与全选快捷键经 WM_CHAR 送达（Ctrl+C/X/V/A 分别对应 3/24/22/1）。
+		switch (character)
+		{
+		case 0x03: // Ctrl+C
+			m_edit.CopyToClipboard(m_host);
+			return false;
+		case 0x18: // Ctrl+X
+			return m_edit.CutToClipboard(m_host);
+		case 0x16: // Ctrl+V
+			return m_edit.PasteFromClipboard(m_host);
+		case 0x01: // Ctrl+A
+			m_edit.SelectAll();
+			return true;
+		default:
+			break;
+		}
+
+		if (character == L'\r' || character == L'\n')
+		{
+			return EndEdit(true);
+		}
+		// 退格/删除已由 WM_KEYDOWN 的 OnEditKey 处理，此处忽略控制字符避免重复删除。
+		if (character < 0x20 || character == 0x7F)
+		{
+			return false;
+		}
+		return m_edit.Insert(character);
+	}
+
+	bool PlotView::CollapseEditSelectionToEnd()
+	{
+		if (m_editTarget == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+		return m_edit.DeselectToEnd();
+	}
+
+	bool PlotView::OnEditMouseDown(int x, int y)
+	{
+		if (m_editTarget == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+		const gd::RectF rect = EditFieldRect();
+		if (rect.Width <= 0.0f)
+		{
+			return false;
+		}
+		return UiEditFieldMouseDown(m_fonts->uiSmall, rect, m_edit, m_scale, x, y);
+	}
+
+	bool PlotView::OnEditMouseMove(int x)
+	{
+		if (m_editTarget == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+		const gd::RectF rect = EditFieldRect();
+		if (rect.Width <= 0.0f)
+		{
+			return false;
+		}
+		return UiEditFieldMouseMove(m_fonts->uiSmall, rect, m_edit, m_scale, x);
+	}
+
+	bool PlotView::OnEditMouseUp()
+	{
+		if (!m_edit.Dragging())
+		{
+			return false;
+		}
+		m_edit.EndDrag();
+		return true;
+	}
+
+	bool PlotView::OnEditKey(WPARAM key)
+	{
+		if (m_editTarget == PlotEditTarget::NONE)
+		{
+			return false;
+		}
+
+		const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
+		const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
+
+		switch (key)
+		{
+		case VK_RETURN:
+			return EndEdit(true);
+		case VK_ESCAPE:
+			return EndEdit(false);
+		case VK_BACK:
+			return m_edit.Backspace();
+		case VK_DELETE:
+			return m_edit.DeleteForward();
+		case VK_LEFT:
+			return m_edit.MoveCaret(-1, shift);
+		case VK_RIGHT:
+			return m_edit.MoveCaret(1, shift);
+		case VK_HOME:
+			return m_edit.MoveHome(shift);
+		case VK_END:
+			return m_edit.MoveEnd(shift);
+		case 'A':
+			if (control)
+			{
+				m_edit.SelectAll();
+			}
+			return true;
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool PlotView::HitTest(int x, int y) const
+	{
+		return UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y));
+	}
+
+	HCURSOR PlotView::QueryCursor(int x, int y) const
+	{
+		switch (m_dragMode)
+		{
+		case PlotDragMode::PAN:
+			return LoadCursorW(nullptr, IDC_SIZEALL);
+		case PlotDragMode::RUBBER_SELECT:
+			// 选区放大：轴向未定时为十字，确定后按方向给出上下/左右箭头。
+			if (m_rubberAxis == PlotRubberAxis::VALUE)
+			{
+				return LoadCursorW(nullptr, IDC_SIZENS);
+			}
+			if (m_rubberAxis == PlotRubberAxis::TIME)
+			{
+				return LoadCursorW(nullptr, IDC_SIZEWE);
+			}
+			return LoadCursorW(nullptr, IDC_CROSS);
+		case PlotDragMode::SCROLL_LANES:
+			return LoadCursorW(nullptr, IDC_SIZENS);
+		case PlotDragMode::CURSOR_MOVE:
+			// 光标拖拽（无论是抓住光标线还是抓住时间读数标签）都沿时间轴移动 → 左右箭头。
+			return LoadCursorW(nullptr, IDC_SIZEWE);
+		case PlotDragMode::CURSOR_SPAN_MOVE:
+			// 差值标签拖拽：两条光标整体沿时间轴平移 → 左右箭头。
+			return LoadCursorW(nullptr, IDC_SIZEWE);
+		case PlotDragMode::PEAK_LEVEL:
+		case PlotDragMode::PEAK_ITERATIONS:
+			// 「弱峰调整」滑块拖拽 → 左右箭头。
+			return LoadCursorW(nullptr, IDC_SIZEWE);
+		case PlotDragMode::MOVE_SIGNAL:
+			// 拖动信号（参考 Photoshop 平移元素的抓握光标）。
+			return LoadCursorW(nullptr, IDC_SIZEALL);
+		case PlotDragMode::EDGE_MOVE:
+			// 「边沿计数」横向光标：上下移动幅值。
+			return LoadCursorW(nullptr, IDC_SIZENS);
+		case PlotDragMode::EDGE_PANEL_MOVE:
+			// 边沿统计浮动面板：可自由拖动。
+			return LoadCursorW(nullptr, IDC_SIZEALL);
+		case PlotDragMode::LANE_REORDER:
+			// 网格次序拖拽：上下箭头（只能上下移动）。
+			return LoadCursorW(nullptr, IDC_SIZENS);
+		default:
+			break;
+		}
+
+		if (m_scrollBarVisible &&
+		    UiPointInRect(m_scrollBarRect, static_cast<float>(x), static_cast<float>(y)))
+		{
+			return LoadCursorW(nullptr, IDC_SIZENS);
+		}
+
+		// 实验性功能面板与横向光标优先于信号悬停提示判定（面板会盖住波形）。
+		// 面板**只有标题栏**可以拖拽（显示抓握光标）；✕ 与面板主体一律保持原始箭头。
+		if (m_tab != nullptr)
+		{
+			// 按**层序从上层往下**判定，重叠时以最上层的面板为准。
+			int panelLane = -1;
+			int panelKind = 0;
+			if (TopPanelAtPoint(static_cast<float>(x), static_cast<float>(y), panelLane, panelKind))
+			{
+				const EdgePanelLayout layout =
+				    EdgePanelLayoutFor(panelLane, static_cast<EdgePanelKind>(panelKind));
+				if (UiPointInRect(layout.close, static_cast<float>(x), static_cast<float>(y)))
+				{
+					// ✕ 按钮：与面板/标签栏的其它 ✕ 一致，用手型光标作为可点击提示。
+					return LoadCursorW(nullptr, IDC_HAND);
+				}
+				if (UiPointInRect(layout.title, static_cast<float>(x), static_cast<float>(y)))
+				{
+					return LoadCursorW(nullptr, IDC_SIZEALL);
+				}
+				if ((static_cast<EdgePanelKind>(panelKind) == EdgePanelKind::MEAN ||
+				     static_cast<EdgePanelKind>(panelKind) == EdgePanelKind::PEAK) &&
+				    layout.button.Width > 0.0f &&
+				    UiPointInRect(layout.button, static_cast<float>(x), static_cast<float>(y)))
+				{
+					// 「构建为新信号」按钮：手型光标作为可点击提示。
+					return LoadCursorW(nullptr, IDC_HAND);
+				}
+				// 「弱峰调整」的逐信号滑块：轨道 → 左右箭头；迭代次数右侧数值 → 手型（可点击改上限）。
+				if (static_cast<EdgePanelKind>(panelKind) == EdgePanelKind::PEAK)
+				{
+					for (std::size_t rowIndex = 0; rowIndex < layout.rowIterValues.size(); ++rowIndex)
+					{
+						if (layout.rowIterValues[rowIndex].Width > 0.0f &&
+						    UiPointInRect(layout.rowIterValues[rowIndex], static_cast<float>(x),
+						                  static_cast<float>(y)))
+						{
+							return LoadCursorW(nullptr, IDC_HAND);
+						}
+						// 两行滑块右侧的**复位控件**：与其它可点击图标一致，用手型光标提示可点击。
+						if (rowIndex < layout.rowLevelResets.size() &&
+						    layout.rowLevelResets[rowIndex].Width > 0.0f &&
+						    UiPointInRect(layout.rowLevelResets[rowIndex], static_cast<float>(x),
+						                  static_cast<float>(y)))
+						{
+							return LoadCursorW(nullptr, IDC_HAND);
+						}
+						if (rowIndex < layout.rowIterResets.size() &&
+						    layout.rowIterResets[rowIndex].Width > 0.0f &&
+						    UiPointInRect(layout.rowIterResets[rowIndex], static_cast<float>(x),
+						                  static_cast<float>(y)))
+						{
+							return LoadCursorW(nullptr, IDC_HAND);
+						}
+						if (rowIndex < layout.rowIterTracks.size() &&
+						    WeakPeakSliderHit(layout.rowIterTracks[rowIndex], m_scale,
+						                      static_cast<float>(x), static_cast<float>(y)))
+						{
+							return LoadCursorW(nullptr, IDC_SIZEWE);
+						}
+						if (rowIndex < layout.rowLevelTracks.size() &&
+						    WeakPeakSliderHit(layout.rowLevelTracks[rowIndex], m_scale,
+						                      static_cast<float>(x), static_cast<float>(y)))
+						{
+							return LoadCursorW(nullptr, IDC_SIZEWE);
+						}
+					}
+				}
+				// 面板主体（含底部编辑行与参数输入框）：保持原始箭头。
+				return nullptr;
+			}
+			int edgeLane = -1;
+			if (IsOnEdgeCursorLine(x, y, edgeLane))
+			{
+				return LoadCursorW(nullptr, IDC_SIZENS);
+			}
+		}
+
+		// 图例中的「GX」编号徽标：**悬停时不改变鼠标形状**（用户明确要求：只在按下左键
+		// 拖拽时才显示上下箭头，见 `LANE_REORDER` 分支）。这里保持“不改变”的语义并
+		// **提前返回**（不再往下落到光标线/图例判定），与原先的优先级完全一致。
+		if (LaneBadgeAtPoint(x, y) >= 0)
+		{
+			return nullptr;
+		}
+
+		// 光标时间读数标签与双光标差值标签：**悬停（未按下）时不改变鼠标形状**。
+		// 两个标签都叠在光标线的正上方，因此必须先于"光标线"判定返回 nullptr，
+		// 由调用方回退成箭头；只有真正拖拽时才切成左右箭头（见 CURSOR_MOVE / CURSOR_SPAN_MOVE）。
+		if (IsOnCursorSpanLabel(x, y))
+		{
+			return nullptr;
+		}
+		{
+			int labelWhich = 0;
+			if (IsOnCursorTimeLabel(x, y, labelWhich))
+			{
+				return nullptr;
+			}
+		}
+
+		{
+			int cursorWhich = 0;
+			if (IsOnCursorLine(x, cursorWhich) && UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y)))
+			{
+				return LoadCursorW(nullptr, IDC_SIZEWE);
+			}
+		}
+
+		if (UiPointInRect(m_plotRect, static_cast<float>(x), static_cast<float>(y)))
+		{
+			// 悬停命中可拖拽信号时**不改变鼠标形状**（维持原始箭头）；
+			// 只有真正按下拖动（MOVE_SIGNAL）才切换为抓握光标。
+			// 悬停图例时同样保持箭头，仅做半高亮提示。
+
+			// 选区放大模式下**未开始框选时保持默认箭头**（不改变鼠标形状）；
+			// 只有真正按下并拖动后才切成十字/方向箭头。
+			// （m_dragMode == RUBBER_SELECT 的情况已在上面处理。）
+		}
+		return nullptr;
+	}
+
+	bool PlotView::OnMouseMove(int x, int y)
+	{
+		const bool mouseMoved = (x != m_mouseX) || (y != m_mouseY);
+		m_mouseX = x;
+		m_mouseY = y;
+
+		if (!HasDrawableContent())
+		{
+			return false;
+		}
+
+		const float fx = static_cast<float>(x);
+
+		switch (m_dragMode)
+		{
+		case PlotDragMode::PAN:
+		{
+			if (m_plotRect.Width <= 0.0f)
+			{
+				return false;
+			}
+
+			// 横向拖动平移时间轴；纵向拖动偏移当前网格的幅值显示位置。
+			const double span = Tab().ViewMax() - Tab().ViewMin();
+			const double delta =
+			    -static_cast<double>(x - m_dragLastX) / static_cast<double>(m_plotRect.Width) * span;
+			if (delta != 0.0)
+			{
+				Tab().ViewMin() += delta;
+				Tab().ViewMax() += delta;
+				ClampTimeView();
+			}
+
+			const int laneIndex = m_dragLane;
+			if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()) && y != m_dragLastY)
+			{
+				const LaneVisual& visual = m_lanes[static_cast<std::size_t>(laneIndex)];
+				if (visual.rect.Height > 0.0f)
+				{
+					const double valueSpan = visual.yMax - visual.yMin;
+					const double deltaValue = static_cast<double>(y - m_dragLastY) /
+					                          static_cast<double>(visual.rect.Height) * valueSpan;
+					ShiftLaneRange(laneIndex, deltaValue);
+				}
+			}
+
+			m_dragLastX = x;
+			m_dragLastY = y;
+			if (std::abs(x - m_dragStartX) > 3 || std::abs(y - m_dragStartY) > 3)
+			{
+				m_dragMoved = true;
+			}
+			return true;
+		}
+		case PlotDragMode::RUBBER_SELECT:
+		{
+			const float dx = static_cast<float>(x - m_dragStartX);
+			const float dy = static_cast<float>(y - m_dragStartY);
+
+			// 轴向由首次明显位移决定，之后固定不变（避免拖拽中途选区形态跳变）。
+			if (m_rubberAxis == PlotRubberAxis::UNDECIDED)
+			{
+				const float threshold = 4.0f * m_scale;
+				if (std::fabs(dx) < threshold && std::fabs(dy) < threshold)
+				{
+					return true;
+				}
+				m_rubberAxis = (std::fabs(dx) >= std::fabs(dy)) ? PlotRubberAxis::TIME : PlotRubberAxis::VALUE;
+			}
+
+			if (m_rubberAxis == PlotRubberAxis::TIME)
+			{
+				// 竖向选区贯穿整个绘图区高度，只取横向区间用于时间轴缩放。
+				// **横向必须夹在绘图区内**：鼠标被捕获时可能移动到工具栏 / 信号面板等处，
+				// 若不夹取，选区会画到绘图区之外（那些区域只会被局部失效，于是残留成"绘制错误"）。
+				const float plotLeft = m_plotRect.X;
+				const float plotRight = m_plotRect.X + m_plotRect.Width;
+				const float from = ClampDouble(static_cast<double>(m_dragStartX),
+				                               static_cast<double>(plotLeft),
+				                               static_cast<double>(plotRight));
+				const float to = ClampDouble(static_cast<double>(x), static_cast<double>(plotLeft),
+				                             static_cast<double>(plotRight));
+				const float left = std::min(from, to);
+				const float width = std::fabs(to - from);
+				m_rubberRect = gd::RectF(left, m_plotRect.Y, width, m_plotRect.Height);
+			}
+			else
+			{
+				// 横向选区限定在按下时的网格内（纵向同样夹在该网格内），只取纵向区间用于幅值轴缩放。
+				if (m_dragLane < 0 || m_dragLane >= static_cast<int>(m_lanes.size()))
+				{
+					return false;
+				}
+				const gd::RectF& laneRect = m_lanes[static_cast<std::size_t>(m_dragLane)].rect;
+				const float from = ClampDouble(static_cast<double>(m_dragStartY),
+				                               static_cast<double>(laneRect.Y),
+				                               static_cast<double>(laneRect.Y + laneRect.Height));
+				const float to = ClampDouble(static_cast<double>(y), static_cast<double>(laneRect.Y),
+				                             static_cast<double>(laneRect.Y + laneRect.Height));
+				const float top = std::min(from, to);
+				const float bottom = std::max(from, to);
+				m_rubberRect = gd::RectF(laneRect.X, top, laneRect.Width, bottom - top);
+			}
+			m_dragMoved = true;
+			// 拖动过程中维持显示"右键取消选区"说明（粘滞，直到松开左键后才淡出）。
+			SetHintSticky(L"右键取消选区，ESC退出选区模式");
+			return true;
+		}
+		case PlotDragMode::SCROLL_LANES:
+		{
+			if (m_plotRect.Height <= 0.0f || m_laneContentHeight <= m_plotRect.Height)
+			{
+				return false;
+			}
+			const double travel =
+			    static_cast<double>(y - m_dragLastY) / static_cast<double>(m_plotRect.Height);
+			Tab().LaneScroll() += static_cast<float>(travel * m_laneContentHeight);
+			m_dragLastY = y;
+			m_dragMoved = true;
+			BuildLaneVisuals();
+			return true;
+		}
+		case PlotDragMode::CURSOR_MOVE:
+		{
+			// 从时间读数标签上抓起时保留横向抓取偏移，避免一按下光标就跳到鼠标中心。
+			const double target = XToTime(fx - static_cast<float>(m_cursorGrabOffset));
+			const bool second =
+			    (m_hoverCursor == 2 && Tab().CursorMode() == PlotCursorMode::DOUBLE);
+			// 吸附 + 夹取统一在 `PlaceCursorTime` 里完成（光标位置不变量只在那里维护）：
+			//  * 吸附只接受可见区间内、且视界内还能分辨的采样点；
+			//  * 结果必定落在当前可见区间内（否则用户看到的是一拖就"飞到视界边缘"）。
+			PlaceCursorTime(second ? 2 : 1, target);
+			m_dragMoved = true;
+			m_cursorHover = true;
+			return true;
+		}
+		case PlotDragMode::CURSOR_SPAN_MOVE:
+		{
+			// 拖拽差值标签：两条光标整体平移，间隔保持不变。
+			const double startTime = XToTime(static_cast<float>(m_spanDragStartX));
+			const double delta = XToTime(fx) - startTime;
+			double first = m_spanDragTime1 + delta;
+			double second = m_spanDragTime2 + delta;
+			// 整体平移后同样不能越出可视区：先尝试保持间隔地整体夹取，
+			// 两光标间隔本身就大于可视跨度时退化为各自夹取。
+			const double low = Tab().ViewMin();
+			const double high = Tab().ViewMax();
+			if (high > low)
+			{
+				const double inset = (high - low) * 0.002;
+				const double lo = low + inset;
+				const double hi = high - inset;
+				const double pairLow = std::min(first, second);
+				const double pairHigh = std::max(first, second);
+				if (pairHigh - pairLow <= hi - lo)
+				{
+					if (pairLow < lo)
+					{
+						first += lo - pairLow;
+						second += lo - pairLow;
+					}
+					else if (pairHigh > hi)
+					{
+						first -= pairHigh - hi;
+						second -= pairHigh - hi;
+					}
+				}
+				else
+				{
+					first = ClampDouble(first, lo, hi);
+					second = ClampDouble(second, lo, hi);
+				}
+			}
+			Tab().CursorTime() = first;
+			Tab().CursorTimeAlt() = second;
+			m_dragMoved = true;
+			return true;
+		}
+		case PlotDragMode::PEAK_LEVEL:
+		{
+			// 「弱峰调整」某信号的等级滑块：按滑轨横向位置换算 -400% – +400%。
+			if (m_tab == nullptr || m_peakDragLane < 0 ||
+			    m_peakDragLane >= static_cast<int>(m_tab->Lanes().size()))
+			{
+				break;
+			}
+			const EdgePanelLayout layout = EdgePanelLayoutFor(m_peakDragLane, EdgePanelKind::PEAK);
+			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_peakDragLane)];
+			if (lane.FindWeakPeakItem(m_peakDragRef) == nullptr)
+			{
+				break;
+			}
+			Lane::WeakPeakItem& item = lane.EnsureWeakPeakItem(m_peakDragRef);
+			const int rowIndex = PeakRowIndexOf(layout, m_peakDragRef);
+			if (rowIndex < 0 || rowIndex >= static_cast<int>(layout.rowLevelTracks.size()) ||
+			    layout.rowLevelTracks[static_cast<std::size_t>(rowIndex)].Width <= 0.0f)
+			{
+				break;
+			}
+			const double ratio =
+			    UiSliderRatioFromX(layout.rowLevelTracks[static_cast<std::size_t>(rowIndex)], fx);
+			// 滑块量程 -200% – +200%：0 在正中间。
+			// 滑块量程 -400% – +400%（三组规则的梯度区间）：0 在正中间。
+			item.amountPercent = std::max(
+			    kWeakPeakAmountMin,
+			    std::min(kWeakPeakAmountMax,
+			             static_cast<int>(std::lround((ratio * 2.0 - 1.0) * 100.0 * kWeakPeakSliderScale))));
+			m_weakPeakCurveCache.clear();
+			m_dragMoved = true;
+			return true;
+		}
+		case PlotDragMode::PEAK_ITERATIONS:
+		{
+			// 「弱峰调整」某信号的迭代次数滑块：量程为 1 … 该信号自己的上限。
+			if (m_tab == nullptr || m_peakDragLane < 0 ||
+			    m_peakDragLane >= static_cast<int>(m_tab->Lanes().size()))
+			{
+				break;
+			}
+			const EdgePanelLayout layout = EdgePanelLayoutFor(m_peakDragLane, EdgePanelKind::PEAK);
+			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_peakDragLane)];
+			if (lane.FindWeakPeakItem(m_peakDragRef) == nullptr)
+			{
+				break;
+			}
+			Lane::WeakPeakItem& item = lane.EnsureWeakPeakItem(m_peakDragRef);
+			const int rowIndex = PeakRowIndexOf(layout, m_peakDragRef);
+			if (rowIndex < 0 || rowIndex >= static_cast<int>(layout.rowIterTracks.size()) ||
+			    layout.rowIterTracks[static_cast<std::size_t>(rowIndex)].Width <= 0.0f)
+			{
+				break;
+			}
+			const double ratio =
+			    UiSliderRatioFromX(layout.rowIterTracks[static_cast<std::size_t>(rowIndex)], fx);
+			const int peakMax = std::max(kWeakPeakIterationsMin,
+			                             std::min(kWeakPeakIterationsMaxLimit, item.maxIterations));
+			item.iterations = std::max(
+			    kWeakPeakIterationsMin,
+			    std::min(peakMax, kWeakPeakIterationsMin +
+			                          static_cast<int>(std::lround(
+			                              ratio * (peakMax - kWeakPeakIterationsMin)))));
+			m_weakPeakCurveCache.clear();
+			m_dragMoved = true;
+			return true;
+		}
+		case PlotDragMode::MOVE_SIGNAL:
+		{
+			const int target = LaneAtY(y);
+			m_dragMoved = true;
+			m_dragMouseX = x;
+			m_dragMouseY = y;
+			if (target != m_dragTargetLane)
+			{
+				m_dragTargetLane = target;
+			}
+			return true;
+		}
+		case PlotDragMode::LANE_REORDER:
+		{
+			// 被拖拽的网格自由跟随鼠标；目标位置变化时其它网格实时让位（吸附）。
+			m_laneDragMouseY = y;
+			const int target = LaneDragTargetAt(y);
+			if (target != m_laneDragTarget)
+			{
+				m_laneDragTarget = target;
+			}
+			m_dragMoved = true;
+			return true;
+		}
+		case PlotDragMode::EDGE_MOVE:
+		{
+			// 横向光标：上下移动幅值（夹在该网格的可见幅值范围内）。
+			if (m_tab == nullptr || m_edgeDragLane < 0 ||
+			    m_edgeDragLane >= static_cast<int>(m_lanes.size()) ||
+			    m_edgeDragLane >= static_cast<int>(m_tab->Lanes().size()))
+			{
+				break;
+			}
+			const LaneVisual& visual = m_lanes[static_cast<std::size_t>(m_edgeDragLane)];
+			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_edgeDragLane)];
+			double value = YToValue(static_cast<float>(y), visual);
+			const double low = std::min(visual.yMin, visual.yMax);
+			const double high = std::max(visual.yMin, visual.yMax);
+			value = std::max(low, std::min(value, high));
+			lane.edgeValue = value;
+			lane.edgeValueValid = true;
+			m_dragMoved = true;
+			return true;
+		}
+		case PlotDragMode::EDGE_PANEL_MOVE:
+		{
+			// 浮动面板：**只能从标题栏拖动**（按下时已限制），整体限制在绘图区内。
+			if (m_tab == nullptr || m_edgePanelDragLane < 0 ||
+			    m_edgePanelDragLane >= static_cast<int>(m_tab->Lanes().size()))
+			{
+				break;
+			}
+			const gd::RectF panel =
+			    EdgePanelLayoutFor(m_edgePanelDragLane, m_edgePanelDragKind).panel;
+			if (panel.Width <= 0.0f)
+			{
+				break;
+			}
+			float left = static_cast<float>(x) - m_edgePanelDragOffset.X;
+			float top = static_cast<float>(y) - m_edgePanelDragOffset.Y;
+			left = std::max(m_plotRect.X + 2.0f * m_scale,
+			                std::min(left, m_plotRect.X + m_plotRect.Width - panel.Width - 2.0f * m_scale));
+			top = std::max(m_plotRect.Y + 2.0f * m_scale,
+			               std::min(top, m_plotRect.Y + m_plotRect.Height - panel.Height - 2.0f * m_scale));
+			Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(m_edgePanelDragLane)];
+			switch (m_edgePanelDragKind)
+			{
+			case EdgePanelKind::CENTER:
+				lane.edgeCenterPanelX = left;
+				lane.edgeCenterPanelY = top;
+				break;
+			case EdgePanelKind::MEAN:
+				lane.meanFilterPanelX = left;
+				lane.meanFilterPanelY = top;
+				break;
+			case EdgePanelKind::PEAK:
+				lane.weakPeakPanelX = left;
+				lane.weakPeakPanelY = top;
+				break;
+			case EdgePanelKind::COUNT:
+			default:
+				lane.edgePanelX = left;
+				lane.edgePanelY = top;
+				break;
+			}
+			m_dragMoved = true;
+			return true;
+		}
+		case PlotDragMode::NONE:
+		default:
+			break;
+		}
+
+		bool changed = false;
+
+		// 鼠标压在实验性功能面板上时不再触发信号悬停提示（面板本来就盖住波形），
+		// 但该面板所属的网格仍然要高亮（与鼠标直接停在网格上一致）。
+		// 按**层序**取最上层的面板（与点击命中保持一致，重叠时以最上层为准）。
+		bool overEdgePanel = false;
+		int panelLane = -1;
+		int hoverPanelKind = 0;
+		{
+			overEdgePanel = TopPanelAtPoint(static_cast<float>(x), static_cast<float>(y), panelLane,
+			                                hoverPanelKind);
+		}
+
+		// 「弱峰调整」每行滑块右侧的**复位控件**：悬停时给出一次性提示（进入时设置、离开时清除）。
+		// 与「系数/偏移」二级面板标题栏的还原图标同一交互语义（悬停高亮 + 手型 + 提示）。
+		bool overPeakReset = false;
+		if (overEdgePanel && panelLane >= 0 && m_tab != nullptr &&
+		    static_cast<EdgePanelKind>(hoverPanelKind) == EdgePanelKind::PEAK)
+		{
+			const EdgePanelLayout resetLayout = EdgePanelLayoutFor(panelLane, EdgePanelKind::PEAK);
+			for (std::size_t rowIndex = 0; rowIndex < resetLayout.rowLevelResets.size(); ++rowIndex)
+			{
+				const gd::RectF& level = resetLayout.rowLevelResets[rowIndex];
+				if (level.Width > 0.0f && UiPointInRect(level, fx, static_cast<float>(y)))
+				{
+					overPeakReset = true;
+					break;
+				}
+				if (rowIndex < resetLayout.rowIterResets.size())
+				{
+					const gd::RectF& iter = resetLayout.rowIterResets[rowIndex];
+					if (iter.Width > 0.0f && UiPointInRect(iter, fx, static_cast<float>(y)))
+					{
+						overPeakReset = true;
+						break;
+					}
+				}
+			}
+		}
+		if (overPeakReset != m_peakResetHover)
+		{
+			m_peakResetHover = overPeakReset;
+			SetHint(overPeakReset ? std::wstring(L"点击恢复该参数的默认值") : std::wstring());
+			changed = true;
+		}
+
+		// 悬停网格：**只有**鼠标悬停在实验性功能浮动面板上时才高亮该面板所属网格。
+		// ⚠️ 用户 2026-10-15 明确要求：鼠标在网格里移动**不再触发**网格变色高亮；
+		//    改为在信号列表 / 样式区「目标」行悬停到某条已绘制信号时联动高亮
+		//    （见 `SetExternalHoverSignal` 与 `EffectiveHoverLane`）。
+		const int lane = overEdgePanel ? panelLane : -1;
+		if (lane != m_hoverLane)
+		{
+			m_hoverLane = lane;
+			changed = true;
+		}
+
+		// 「GX」编号徽标的悬停高亮：徽标本体在静态场景 / 装饰缓存里被冻结，高亮是叠加层，
+		// 因此必须靠这个**单独的状态**触发重绘与取消。徽标命中的网格直接用鼠标纵坐标算，
+		// 与上面的「悬停网格高亮」解耦（后者已不再跟随鼠标位置）。
+		int hoverBadge = -1;
+		if (m_dragMode == PlotDragMode::NONE && !overEdgePanel)
+		{
+			const int underMouse = LaneAtY(y);
+			if (underMouse >= 0)
+			{
+				const gd::RectF badge = LaneBadgeRect(underMouse);
+				if (badge.Width > 0.0f &&
+				    UiPointInRect(badge, static_cast<float>(x), static_cast<float>(y)))
+				{
+					hoverBadge = underMouse;
+				}
+			}
+		}
+		if (hoverBadge != m_hoverBadge)
+		{
+			m_hoverBadge = hoverBadge;
+			changed = true;
+		}
+
+		// ✕ 关闭按钮 / 等级与迭代次数滑块 / 底部按钮的悬停提示都直接依赖鼠标坐标，
+		// 但它们在面板内部移动时上面这些状态可能毫无变化（例如从同一网格的波形移到面板上），
+		// 于是返回值恒为 false → 宿主不重绘 → **悬停提示不会出现**。
+		// 因此在“鼠标进入 / 离开 / 在面板内移动”时强制标记需要重绘。
+		if ((overEdgePanel || m_mouseOverPanel) && mouseMoved)
+		{
+			changed = true;
+		}
+		m_mouseOverPanel = overEdgePanel;
+
+		// 时间光标不再跟随鼠标移动，仅在鼠标覆盖光标时才显示具体时间读数。
+		int hoverWhich = 0;
+		const bool hover = Tab().CursorEnabled() && IsOnCursorLine(x, hoverWhich);
+		if (hover != m_cursorHover)
+		{
+			m_cursorHover = hover;
+			changed = true;
+		}
+		if (hoverWhich != m_hoverCursor)
+		{
+			m_hoverCursor = hoverWhich;
+			changed = true;
+		}
+
+		// 精确检测鼠标是否贴近某条信号曲线，用于给出可拖拽提示。
+		// 图例优先于曲线：图例条目是可点选目标（与左侧信号列表一致），
+		// 但悬停图例时**只做半高亮提示**，不显示曲线拖拽提示（也不触发光晕）。
+		// **图例悬停在选区放大模式下同样生效**（该模式只改变拖拽语义）。
+		SignalRef hoverSignal;
+		SignalRef hoverLegend;
+		if (!m_cursorHover && !overEdgePanel)
+		{
+			hoverLegend = LegendAtPoint(x, y);
+			if (!hoverLegend.IsValid() && Tab().ZoomMode() == PlotZoomMode::NONE)
+			{
+				hoverSignal = HitTestSignal(x, y);
+			}
+		}
+		if (hoverSignal != m_hoverSignal)
+		{
+			m_hoverSignal = hoverSignal;
+			changed = true;
+		}
+		if (hoverLegend != m_hoverLegend)
+		{
+			m_hoverLegend = hoverLegend;
+			changed = true;
+		}
+
+		// 双光标差值标签的悬停状态（用于区分"抓握/悬停"光标与普通状态）。
+		const bool spanHover = IsOnCursorSpanLabel(x, y);
+		if (spanHover != m_spanHover)
+		{
+			m_spanHover = spanHover;
+			changed = true;
+		}
+
+		// 悬停提示跟随鼠标：只要提示可见，鼠标移动本身就要触发重绘；
+		// 否则鼠标在可拖拽区域内继续移动时，提示会停在上一帧的位置。
+		if (m_hoverSignal.IsValid() && mouseMoved)
+		{
+			changed = true;
+		}
+		return changed;
+	}
+
+	bool PlotView::OnLButtonDown(int x, int y)
+	{
+		if (!HasDrawableContent())
+		{
+			return false;
+		}
+
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+
+		m_dragStartX = x;
+		m_dragStartY = y;
+		m_dragLastX = x;
+		m_dragLastY = y;
+		m_dragMoved = false;
+		m_rubberRect = gd::RectF();
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+		m_cursorGrabOffset = 0;
+		// 新的交互开始：清掉上一次留下的提示（拖动过程中会重新设置粘滞提示）。
+		SetHint(std::wstring());
+		// 上一轮尚未抬起确认的面板关闭请求一律作废。
+		m_pendingPanelClose = false;
+		m_pendingPanelCloseLane = -1;
+
+		if (m_scrollBarVisible &&
+		    UiPointInRect(m_scrollBarRect, static_cast<float>(x), static_cast<float>(y)))
+		{
+			m_dragMode = PlotDragMode::SCROLL_LANES;
+			return true;
+		}
+
+		// 内联输入中：输入框之外的点击视为提交（与线宽输入一致）。
+		if (IsEditing())
+		{
+			if (!UiPointInRect(EditFieldRect(), fx, fy))
+			{
+				EndEdit(true);
+			}
+			return true;
+		}
+
+		// 双光标模式下先检查差值标签：它可拖拽（两条光标整体平移，间隔不变）。
+		if (IsOnCursorSpanLabel(x, y))
+		{
+			m_dragMode = PlotDragMode::CURSOR_SPAN_MOVE;
+			m_spanDragStartX = x;
+			m_spanDragTime1 = Tab().CursorTime();
+			m_spanDragTime2 = Tab().CursorTimeAlt();
+			return true;
+		}
+
+		// 光标时间读数标签：可直接抓住拖动（与抓住光标线等价）。
+		{
+			int labelWhich = 0;
+			if (IsOnCursorTimeLabel(x, y, labelWhich))
+			{
+				m_dragMode = PlotDragMode::CURSOR_MOVE;
+				m_hoverCursor = labelWhich;
+				m_activeCursor = labelWhich;
+				m_cursorHover = true;
+				// 抓取偏移 = “手指按在读数标签的哪个位置”。
+				// ⚠️ 但光标**滞留在视界之外**时读数被钉在网格边缘，此时抓取点与光标真实位置
+				// 之间没有任何有意义的对应关系：仍然沿用偏移会让首次移动把目标送到视界之外
+				//（再被夹回边缘），表现为“一拖就跳很远 / 光标钉在边缘不动”。
+				// 因此这种情形下不带偏移：首次移动就把光标放在鼠标处（自然地拖回来）。
+				bool offRight = false;
+				const bool offView = CursorOffViewSide(labelWhich, offRight);
+				m_cursorGrabOffset =
+				    offView ? 0
+				            : (x - static_cast<int>(std::lround(CursorDisplayX(labelWhich))));
+				return true;
+			}
+		}
+
+		// 图例与 GX 编号徽标叠在波形之上、且直接位于网格顶部——用户明确要求它们**优先响应**：
+		// 必须先于「时间光标线 / 光标读数 / 边沿计数横向光标 / 选区放大」判定，否则：
+		//  * 光标线恰好经过徽标/图例时，按下会变成拖光标；
+		//  * 选区放大模式下会变成“开始框选”，用户看到的就是“GX 拖不动、图例点不中”。
+		// 层序上仍然让位于浮动面板（面板绘制在徽标与图例之上），因此先挡一次面板命中。
+		int guardLane = -1;
+		int guardKind = 0;
+		const bool guardPanel = TopPanelAtPoint(fx, fy, guardLane, guardKind);
+
+		// 网格次序拖拽：按在图例的 GX 编号徽标上即可整块拎起该网格上下移动。
+		if (!guardPanel)
+		{
+			const int badgeLane = LaneBadgeAtPoint(x, y);
+			if (badgeLane >= 0)
+			{
+				m_dragMode = PlotDragMode::LANE_REORDER;
+				m_laneDragFrom = badgeLane;
+				m_laneDragTarget = badgeLane;
+				m_laneDragMouseY = y;
+				m_laneDragGrabOffset =
+				    static_cast<float>(y) - m_lanes[static_cast<std::size_t>(badgeLane)].rect.Y;
+				// 拖动期间保持静态场景缓存有效：内容按网格条带平移贴回，
+				// 因此不必重绘百万级采样的波形（见 PaintLaneReorder）。
+				return true;
+			}
+		}
+
+		// 点击图例条目等价于在左侧列表中选中该信号（样式区随之切换目标）。
+		// **必须在选区放大判定之前**：选区放大模式只改变拖拽语义，
+		// 不应影响图例的悬停与点选（否则用户在选区放大模式下无法切换信号）。
+		if (!guardPanel)
+		{
+			const SignalRef legendHit = LegendAtPoint(x, y);
+			if (legendHit.IsValid())
+			{
+				SelectSignal(legendHit);
+				m_dragMode = PlotDragMode::NONE;
+				return true;
+			}
+		}
+
+		// 靠近时间光标线时进入拖动。
+		// （放在徽标/图例之后：两者重叠时徽标与图例优先，与用户要求一致。）
+		if (!guardPanel)
+		{
+			int cursorWhich = 0;
+			if (IsOnCursorLine(x, cursorWhich) && UiPointInRect(m_area, fx, fy))
+			{
+				m_dragMode = PlotDragMode::CURSOR_MOVE;
+				m_hoverCursor = cursorWhich;
+				// 点中的光标成为“活动光标”：它触发的内容将画在上层。
+				m_activeCursor = cursorWhich;
+				m_cursorHover = true;
+				return true;
+			}
+		}
+
+		// 实验性功能浮动面板（面板压在波形之上，必须先于信号拖拽判定）：
+		// * ✕ → 关闭该网格对应的功能；
+		// * 逐条目参数输入框 → 进入内联编辑；
+		// * 底部按钮 → 触发「构建为新信号」请求；
+		// * 标题栏 → 拖动面板；
+		// * 面板主体 → 消费点击，但**不拖动也不穿透**（用户明确要求只有标题栏可拖拽）。
+		//
+		// ⚠️ **按层序从上层往下命中**（重叠时只有最上层那个面板响应），并在命中后把该面板
+		// **置顶**（用户点击哪个就把哪个放到最上层），这样：
+		//  * 上层面板的 ✕ / 标题栏不会被下层面板的参数输入框抢走（否则"上层面板关不掉 / 拖不动"）；
+		//  * 两个面板重叠时总能操作到用户想要的那一个。
+		{
+			int panelLane = -1;
+			int panelKindValue = 0;
+			if (TopPanelAtPoint(fx, fy, panelLane, panelKindValue))
+			{
+				const EdgePanelKind kind = static_cast<EdgePanelKind>(panelKindValue);
+				const int index = panelLane;
+				BringPanelToFront(index, panelKindValue);
+				const EdgePanelLayout layout = EdgePanelLayoutFor(index, kind);
+
+				if (UiPointInRect(layout.close, fx, fy))
+				{
+					// ✕：**抬起**时才关闭该网格对应的实验性功能，这里只记录目标；
+					// 按住后移开再松开视为放弃（与面板/标签栏的关闭 ✕ 语义一致）。
+					// ⚠️ 必须在此**直接消费**该次按下：✕ 位于标题栏矩形内部，
+					// 若继续往下走会被“标题栏 → 拖动面板”分支命中，表现为“按下 ✕ 却拖走了面板”。
+					m_pendingPanelClose = true;
+					m_pendingPanelCloseLane = index;
+					m_pendingPanelCloseKind = kind;
+					m_dragMode = PlotDragMode::NONE;
+					return true;
+				}
+
+				// 「中心轴边沿计数」/「均值滤波」/「弱峰调整」面板：逐信号条目
+				// （前两者是「名称 + 复选框 + 两个参数输入框」，弱峰调整是「名称 + 复选框 + 两行滑块」）。
+				if ((kind == EdgePanelKind::MEAN || kind == EdgePanelKind::CENTER ||
+				     kind == EdgePanelKind::PEAK) &&
+				    m_tab != nullptr)
+				{
+					const bool meanMode = (kind == EdgePanelKind::MEAN);
+					const bool boostMode = (kind == EdgePanelKind::PEAK);
+					Lane& tabLane = m_tab->Lanes()[static_cast<std::size_t>(index)];
+
+					// 「弱峰调整」：先判两行滑块（数值文本 → 改上限；轨道 → 拖动）。
+					if (boostMode)
+					{
+						for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
+						{
+							const SignalRef& ref = layout.rowRefs[rowIndex];
+							const bool hasLevel = rowIndex < layout.rowLevelTracks.size() &&
+							                      layout.rowLevelTracks[rowIndex].Width > 0.0f;
+							if (!hasLevel)
+							{
+								continue;
+							}
+							if (tabLane.FindWeakPeakItem(ref) == nullptr)
+							{
+								continue;
+							}
+							Lane::WeakPeakItem& item = tabLane.EnsureWeakPeakItem(ref);
+							// 两行滑块右侧的**复位控件**：点击恢复该行参数的默认值
+							//（幅度 → 0；迭代次数 → 1 且上限回到初始上限 `kWeakPeakIterationsDefaultMax`）。
+							// 与「系数/偏移」二级面板里的还原图标同一交互语义（面板保持打开、就地回显）。
+							if (rowIndex < layout.rowLevelResets.size() &&
+							    layout.rowLevelResets[rowIndex].Width > 0.0f &&
+							    UiPointInRect(layout.rowLevelResets[rowIndex], fx, fy))
+							{
+								item.amountPercent = 0;
+								m_weakPeakCurveCache.clear();
+								m_dragMode = PlotDragMode::NONE;
+								return true;
+							}
+							if (rowIndex < layout.rowIterResets.size() &&
+							    layout.rowIterResets[rowIndex].Width > 0.0f &&
+							    UiPointInRect(layout.rowIterResets[rowIndex], fx, fy))
+							{
+								item.iterations = kWeakPeakIterationsMin;
+								item.maxIterations = kWeakPeakIterationsDefaultMax;
+								m_weakPeakCurveCache.clear();
+								m_dragMode = PlotDragMode::NONE;
+								return true;
+							}
+							// 迭代次数行右侧的**数值文本**：点击后整行变成输入框以修改滑块上限。
+							// ⚠️ 必须放在轨道命中之前（数值区在轨道右侧，命中区不重叠，但顺序更安全）。
+							if (layout.rowIterValues[rowIndex].Width > 0.0f &&
+							    UiPointInRect(layout.rowIterValues[rowIndex], fx, fy))
+							{
+								m_editMeanRef = ref;
+								m_peakEditCurrentMax = item.maxIterations;
+								// 输入框以**空内容**开始：空内容时显示当前上限作为灰色提示。
+								// 输入框覆盖"整条滑块行"（从轨道左端到数值文本右端）。
+								const gd::RectF& track = layout.rowIterTracks[rowIndex];
+								const gd::RectF& value = layout.rowIterValues[rowIndex];
+								const gd::RectF rowRect(track.X, value.Y, value.X + value.Width - track.X,
+								                        value.Height);
+								BeginEdit(PlotEditTarget::PEAK_ITERATIONS_MAX, index, L"", rowRect);
+								// `BeginEdit` 默认用 NUMBER 过滤（允许负号/小数点）；这里改为**纯数字**，
+								// 从源头保证"只允许输入正整数"（负数、小数根本无法键入，粘贴同样被清洗）。
+								m_edit.Begin(L"", false, EditFilter::BYTE, 0u);
+								m_dragMode = PlotDragMode::NONE;
+								return true;
+							}
+							if (layout.rowIterTracks[rowIndex].Width > 0.0f &&
+							    WeakPeakSliderHit(layout.rowIterTracks[rowIndex], m_scale, fx, fy))
+							{
+								m_dragMode = PlotDragMode::PEAK_ITERATIONS;
+								m_peakDragLane = index;
+								m_peakDragRef = ref;
+								const double ratio = UiSliderRatioFromX(layout.rowIterTracks[rowIndex], fx);
+								const int peakMax = std::max(kWeakPeakIterationsMin,
+								                             std::min(kWeakPeakIterationsMaxLimit,
+								                                      item.maxIterations));
+								item.iterations = std::max(
+								    kWeakPeakIterationsMin,
+								    std::min(peakMax, kWeakPeakIterationsMin +
+								                          static_cast<int>(std::lround(
+								                              ratio * (peakMax - kWeakPeakIterationsMin)))));
+								m_weakPeakCurveCache.clear();
+								return true;
+							}
+							if (layout.rowLevelTracks[rowIndex].Width > 0.0f &&
+							    WeakPeakSliderHit(layout.rowLevelTracks[rowIndex], m_scale, fx, fy))
+							{
+								m_dragMode = PlotDragMode::PEAK_LEVEL;
+								m_peakDragLane = index;
+								m_peakDragRef = ref;
+								// 单击轨道：直接写入该处对应的幅度（-400% … +400%，0 在正中间）。
+								item.amountPercent = static_cast<int>(std::lround(
+								    (UiSliderRatioFromX(layout.rowLevelTracks[rowIndex], fx) * 2.0 - 1.0) *
+								    100.0 * kWeakPeakSliderScale));
+								item.amountPercent = std::max(
+								    kWeakPeakAmountMin,
+								    std::min(kWeakPeakAmountMax, item.amountPercent));
+								m_weakPeakCurveCache.clear();
+								return true;
+							}
+						}
+					}
+
+					for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
+					{
+						const SignalRef& ref = layout.rowRefs[rowIndex];
+						// 第一排右侧的复选框 → 切换该信号的预览勾选状态。
+						if (layout.rowChecks[rowIndex].Width > 0.0f &&
+						    UiPointInRect(layout.rowChecks[rowIndex], fx, fy))
+						{
+							if (meanMode)
+							{
+								ToggleLaneMeanFilterSignal(index, ref);
+							}
+							else if (boostMode)
+							{
+								ToggleLaneWeakPeakSignal(index, ref);
+							}
+							else
+							{
+								ToggleLaneEdgeCenterSignal(index, ref);
+							}
+							// 勾选变化只改变该信号“是否显示”，它的统计状态（与参数相关）依然有效，
+							// 其它信号更是完全无关 ⇒ **不要**清任何缓存（清掉就会让所有统计重算）。
+							// 这里**不**整体作废场景缓存（交给 `m_sceneDerived` 快照驱动局部重画）。
+							m_dragMode = PlotDragMode::NONE;
+							return true;
+						}
+						// 第二排的两个输入框 → 就地编辑该信号的参数（仅 MEAN / CENTER 面板；
+						// 弱峰调整用的是滑块，已在上面处理）。
+						if (layout.rowPoints[rowIndex].Width > 0.0f &&
+						    UiPointInRect(layout.rowPoints[rowIndex], fx, fy))
+						{
+							m_editMeanRef = ref;
+							const Lane::MeanFilterItem* item =
+							    meanMode ? tabLane.FindMeanFilterItem(ref)
+							             : tabLane.FindEdgeCenterItem(ref);
+							BeginEdit(meanMode ? PlotEditTarget::MEAN_FILTER_POINTS
+							                   : PlotEditTarget::EDGE_CENTER_POINTS,
+							          index, std::to_wstring(item != nullptr ? item->points : 5),
+							          layout.rowPoints[rowIndex]);
+							return true;
+						}
+						if (layout.rowIterations[rowIndex].Width > 0.0f &&
+						    UiPointInRect(layout.rowIterations[rowIndex], fx, fy))
+						{
+							m_editMeanRef = ref;
+							const Lane::MeanFilterItem* item =
+							    meanMode ? tabLane.FindMeanFilterItem(ref)
+							             : tabLane.FindEdgeCenterItem(ref);
+							BeginEdit(meanMode ? PlotEditTarget::MEAN_FILTER_ITERATIONS
+							                   : PlotEditTarget::EDGE_CENTER_ITERATIONS,
+							          index, std::to_wstring(item != nullptr ? item->iterations : 1),
+							          layout.rowIterations[rowIndex]);
+							return true;
+						}
+					}
+
+					if (boostMode && layout.button.Width > 0.0f && UiPointInRect(layout.button, fx, fy))
+					{
+						// 「弱峰调整 → 构建为新信号」：与均值滤波同一套请求机制，
+						// **每个信号用自己的等级与迭代次数**（与预览曲线逐位一致）。
+						const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(index)];
+						m_pendingWeakPeakItems.clear();
+						for (const SignalRef& ref : lane.signals)
+						{
+							const ResolvedSignal resolved = ResolveSignal(ref);
+							if (resolved.data == nullptr || !resolved.visible)
+							{
+								continue;
+							}
+							const Lane::WeakPeakItem* item = lane.FindWeakPeakItem(ref);
+							if (item == nullptr)
+							{
+								continue;
+							}
+							WeakPeakBuild build;
+							build.groupIndex = ref.groupIndex;
+							build.signalIndex = ref.signalIndex;
+							const int peakAmount =
+							    std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, item->amountPercent));
+							build.amountPercent = peakAmount;
+							// 迭代次数按**该信号自己的滑块量程**（1 … `maxIterations`）夹取。
+							const int peakMax = std::max(
+							    kWeakPeakIterationsMin,
+							    std::min(kWeakPeakIterationsMaxLimit, item->maxIterations));
+							build.iterations =
+							    std::max(kWeakPeakIterationsMin, std::min(peakMax, item->iterations));
+							m_pendingWeakPeakItems.push_back(build);
+						}
+						if (!m_pendingWeakPeakItems.empty())
+						{
+							const WeakPeakBuild& first = m_pendingWeakPeakItems.front();
+							SetHint(L"正在构建弱峰调整信号（幅度 " + std::to_wstring(first.amountPercent) +
+							        L"% / " + std::to_wstring(first.iterations) + L" 次迭代，共 " +
+							        std::to_wstring(m_pendingWeakPeakItems.size()) + L" 条）…");
+							m_pendingWeakPeakLane = index;
+						}
+						m_dragMode = PlotDragMode::NONE;
+						return true;
+					}
+
+					if (meanMode && layout.button.Width > 0.0f && UiPointInRect(layout.button, fx, fy))
+					{
+						// 「构建为新信号」：只登记请求（含每个信号自己的 X/N），
+						// 真正的信号构建由宿主（Application）完成。
+						const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(index)];
+						m_pendingMeanFilterItems.clear();
+						for (const SignalRef& ref : lane.signals)
+						{
+							const ResolvedSignal resolved = ResolveSignal(ref);
+							if (resolved.data == nullptr || !resolved.visible)
+							{
+								continue;
+							}
+							const Lane::MeanFilterItem* item = lane.FindMeanFilterItem(ref);
+							if (item == nullptr)
+							{
+								continue;
+							}
+							MeanFilterBuild build;
+							build.groupIndex = ref.groupIndex;
+							build.signalIndex = ref.signalIndex;
+							build.points = item->points;
+							build.iterations = item->iterations;
+							m_pendingMeanFilterItems.push_back(build);
+						}
+						if (!m_pendingMeanFilterItems.empty())
+						{
+							const MeanFilterBuild& first = m_pendingMeanFilterItems.front();
+							SetHint(L"正在构建均值滤波信号（" + std::to_wstring(first.points) +
+							        L" 点 " + std::to_wstring(first.iterations) + L" 次迭代，共 " +
+							        std::to_wstring(m_pendingMeanFilterItems.size()) + L" 条）…");
+							m_pendingMeanFilterLane = index;
+						}
+						m_dragMode = PlotDragMode::NONE;
+						return true;
+					}
+				}
+
+				if (UiPointInRect(layout.title, fx, fy))
+				{
+					m_dragMode = PlotDragMode::EDGE_PANEL_MOVE;
+					m_edgePanelDragLane = index;
+					m_edgePanelDragKind = kind;
+					m_edgePanelDragOffset.X = fx - layout.panel.X;
+					m_edgePanelDragOffset.Y = fy - layout.panel.Y;
+					return true;
+				}
+
+				// 面板主体：消费该次点击，避免误触发底层的平移/选区/信号拖拽。
+				m_dragMode = PlotDragMode::NONE;
+				return true;
+			}
+		}
+
+		// 「边沿计数」横向光标：上下拖动改变幅值。
+		{
+			int edgeLane = -1;
+			if (IsOnEdgeCursorLine(x, y, edgeLane))
+			{
+				m_dragMode = PlotDragMode::EDGE_MOVE;
+				m_edgeDragLane = edgeLane;
+				return true;
+			}
+		}
+
+		if (!UiPointInRect(m_plotRect, fx, fy))
+		{
+			m_dragMode = PlotDragMode::NONE;
+			return false;
+		}
+
+		const PlotZoomMode mode = Tab().ZoomMode();
+		if (mode == PlotZoomMode::SELECT)
+		{
+			// 选区放大：轴向由鼠标移动方向决定，因此按下时先记录网格并置为未定。
+			// 按下本身**不显示提示**（拖动开始后才显示"右键取消选区"）。
+			m_dragLane = LaneAtY(y);
+			m_rubberAxis = PlotRubberAxis::UNDECIDED;
+			m_dragMode = PlotDragMode::RUBBER_SELECT;
+			return true;
+		}
+
+		// 常规模式下：先检测是否落在信号曲线上；只有命中提示时才允许拖拽该信号。
+		const SignalRef hit = HitTestSignal(x, y);
+		if (hit.IsValid())
+		{
+			m_dragSignal = hit;
+			m_dragTargetLane = Tab().LaneOfSignal(hit);
+			SelectSignal(hit);
+			m_dragMouseX = x;
+			m_dragMouseY = y;
+			m_dragMode = PlotDragMode::MOVE_SIGNAL;
+			return true;
+		}
+
+		m_dragLane = LaneAtY(y);
+		m_dragMode = PlotDragMode::PAN;
+		return true;
+	}
+
+	bool PlotView::OnMButtonDown(int x, int y)
+	{
+		if (!HasDrawableContent())
+		{
+			return false;
+		}
+
+		// 中键：无论当前是否处于选区放大模式，都直接进入自由平移
+		// （不改变选区放大模式本身，松手后仍可继续框选）。
+		m_dragStartX = x;
+		m_dragStartY = y;
+		m_dragLastX = x;
+		m_dragLastY = y;
+		m_dragMoved = false;
+		m_rubberRect = gd::RectF();
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+		m_cursorGrabOffset = 0;
+		m_edgeDragLane = -1;
+		m_edgePanelDragLane = -1;
+		m_edgePanelDragKind = EdgePanelKind::COUNT;
+		SetHint(std::wstring());
+		m_dragLane = LaneAtY(y);
+		m_dragMode = PlotDragMode::PAN;
+		return true;
+	}
+
+	bool PlotView::OnMButtonUp()
+	{
+		const bool changed = (m_dragMode == PlotDragMode::PAN);
+		if (changed)
+		{
+			m_dragMode = PlotDragMode::NONE;
+			m_dragLane = -1;
+			m_dragMoved = false;
+			ReleaseHint();
+		}
+		return changed;
+	}
+
+	bool PlotView::OnLButtonUp(int x, int y)
+	{
+		bool changed = (m_dragMode != PlotDragMode::NONE);
+
+		// 实验性功能面板的 ✕：只有"按下后仍在同一个 ✕ 上抬起"才真正关闭该功能。
+		if (m_pendingPanelClose)
+		{
+			const int lane = m_pendingPanelCloseLane;
+			const EdgePanelKind kind = m_pendingPanelCloseKind;
+			m_pendingPanelClose = false;
+			m_pendingPanelCloseLane = -1;
+
+			if (lane >= 0 && lane < static_cast<int>(m_lanes.size()))
+			{
+				const EdgePanelLayout layout = EdgePanelLayoutFor(lane, kind);
+				if (layout.close.Width > 0.0f &&
+				    UiPointInRect(layout.close, static_cast<float>(x), static_cast<float>(y)))
+				{
+					switch (kind)
+					{
+					case EdgePanelKind::CENTER:
+						SetLaneEdgeCenterCount(lane, false);
+						break;
+					case EdgePanelKind::MEAN:
+						SetLaneMeanFilter(lane, false);
+						break;
+					case EdgePanelKind::PEAK:
+						SetLaneWeakPeak(lane, false);
+						break;
+					case EdgePanelKind::COUNT:
+					default:
+						SetLaneEdgeCount(lane, false);
+						break;
+					}
+					changed = true;
+				}
+			}
+		}
+
+		switch (m_dragMode)
+		{
+		case PlotDragMode::RUBBER_SELECT:
+		{
+			// 按拖拽方向应用对应的缩放（横向 → 时间轴；纵向 → 当前网格幅值轴）。
+			if (m_rubberAxis == PlotRubberAxis::TIME)
+			{
+				if (m_dragMoved &&
+				    ApplyTimeSelection(m_rubberRect.X, m_rubberRect.X + m_rubberRect.Width))
+				{
+					changed = true;
+				}
+			}
+			else if (m_rubberAxis == PlotRubberAxis::VALUE)
+			{
+				if (m_dragMoved &&
+				    ApplyValueSelection(m_dragLane, m_rubberRect.Y, m_rubberRect.Y + m_rubberRect.Height))
+				{
+					changed = true;
+				}
+			}
+			break;
+		}
+		case PlotDragMode::CURSOR_MOVE:
+			m_cursorHover = true;
+			break;
+		case PlotDragMode::CURSOR_SPAN_MOVE:
+			break;
+		case PlotDragMode::LANE_REORDER:
+			// 网格次序拖拽结束：真正重排并重编号（GX 徽标随之同步）。
+			FinishLaneReorder();
+			changed = true;
+			break;
+		case PlotDragMode::MOVE_SIGNAL:
+		{
+			const int target = LaneAtY(y);
+			const int source = (m_tab != nullptr) ? m_tab->LaneOfSignal(m_dragSignal) : -1;
+			if (m_dataSet != nullptr && m_tab != nullptr && m_dragSignal.IsValid() && target >= 0 &&
+			    target != source && m_dragMoved)
+			{
+				m_tab->MoveSignalToLane(*m_dataSet, m_dragSignal, target);
+				changed = true;
+			}
+			m_dragSignal = SignalRef();
+			m_dragTargetLane = -1;
+			break;
+		}
+		default:
+			break;
+		}
+
+		m_dragMode = PlotDragMode::NONE;
+		m_rubberAxis = PlotRubberAxis::UNDECIDED;
+		m_dragLane = -1;
+		m_dragMoved = false;
+		m_rubberRect = gd::RectF();
+		m_cursorGrabOffset = 0;
+		m_edgeDragLane = -1;
+		m_edgePanelDragLane = -1;
+		m_edgePanelDragKind = EdgePanelKind::COUNT;
+		// 弱峰滑块拖拽结束：清掉目标（避免留下上一轮的信号引用）。
+		m_peakDragLane = -1;
+		m_peakDragRef = SignalRef();
+		// 松开左键：粘滞提示结束计时，开始"停留后淡出"。
+		ReleaseHint();
+		return changed;
+	}
+
+	bool PlotView::OnMouseWheel(int delta, bool shift)
+	{
+		if (!HasDrawableContent() || delta == 0)
+		{
+			return false;
+		}
+
+		const double notches = static_cast<double>(delta) / 120.0;
+
+		// 滚轮不再承担缩放：默认纵向滚动网格，按住 Shift 时水平平移时间轴。
+		if (shift)
+		{
+			const double span = Tab().ViewMax() - Tab().ViewMin();
+			const double sweep = -notches * span * 0.15;
+			Tab().ViewMin() += sweep;
+			Tab().ViewMax() += sweep;
+			ClampTimeView();
+			return true;
+		}
+
+		if (m_plotRect.Height <= 0.0f || m_laneContentHeight <= m_plotRect.Height)
+		{
+			return false;
+		}
+
+		Tab().LaneScroll() -= static_cast<float>(notches * 48.0 * m_scale);
+		BuildLaneVisuals();
+		return true;
+	}
+
+	bool PlotView::OnDoubleClick(int x, int y)
+	{
+		if (!UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y)))
+		{
+			return false;
+		}
+
+		// ⚠️ **上层元素的交互绝不能穿透到下层**：实验性功能的浮动面板浮在网格之上（且绘制在
+		//    光标标签 / 图例之上），因此在它上面双击必须由它消费掉。旧实现在所有下层命中都不成
+		//    立时无条件 `FitAll()`，于是"在面板上双击任意位置"会让网格莫名其妙地自适应一次
+		//    （用户 2026-10-15 报告）。面板自身双击没有额外语义，直接消费即可。
+		{
+			int panelLane = -1;
+			int panelKind = 0;
+			if (TopPanelAtPoint(static_cast<float>(x), static_cast<float>(y), panelLane, panelKind))
+			{
+				return true;
+			}
+		}
+
+		// 双光标差值标签：双击进入差值编辑（输入值的量级始终为秒）。
+		// 注意：差值标签在"两光标过近"时会落到主时间轴内部，因此必须先于区域判定。
+		if (IsOnCursorSpanLabel(x, y))
+		{
+			return BeginEdit(PlotEditTarget::CURSOR_SPAN, -1, FormatDurationSeconds(CursorSpan()));
+		}
+
+		if (!UiPointInRect(m_area, static_cast<float>(x), static_cast<float>(y)))
+		{
+			return false;
+		}
+
+		// 命中光标时间读数标签：编辑该条光标的时间（优先于光标线，避免两条过近时选错）。
+		{
+			int labelWhich = 0;
+			if (IsOnCursorTimeLabel(x, y, labelWhich))
+			{
+				m_editCursor = labelWhich;
+				m_activeCursor = labelWhich;
+				const double time = (labelWhich == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
+				return BeginEdit(PlotEditTarget::CURSOR_TIME, -1, FormatValue(time));
+			}
+		}
+
+		// 命中时间光标：进入精确时间输入（交互与线宽输入框一致）。
+		{
+			int cursorWhich = 0;
+			if (IsOnCursorLine(x, cursorWhich))
+			{
+				m_editCursor = (cursorWhich == 2) ? 2 : 1;
+				m_activeCursor = m_editCursor;
+				const double time =
+				    (m_editCursor == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
+				return BeginEdit(PlotEditTarget::CURSOR_TIME, -1, FormatValue(time));
+			}
+		}
+
+		// 命中图例条目：进入信号改名（与左侧列表双击改名的交互一致）。
+		const SignalRef legendHit = LegendAtPoint(x, y);
+		if (legendHit.IsValid())
+		{
+			const ResolvedSignal resolved = ResolveSignal(legendHit);
+			if (resolved.data != nullptr)
+			{
+				SelectSignal(legendHit);
+				m_editSignal = legendHit;
+
+				// 先把输入框位置落在被双击的条目上，再进入编辑态。
+				for (const LegendHit& hit : m_legendHits)
+				{
+					if (hit.ref == legendHit)
+					{
+						m_editFieldRect = hit.rect;
+						break;
+					}
+				}
+				return BeginEdit(PlotEditTarget::SIGNAL_NAME, -1, resolved.data->name);
+			}
+		}
+
+		// 其它位置：回到初始状态（自适应 + 退出缩放模式）。
+		FitAll();
+		return true;
+	}
+
+	bool PlotView::OnMouseLeave()
+	{
+		bool changed = false;
+		if (m_hoverLane != -1)
+		{
+			m_hoverLane = -1;
+			changed = true;
+		}
+		if (m_hoverBadge != -1)
+		{
+			m_hoverBadge = -1;
+			changed = true;
+		}
+		if (m_hoverSignal.IsValid())
+		{
+			m_hoverSignal = SignalRef();
+			changed = true;
+		}
+		// 图例悬停半高亮同样随鼠标离开而消失（否则右键弹菜单/移出绘图区后残留在原地）。
+		if (m_hoverLegend.IsValid())
+		{
+			m_hoverLegend = SignalRef();
+			changed = true;
+		}
+		if (m_cursorHover)
+		{
+			m_cursorHover = false;
+			changed = true;
+		}
+		if (m_hoverCursor != 0 && m_dragMode != PlotDragMode::CURSOR_MOVE)
+		{
+			m_hoverCursor = 0;
+			changed = true;
+		}
+		if (m_spanHover)
+		{
+			m_spanHover = false;
+			changed = true;
+		}
+		return changed;
+	}
+
+
+	int PlotView::LaneBadgeAtPoint(int x, int y) const
+	{
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			const gd::RectF badge = LaneBadgeRect(static_cast<int>(index));
+			if (badge.Width > 0.0f && UiPointInRect(badge, fx, fy))
+			{
+				return static_cast<int>(index);
+			}
+		}
+		return -1;
+	}
+
+	float PlotView::LaneDragOffset(int laneIndex) const
+	{
+		if (m_dragMode != PlotDragMode::LANE_REORDER || m_laneDragFrom < 0 ||
+		    laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return 0.0f;
+		}
+
+		const float laneHeight = m_lanes[static_cast<std::size_t>(m_laneDragFrom)].rect.Height;
+		if (laneIndex == m_laneDragFrom)
+		{
+			// 被拖拽的网格自由跟随鼠标（整体绘制区域跟着走）。
+			const float baseTop = m_lanes[static_cast<std::size_t>(laneIndex)].rect.Y;
+			return static_cast<float>(m_laneDragMouseY) - m_laneDragGrabOffset - baseTop;
+		}
+
+		const int target = (m_laneDragTarget >= 0) ? m_laneDragTarget : m_laneDragFrom;
+		if (target > m_laneDragFrom && laneIndex > m_laneDragFrom && laneIndex < target)
+		{
+			// 向下拖：被跨越的网格整体上移一格让出位置（大小不变）。
+			// 移动到插入位置 target 的结果是 [1,2,...,A,target,...]，
+			// 因此需要上移的是 (from, target) 区间内的网格，不含 target 本身。
+			return -laneHeight;
+		}
+		if (target < m_laneDragFrom && laneIndex >= target && laneIndex < m_laneDragFrom)
+		{
+			// 向上拖：中间的网格整体下移一格。
+			return laneHeight;
+		}
+		return 0.0f;
+	}
+
+	int PlotView::LaneDragTargetAt(int mouseY) const
+	{
+		if (m_lanes.empty())
+		{
+			return 0;
+		}
+		const int count = static_cast<int>(m_lanes.size());
+		const float laneHeight = m_lanes.front().rect.Height;
+		if (!(laneHeight > 0.0f))
+		{
+			return m_laneDragFrom;
+		}
+
+		// 判据 = **被拖网格自己的上下边界**（用户明确要求）：
+		//   * 上边界越过"上方第 m 个网格"的中心水平线 → 让位 m 个位置（插入位置 = from - m）；
+		//   * 下边界越过"下方第 m 个网格"的中心水平线 → 让位 m 个位置（插入位置 = from + m + 1，
+		//     因为被拖网格会先从原位置摘除，越过后应落在该网格之后）。
+		//
+		// ⚠️ 旧判据只看**鼠标指针**落在哪个网格的哪一半。因为被拖网格整体跟随指针，而指针通常
+		// 按在网格上沿的 GX 徽标上，于是"向下拖必须把整个网格拖过下方网格才吸附、
+		// 向上拖只要半个网格" —— 上下不对称（用户报告）。改用网格边界后上下完全对称。
+		//
+		// 数学：令 shift = 被拖网格相对原槽位的位移，H = 网格高。
+		//   上边界 = baseTop + shift，上方第 m 个网格的中心线 = baseTop - (m - 0.5)H
+		//   ⇒ 满足 shift < (0.5 - m)H 的最大 m 即让位格数（m < 0.5 - shift/H）；
+		//   下边界 = baseTop + shift + H，下方第 m 个网格的中心线 = baseTop + (m + 0.5)H
+		//   ⇒ 满足 shift > (m - 0.5)H 的最大 m（m < shift/H + 0.5）。
+		// ⚠️ 两侧条件互斥（不可能同时成立），因此最多只会向一侧吸附。
+		const float baseTop = m_lanes[static_cast<std::size_t>(m_laneDragFrom)].rect.Y;
+		const float shift =
+		    static_cast<float>(mouseY) - m_laneDragGrabOffset - baseTop;
+		const float upRatio = 0.5f - shift / laneHeight;		// m < upRatio
+		const float downRatio = shift / laneHeight + 0.5f;		// m < downRatio
+		// "严格小于" ⇒ 最大整数 m = ceil(ratio) - 1。
+		int up = static_cast<int>(std::ceil(upRatio)) - 1;
+		int down = static_cast<int>(std::ceil(downRatio)) - 1;
+		up = std::max(0, std::min(up, m_laneDragFrom));
+		down = std::max(0, std::min(down, count - 1 - m_laneDragFrom));
+		if (up > 0)
+		{
+			return m_laneDragFrom - up;
+		}
+		if (down > 0)
+		{
+			return m_laneDragFrom + down + 1;
+		}
+		return m_laneDragFrom;
+	}
+
+	void PlotView::FinishLaneReorder()
+	{
+		const int from = m_laneDragFrom;
+		const int target = m_laneDragTarget;
+		m_laneDragFrom = -1;
+		m_laneDragTarget = -1;
+		m_laneDragGrabOffset = 0.0f;
+		m_dragMode = PlotDragMode::NONE;
+
+		if (m_tab == nullptr || from < 0 || target < 0)
+		{
+			return;
+		}
+		if (!m_tab->MoveLane(from, target))
+		{
+			return;
+		}
+		// 网格次序变化 → 几何、派生缓存与静态场景缓存全部失效。
+		BuildLaneVisuals();
+		InvalidateDerivedCaches();
+	}
+
+	SignalRef PlotView::LegendAtPoint(int x, int y) const
+	{
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+		for (const LegendHit& hit : m_legendHits)
+		{
+			if (UiPointInRect(hit.rect, fx, fy))
+			{
+				return hit.ref;
+			}
+		}
+		return SignalRef();
+	}
+
+	gd::RectF PlotView::CursorSpanRect(bool& insideAxis) const
+	{
+		insideAxis = false;
+		if (m_tab == nullptr || Tab().CursorMode() != PlotCursorMode::DOUBLE ||
+		    m_fonts == nullptr || m_fonts->monoSmall == nullptr)
+		{
+			return gd::RectF();
+		}
+
+		const std::wstring text = FormatSpanText(CursorSpan());
+		const float width = std::max(
+		    72.0f * m_scale, UiMeasureTextWidth(m_fonts->monoSmall, text) + 18.0f * m_scale);
+		const float height = 20.0f * m_scale;
+
+		// 水平位置取两条光标时间读数的中点（与它们同一行，位于时间轴上方）。
+		// 注意用"显示横坐标"：光标滞留在可视区外时会被钉在网格边缘，
+		// 此时二者在屏幕上必然很近，差值标签应改放到主时间轴内部。
+		const gd::RectF first = CursorLabelRect(1);
+		const gd::RectF second = CursorLabelRect(2);
+		float center = (CursorDisplayX(1) + CursorDisplayX(2)) * 0.5f;
+		if (first.Width > 0.0f && second.Width > 0.0f)
+		{
+			center = ((first.X + first.Width * 0.5f) + (second.X + second.Width * 0.5f)) * 0.5f;
+		}
+
+		float left = center - width * 0.5f;
+		left = std::max(m_plotRect.X + 2.0f * m_scale,
+		                std::min(left, m_plotRect.X + m_plotRect.Width - width - 2.0f * m_scale));
+
+		// 两条**时间读数标签**之间的净空不足时，同一行放不下第三个标签
+		// → 改放到主时间轴内部（时间轴上方已无空间）。
+		const gd::RectF& leftRect = (first.X <= second.X) ? first : second;
+		const gd::RectF& rightRect = (first.X <= second.X) ? second : first;
+		const float freeStart = leftRect.X + leftRect.Width;
+		const float freeEnd = rightRect.X;
+		const bool fits = (freeStart <= freeEnd) && ((freeEnd - freeStart) >= (width + 2.0f * m_scale));
+
+		// 双光标都滞留在**同一侧**视界之外时，两条时间读数会被钉在同一条边上并叠成两行；
+		// 此时差值标签也跟着它们排成一列（用户要求"垂直排列要对齐"），
+		// 而不是孤零零地留在时间轴上方。
+		const float pinLeftEdge = m_plotRect.X + 1.0f * m_scale;
+		const float pinRightEdge = m_plotRect.X + m_plotRect.Width - 1.0f * m_scale;
+		const bool offLeft1 = CursorX(1) < pinLeftEdge;
+		const bool offRight1 = CursorX(1) > pinRightEdge;
+		const bool offLeft2 = CursorX(2) < pinLeftEdge;
+		const bool offRight2 = CursorX(2) > pinRightEdge;
+		const bool bothOffSameSide = (offLeft1 && offLeft2 && !offRight1 && !offRight2) ||
+		                             (offRight1 && offRight2 && !offLeft1 && !offLeft2);
+
+		if (bothOffSameSide)
+		{
+			// 与两条时间读数同一列、叠在它们下方（更靠下的一行之下）。
+			const float columnLeft = std::max(m_plotRect.X, first.X);
+			const float stackBottom = std::max(first.Y, second.Y) + first.Height + 2.0f * m_scale;
+			insideAxis = true;
+			const float axisHeight = std::max(14.0f * m_scale, m_timeAxisRect.Height - 4.0f * m_scale);
+			return gd::RectF(columnLeft, stackBottom, width, std::min(height, axisHeight));
+		}
+
+		if (!fits)
+		{
+			insideAxis = true;
+			const float top = m_timeAxisRect.Y + 2.0f * m_scale;
+			const float axisHeight = std::max(14.0f * m_scale, m_timeAxisRect.Height - 4.0f * m_scale);
+			return gd::RectF(left, top, width, std::min(height, axisHeight));
+		}
+
+		return gd::RectF(left, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale, width, height);
+	}
+
+	bool PlotView::CursorOffViewSide(int which, bool& offRight) const
+	{
+		offRight = false;
+		if (m_tab == nullptr || !Tab().CursorEnabled())
+		{
+			return false;
+		}
+		const float pinLeft = m_plotRect.X + 1.0f * m_scale;
+		const float pinRight = m_plotRect.X + m_plotRect.Width - 1.0f * m_scale;
+		const float raw = CursorX(which);
+		if (raw < pinLeft)
+		{
+			return true;
+		}
+		if (raw > pinRight)
+		{
+			offRight = true;
+			return true;
+		}
+		return false;
+	}
+
+	void PlotView::SyncPanelOrder() const
+	{
+		// 收集当前"可见"（已启用且已展开、且网格内有可见信号）的面板集合。
+		std::vector<PanelRef> visible;
+		for (int index = 0; index < static_cast<int>(m_lanes.size()); ++index)
+		{
+			for (int pass = 0; pass < kEdgePanelKindCount; ++pass)
+			{
+				const EdgePanelKind kind = kEdgePanelKinds[pass];
+				if (EdgePanelLayoutFor(index, kind).panel.Width > 0.0f)
+				{
+					PanelRef ref;
+					ref.laneIndex = index;
+					ref.kind = static_cast<int>(kind);
+					visible.push_back(ref);
+				}
+			}
+		}
+		// 保留已有层序（剔除已不可见的），并把**新出现**的面板追加到队尾（= 最上层），
+		// 这样新打开的面板不会被已有面板盖住。
+		std::vector<PanelRef> next;
+		next.reserve(visible.size());
+		for (const PanelRef& existing : m_panelOrder)
+		{
+			for (const PanelRef& candidate : visible)
+			{
+				if (candidate == existing)
+				{
+					next.push_back(existing);
+					break;
+				}
+			}
+		}
+		for (const PanelRef& candidate : visible)
+		{
+			bool present = false;
+			for (const PanelRef& kept : next)
+			{
+				if (kept == candidate)
+				{
+					present = true;
+					break;
+				}
+			}
+			if (!present)
+			{
+				next.push_back(candidate);
+			}
+		}
+		m_panelOrder = std::move(next);
+	}
+
+	void PlotView::BringPanelToFront(int laneIndex, int kind)
+	{
+		SyncPanelOrder();
+		PanelRef target;
+		target.laneIndex = laneIndex;
+		target.kind = kind;
+		for (std::size_t index = 0; index < m_panelOrder.size(); ++index)
+		{
+			if (!(m_panelOrder[index] == target))
+			{
+				continue;
+			}
+			if (index + 1 == m_panelOrder.size())
+			{
+				return;		// 已经在最上层
+			}
+			m_panelOrder.erase(m_panelOrder.begin() + static_cast<std::ptrdiff_t>(index));
+			m_panelOrder.push_back(target);
+			return;
+		}
+	}
+
+	bool PlotView::TopPanelAtPoint(float x, float y, int& laneIndex, int& kind) const
+	{
+		laneIndex = -1;
+		kind = 0;
+		SyncPanelOrder();
+		// `m_panelOrder` 队尾 = 最上层：从后往前找第一个命中的面板。
+		for (std::size_t index = m_panelOrder.size(); index-- > 0;)
+		{
+			const PanelRef& ref = m_panelOrder[index];
+			const EdgePanelLayout layout =
+			    EdgePanelLayoutFor(ref.laneIndex, static_cast<EdgePanelKind>(ref.kind));
+			if (layout.panel.Width <= 0.0f)
+			{
+				continue;
+			}
+			if (UiPointInRect(layout.panel, x, y))
+			{
+				laneIndex = ref.laneIndex;
+				kind = ref.kind;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	int PlotView::PeakRowIndexOf(const EdgePanelLayout& layout, const SignalRef& ref) const
+	{
+		for (std::size_t index = 0; index < layout.rowRefs.size(); ++index)
+		{
+			if (layout.rowRefs[index] == ref)
+			{
+				return static_cast<int>(index);
+			}
+		}
+		return -1;
+	}
+
+	bool PlotView::IsOnEdgeCursorLine(int x, int y, int& laneIndex) const
+	{
+		laneIndex = -1;
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		const std::vector<Lane>& tabLanes = m_tab->Lanes();
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+		const float tolerance = 5.0f * m_scale;
+
+		for (std::size_t index = 0; index < m_lanes.size() && index < tabLanes.size(); ++index)
+		{
+			if (!tabLanes[index].edgeCount)
+			{
+				continue;
+			}
+			const LaneVisual& visual = m_lanes[index];
+			if (fx < visual.rect.X || fx > visual.rect.X + visual.rect.Width)
+			{
+				continue;
+			}
+			const float clipTop = std::max(visual.rect.Y, m_plotRect.Y);
+			const float clipBottom =
+			    std::min(visual.rect.Y + visual.rect.Height, m_plotRect.Y + m_plotRect.Height);
+			if (clipBottom <= clipTop)
+			{
+				continue;
+			}
+			const float lineY = std::max(
+			    clipTop, std::min(ValueToY(tabLanes[index].edgeValue, visual), clipBottom));
+			if (std::fabs(fy - lineY) <= tolerance)
+			{
+				laneIndex = static_cast<int>(index);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	PlotView::DataMarker PlotView::MakeDataMarker(float rawX, float rawY, float pinX, float clipTop,
+	                                              float clipBottom, float topReserve) const
+	{
+		DataMarker marker;
+		// 形状**只**由“数据点本身是否越出绘制边界”决定：
+		// 旧实现拿“夹取之后”的位置反推越界方向，于是贴近边界、其实仍在视界内的数据点
+		// 也会被误画成三角（用户报告的“数值显示超出边界就改变数据点形状”）。
+		const float left = m_plotRect.X;
+		const float right = m_plotRect.X + m_plotRect.Width;
+		marker.offLeft = (rawX < left);
+		marker.offRight = (rawX > right);
+		marker.offUp = (rawY < clipTop);
+		marker.offDown = (rawY > clipBottom);
+
+		marker.x = pinX;
+		// 左右越界时三角沿水平方向**向外**伸出 `kMarkerTriangleDepth`：
+		// 光标贴边时 pinX 只离边界 1px，若直接把锚点放在那里，三角会有一大半画到
+		// 网格绘制区之外（被裁剪后只看到残缺的一角，描边也随之断开）。
+		// 因此把锚点沿水平方向**向内**推 keepIn，保证三角完整落在绘制区内。
+		const float keepIn = (kMarkerTriangleDepth + 1.0f) * m_scale;
+		if (marker.offLeft)
+		{
+			marker.x = std::max(pinX, left + keepIn);
+		}
+		else if (marker.offRight)
+		{
+			marker.x = std::min(pinX, right - keepIn);
+		}
+
+		if (marker.offUp)
+		{
+			// 上越界：为方向三角与顶部把手预留高度，避免压住把手。
+			marker.y = clipTop + kMarkerEdgeInset * m_scale + topReserve;
+		}
+		else if (marker.offDown)
+		{
+			marker.y = clipBottom - kMarkerEdgeInset * m_scale;
+		}
+		else
+		{
+			// 视界内：保留数据点的真实纵坐标（越界判定已在上面完成，这里夹取只为了让
+			// 圆点整体可见，不会影响形状）。
+			marker.y = std::max(clipTop + kMarkerInsideMargin * m_scale,
+			                    std::min(rawY, clipBottom - kMarkerInsideMargin * m_scale));
+		}
+		return marker;
+	}
+
+	void PlotView::PlaceCursorLabel(gd::RectF& rect, float preferredTop, float textHeight,
+	                                float clipTop, float clipBottom)
+	{
+		const float gap = 2.0f * m_scale;
+		const float minTop = clipTop + 1.0f * m_scale;
+		const float maxTop = std::max(minTop, clipBottom - textHeight - 1.0f * m_scale);
+		rect.Y = std::max(minTop, std::min(preferredTop, maxTop));
+
+		const auto overlaps = [this](const gd::RectF& candidate, const gd::RectF*& hit) -> bool
+		{
+			for (const gd::RectF& occupied : m_cursorLabelRects)
+			{
+				if (candidate.IntersectsWith(occupied))
+				{
+					hit = &occupied;
+					return true;
+				}
+			}
+			return false;
+		};
+
+		bool resolved = false;
+		for (int step = 0; step < 16; ++step)
+		{
+			const gd::RectF* hit = nullptr;
+			if (!overlaps(rect, hit))
+			{
+				resolved = true;
+				break;
+			}
+			// 向下推一格；超出网格底部则改由原始位置向上避让。
+			const float next = hit->Y + hit->Height + gap;
+			if (next > maxTop)
+			{
+				break;
+			}
+			rect.Y = next;
+		}
+		if (!resolved)
+		{
+			rect.Y = std::max(minTop, std::min(preferredTop, maxTop));
+			for (int step = 0; step < 16; ++step)
+			{
+				const gd::RectF* hit = nullptr;
+				if (!overlaps(rect, hit))
+				{
+					break;
+				}
+				rect.Y = hit->Y - rect.Height - gap;
+				if (rect.Y < minTop)
+				{
+					break;
+				}
+			}
+		}
+		rect.Y = std::max(minTop, std::min(rect.Y, maxTop));
+		m_cursorLabelRects.push_back(rect);
+	}
+
+
+} // namespace jdi
+
diff --git a/Components/PlotView/Src/PlotViewInternal.hpp b/Components/PlotView/Src/PlotViewInternal.hpp
new file mode 100644
index 0000000..9209abe
--- /dev/null
+++ b/Components/PlotView/Src/PlotViewInternal.hpp
@@ -0,0 +1,932 @@
+#ifndef __PLOT_VIEW_INTERNAL_HPP__
+#define __PLOT_VIEW_INTERNAL_HPP__
+
+// Components/PlotView 组件内部共享的常量与工具函数（私有头，仅本组件的 .cpp 使用）。
+//
+// PlotView 的实现按功能拆成多个协作文件：
+//   PlotView.cpp              视图核心（上下文 / 布局 / 坐标映射 / 视界与缩放 / 网格结构）
+//   PlotViewPaint.cpp         渲染与像素缓存（绘制 / 场景与装饰缓存 / 图层 / 宽基底）
+//   PlotViewInteraction.cpp   交互、命中测试与内联编辑
+//   PlotViewFeatures.cpp      实验性功能、派生曲线、边沿统计、自适应与光标吸附
+// 它们共用这一份内部工具集。
+//
+// ⚠️ 为让多个翻译单元都能使用，原匿名命名空间改为**具名**命名空间 `pvdetail`，
+//    并把其中每个函数与常量标为 `inline` —— 单一定义、单一副本，不会产生代码重复。
+//    各实现文件在包含本头之后用 `using namespace pvdetail;` 引入这些工具，
+//    因此函数体里原有的非限定调用（如 `IntersectRect` / `NiceStep`）一行都不用改。
+
+#include <windows.h>
+#include <objidl.h>
+#include <gdiplus.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "PlotView.hpp"
+#include "UiControls.hpp"
+#include "Utf8Util.hpp"
+
+namespace jdi
+{
+
+	namespace pvdetail
+	{
+	/**
+	 * @brief PlotView 内部工具集（常量 / 几何与配色辅助 / 边沿统计辅助 / 绘制辅助）。
+	 *
+	 * 全部符号都是 `inline` ⇒ 多个翻译单元共用同一个定义：既不重复符号，也不产生多份代码。
+	 * 不要把它们移回匿名命名空间（那样每个 .cpp 都会各自复制一份）。
+	 */
+		inline const int kTimeTickTarget = 10;				/**< 时间轴期望刻度数。 */
+		inline const int kYTickTarget = 6;					/**< 幅值轴期望刻度数（网格较高时）。 */
+		inline const int kYTickTargetMin = 3;				/**< 幅值轴最少刻度数（网格很矮时也要保证可读数）。 */
+		inline const int kYTickTargetMax = 8;				/**< 幅值轴最多刻度数。 */
+		inline const float kYTickSpacing = 28.0f;			/**< 幅值刻度之间的理想间距（逻辑像素）。 */
+		inline const float kYLabelMinGap = 15.0f;			/**< 幅值标签的最小行距（逻辑像素）。 */
+		inline const int kMinorDivisions = 5;				/**< 相邻主刻度之间的等分数（用于估读）。 */
+		inline const unsigned int kMinorLineAlpha = 0x9Au;	/**< 辅助等分线的透明度（越高越清晰）。 */
+		inline const float kScrollBarThickness = 9.0f;		/**< 滚动条宽度（逻辑像素）。 */
+		inline const float kLanePadding = 8.0f;			/**< 网格内边距。 */
+		inline const size_t kMaxPolylinePoints = 20000;	/**< 单条折线最大顶点数（上限保护）。 */
+		inline const size_t kPolylinePointsPerPixel = 2;	/**< 每个像素列允许的折线顶点数（上/下包络两顶点）。 */
+		inline const size_t kMinPolylinePoints = 512;		/**< 折线最少顶点数（窗口很窄时仍保留细节）。 */
+		/**
+		 * @brief 图层**纵向滚动**的量化阈值（位图像素）。
+		 *
+		 * 幅值平移不足该值时**不滚动**图层，交给贴图时的纵向偏移（`srcY`）处理；
+		 * 超过才滚动一次并补画新暴露的一整条。这样画布映射在拖动过程中保持稳定 →
+		 * 折线缓存（键含幅值映射）能命中，避免"每帧滚 1 行 → 每帧重算折线"的性能陷阱。
+		 */
+		inline const int kLayerRollQuantum = 16;
+		inline const float kEnvelopeMinPixelSpan = 0.5f;	/**< 包络纵向跨度小于该像素值时合并为单个顶点。 */
+		inline const float kCursorHandleReserve = 9.0f;	/**< 光标顶部三角把手占用的高度（数据点贴边时需避让）。 */
+		inline const float kMarkerEdgeInset = 7.0f;		/**< 数据点越界贴边时距网格可见边界的间距。 */
+		inline const float kMarkerInsideMargin = 2.0f;	/**< 数据点在视界内时允许贴到边界的最小余量。 */
+		inline const float kMarkerTriangleArm = 5.0f;		/**< 越界方向三角"半宽/半高"（垂直于朝向的半边长）。 */
+		/** 越界方向三角沿朝向的深度（与光标把手同比例）。 */
+		inline const float kMarkerTriangleDepth = kMarkerTriangleArm * 1.4f;
+		/**
+		 * 越界方向三角与数值/时间标注之间的间隙（逻辑像素）。
+		 *
+		 * 三角与胶囊之间**必须留出这段空白**：贴在一起时三角看起来像胶囊上多出来的
+		 * 一个尖角（用户报告的"三角形与数值显示部分没有间隔"）。
+		 */
+		inline const float kMarkerTriangleGap = 4.0f;
+		inline const size_t kMaxScatterPoints = 2500;		/**< 单条散点最大绘制点数。 */
+		inline const size_t kPolylineCacheLimit = 64;		/**< 折线顶点缓存条目上限。 */
+		inline const float kMinScatterRadius = 1.6f;		/**< 散点最小半径（逻辑像素）。 */
+		inline const float kMaxScatterRadius = 12.0f;	/**< 散点最大半径（逻辑像素）。 */
+		inline const float kScatterRadiusScale = 1.5f;	/**< 散点半径相对线宽的增长系数。 */
+		inline const double kMinTimeSpan = 1.0e-12;		/**< 允许的最小时间跨度。 */
+		inline const float kPlotSidePadding = 8.0f;		/**< 绘图区左右留白（逻辑像素）。 */
+		inline const float kLaneDividerWidth = 2.0f;		/**< 网格之间分界线的宽度。 */
+		inline const float kSignalHitTolerance = 6.0f;	/**< 信号曲线命中容差（逻辑像素）。 */
+		/**
+		 * @brief 两个矩形的交集（空交集返回宽高为 0 的矩形）。
+		 *
+		 * 用于把 GDI 绘制（不受 GDI+ 裁剪约束）限制在"本次真正要重画的区域"内，
+		 * 见 `PaintLane` 里的 `laneClip`。
+		 */
+		inline gd::RectF IntersectRect(const gd::RectF& first, const gd::RectF& second)
+		{
+			const float left = std::max(first.X, second.X);
+			const float top = std::max(first.Y, second.Y);
+			const float right = std::min(first.X + first.Width, second.X + second.Width);
+			const float bottom = std::min(first.Y + first.Height, second.Y + second.Height);
+			if (right <= left || bottom <= top)
+			{
+				return gd::RectF(left, top, 0.0f, 0.0f);
+			}
+			return gd::RectF(left, top, right - left, bottom - top);
+		}
+
+		/**
+		 * @brief 绘制「还原/重置」图标（逆时针回环箭头）。
+		 *
+		 * 与 `PopupMenu` 里「系数 / 偏移」二级面板标题栏右侧的还原图标**同一套笔画**
+		 *（用户要求：“可以直接挪用信号『调整』功能中『系数/偏移』二级菜单内的复位控件”），
+		 * 因此弱峰调整面板的复位控件与它视觉完全一致。不依赖字体或资源，任意 DPI 都清晰。
+		 *
+		 * @param [IN,OUT] g 绘图上下文。
+		 * @param [IN] rect 图标外接矩形（正方形）。
+		 * @param [IN] color 笔画颜色（0xAARRGGBB）。
+		 * @param [IN] scale DPI 缩放比例。
+		 */
+		inline void PaintPanelResetIcon(gd::Graphics& g, const gd::RectF& rect, std::uint32_t color,
+		                         float scale)
+		{
+			const float inset = 2.5f * scale;
+			gd::RectF box(rect.X + inset, rect.Y + inset, rect.Width - inset * 2.0f,
+			              rect.Height - inset * 2.0f);
+			if (box.Width <= 1.0f || box.Height <= 1.0f)
+			{
+				return;
+			}
+			gd::Pen pen(gd::Color((color >> 24) & 0xFFu, (color >> 16) & 0xFFu, (color >> 8) & 0xFFu,
+			                      color & 0xFFu),
+			            std::max(1.0f, 1.5f * scale));
+			pen.SetStartCap(gd::LineCapRound);
+			pen.SetEndCap(gd::LineCapRound);
+			// 缺口留在右上角（从 300° 到 20° 处断开），与常见的"重置/刷新"图标一致。
+			g.DrawArc(&pen, box.X, box.Y, box.Width, box.Height, 300.0f, 300.0f);
+
+			// 箭头：位于缺口末端（约 300° 方向），指向前进方向。
+			const float cx = box.X + box.Width * 0.5f;
+			const float cy = box.Y + box.Height * 0.5f;
+			const float radius = box.Width * 0.5f;
+			const float angle = 300.0f * 3.14159265f / 180.0f;
+			const float tipX = cx + std::cos(angle) * radius;
+			const float tipY = cy + std::sin(angle) * radius;
+			const float size = std::max(2.5f, 3.2f * scale);
+			gd::PointF arrow[3];
+			arrow[0] = gd::PointF(tipX, tipY);
+			arrow[1] = gd::PointF(tipX - size, tipY - size * 0.25f);
+			arrow[2] = gd::PointF(tipX - size * 0.25f, tipY - size);
+			gd::SolidBrush brush(gd::Color((color >> 24) & 0xFFu, (color >> 16) & 0xFFu,
+			                               (color >> 8) & 0xFFu, color & 0xFFu));
+			g.FillPolygon(&brush, arrow, 3);
+		}
+
+		/**
+		 * @brief 光标吸附的**判定系数**：一屏内的数据点少于 `网格小格数 × 该系数` 时才开启吸附。
+		 *
+		 * 用户 2026-10-15 明确定义：网格底衬一横排有 N 个小格（见 `GridMinorCellCount`），
+		 * **当且仅当**某信号在当前视界内的数据点个数 `< N × 4` 时为它开启光标吸附。
+		 * 该判据随视界实时重算 ⇒ 疏密变化的信号在稀疏区自动吸附、稠密区自动自由移动。
+		 */
+		inline const int kSnapVisibleCellsPerPoint = 4;
+
+		/**
+		 * @brief 吸附半径（以**网格小格**为单位）：一个数据点只用其**一个小格宽**内的移动来吸。
+		 *
+		 * 吸附半径 = 一个网格小格的宽度（与判定用同一套网格定义），且**不超过半个采样间距**
+		 * ——后者保证点很稀疏时（例如一屏只有一两个点）光标在点与点之间仍可自由移动，
+		 * 而不是被“死死吸住”（用户明确要求：吸附只是提示性响应）。
+		 */
+		inline const double kSnapRadiusCells = 1.0;
+
+		/**
+		 * @brief 一般信号查找“离光标最近的有效采样点”时向两侧探测的最大步数。
+		 *
+		 * 采样值里的 NaN 只出现在缺少数据的区段（例如多时间轴 CSV 的较短轴的尾部），
+		 * 因此从最近下标向外少量探测即可找到有效点；探测失败就不吸附（宁可自由移动）。
+		 */
+		inline const int kSnapSampleProbeSteps = 64;
+
+		/**
+		 * @brief 判定“可见数据点是否足够少”时允许扫描的最大样本数（相对阈值的倍数）。
+		 *
+		 * 判定只需知道“有效点是否少于阈值”，因此扫到阈值个有效点就早退；
+		 * 但连续 NaN 不会被计入，因此再给一个**有界**的扫描窗口防止极端情况下的长循环。
+		 */
+		inline const std::size_t kSnapScanWindowFactor = 64;
+
+		/**
+		 * @brief 「所有可见数据点都是单值信号、且时刻完全相同」时，时间轴**一个大格**对应的秒数。
+		 *
+		 * 用户 2026-10-15 明确要求：这种最极端情况下时间轴以该时刻居中、并缩放到
+		 * **一大格 = 1s** 的级别。视界跨度取 `kTimeTickTarget` 个大格 ⇒
+		 * 跨度 = 10s、`NiceStep(10, kTimeTickTarget)` = **1.0 秒**，正好是"一大格 1s"。
+		 */
+		inline const double kSinglePointClusterSecondsPerCell = 1.0;
+
+		/**
+		 * @brief 让边界处的单值散点"完整显示"时，在半径之外额外多留的像素（设备像素）。
+		 *
+		 * 只让出**正好等于半径**的量会让圆点边缘贴着网格边框（抗锯齿边缘看起来被切了一刀），
+		 * 因此再多留 1 个像素。
+		 */
+		inline const float kSinglePointBoundaryPadPixels = 1.0f;
+
+		/**
+		 * @brief 判定"多个单值数据点处于同一时刻"的相对误差。
+		 *
+		 * 同一列里读出的时刻是完全相同的 double；但不同来源（例如 MF4 的整数刻度 ×
+		 * 通道组的标定系数）可能差 1ulp，因此用相对误差而不是精确相等。
+		 */
+		inline const double kSinglePointSameTimeEpsilon = 1.0e-9;
+
+		inline const float kLaneLabelPad = 6.0f;		/**< 网格内侧标尺带的内边距。 */
+		inline const float kLegendHeight = 19.0f;		/**< 图例条目高度（逻辑像素）。 */
+		inline const float kLegendPad = 5.0f;			/**< 图例相对网格左上角的内缩。 */
+		inline const float kLegendSwatchSize = 8.0f;	/**< 图例色块尺寸。 */
+		inline const float kLegendItemGap = 14.0f;		/**< 图例条目之间的间距。 */
+		inline const float kLegendMaxTextWidth = 200.0f;	/**< 图例条目的文本宽度上限（超出则省略）。 */
+		inline const float kLaneBadgeWidth = 30.0f;		/**< 网格编号徽标宽度（与信号面板保持一致）。 */
+		inline const float kLaneBadgeHeight = 17.0f;		/**< 网格编号徽标高度。 */
+		inline const float kLaneBadgeGap = 8.0f;		/**< 编号徽标与图例条目之间的间距。 */
+		inline const float kEdgePanelWidth = 230.0f;		/**< 边沿统计浮动面板宽度。 */
+		inline const float kEdgePanelTitleHeight = 26.0f;	/**< 面板标题栏高度。 */
+		inline const float kEdgePanelRowHeight = 18.0f;	/**< 面板内单行文本高度。 */
+		inline const float kEdgePanelPad = 7.0f;		/**< 面板内边距。 */
+		inline const float kEdgePanelNameMaxWidth = 150.0f;	/**< 面板内信号名的宽度上限（超过则省略；避免超长信号名把面板顶得很长）。 */
+		inline const float kEdgePanelStatColumnGap = 14.0f;	/**< 「上升沿 / 下降沿」两列之间的间距（保证多信号的文字垂直对齐）。 */
+		inline const float kEdgePanelEditFieldWidth = 64.0f;	/**< 数值框的最小宽度。 */
+		inline const float kEdgePanelButtonHeight = 30.0f;	/**< 均值滤波面板底部按钮行高度。 */
+		inline const float kEdgePanelMeanRowHeight = 22.0f;	/**< 逐条目面板中每条信号的名称行高度。 */
+		inline const float kEdgePanelMeanEditHeight = 24.0f;	/**< 逐条目面板中每条信号的参数行高度。 */
+		inline const float kEdgePanelMeanRowGap = 2.0f;		/**< 名称行与参数行之间的间距。 */
+		inline const float kEdgePanelMeanCheckSize = 15.0f;	/**< 逐条目面板中条目复选框尺寸。 */
+		inline const float kWeakPeakSliderRowHeight = 26.0f;	/**< 弱峰调整面板中每个滑块行的高度。 */
+		inline const float kWeakPeakTrackHeight = 6.0f;		/**< 弱峰调整滑块的轨道高度。 */
+		inline const float kWeakPeakTrackMinWidth = 120.0f;	/**< 弱峰调整滑块轨道的最小宽度。 */
+		/**
+		 * @brief 「弱峰调整」滑块行右侧**复位控件**的边长（逻辑像素）。
+		 *
+		 * 每行滑块都有一个复位按钮（与「系数/偏移」二级面板里的「还原」图标同一套绘制），
+		 * 点击把该行的参数恢复为默认值（幅度 0 / 迭代次数 1 且上限回到初始上限）。
+		 */
+		inline const float kWeakPeakResetButtonSize = 16.0f;
+		/** 复位控件与其左侧数值列之间的间距（逻辑像素）。 */
+		inline const float kWeakPeakResetGap = 4.0f;
+		inline const int kWeakPeakIterationsMin = 1;				/**< 迭代次数 N 的下限。 */
+		/** 迭代次数滑块「自定义上限」的允许范围（与算法内部的阶数夹取保持一致）。 */
+		inline const int kWeakPeakIterationsMaxLimit = 1000;
+		/** 迭代次数滑块上限的默认值（与 `Lane::WeakPeakItem::maxIterations` 一致）。 */
+		inline const int kWeakPeakIterationsDefaultMax = 10;
+		/**
+		 * @brief 「弱峰调整」滑动条的量程（±400%）。
+		 *
+		 * 滑动条同时驱动三组识别规则（见 `ComputeWeakPeakAdjust`）：0–100% 只有第一类规则在动，
+		 * 之后每 100% 加入下一类、而前一类继续走完自己的 0–200%。因此量程是算法内部
+		 * 「单组 ±200%」的两倍。
+		 */
+		inline const double kWeakPeakSliderScale = 4.0;
+		/** 弱峰调整幅度百分比上限（滑动条右端，用于构建新信号 / 曲线缓存键）。 */
+		inline const int kWeakPeakAmountMax = 400;
+		/** 弱峰调整幅度百分比下限（滑动条左端，负值 = 削弱）。 */
+		inline const int kWeakPeakAmountMin = -400;
+		/**
+		 * @brief 派生曲线「区间窗口」缓存的保护带上限（采样点数）。
+		 *
+		 * 窗口只覆盖可见区间 ± 保护带，可见区间内的取值与整条曲线一致（见 `CurveSpanFor`）。
+		 * 上限避免在完全缩小时把保护带放大到整条信号（那就退化成重算整条曲线）。
+		 */
+		inline const std::size_t kDerivedCurveGuardMax = 65536;
+		/** 派生曲线缓存条目上限（超出时按「最旧优先」淘汰；它只是加速与内存控制手段）。 */
+		inline const std::size_t kCurveSpanCacheLimit = 32;
+		/** 派生曲线缓存允许占用的总字节数（约 768MB）：超出时按「最旧优先」淘汰。
+		 *  取足够大是为了让「完全放大时 5 个网格各缓存一条整段曲线」可以同时驻留。 */
+		inline const std::size_t kCurveSpanCacheMaxBytes = 768ull * 1024ull * 1024ull;
+		/**
+		 * @brief 派生（预览）曲线走「后台异步计算」的窗口采样数门槛。
+		 *
+		 * 拖动滑块 / 移动视界 / 缩放每帧都会请求预览曲线。窗口不超过本门槛时同步重算足够快
+		 * （弱峰调整 ≈0.9ms/6.5 万采样），预览曲线能**实时跟随控件**；一旦窗口超过门槛
+		 * （大时间跨度、整条信号），同步重算会阻塞交互（弱峰调整整条信号单条 ≈368ms），
+		 * 此时改为交后台线程计算、本帧先用旧曲线顶替（双缓冲），保证控件反馈始终跟手。
+		 */
+		inline const std::size_t kDerivedAsyncWindowThreshold = 65536;
+		/**
+		 * @brief 「超大信号」门槛：信号采样数超过它时，**拖拽参数期间不再反复排队**"整条信号"的
+		 *        预览曲线重算（见 `CurveSpanFor`）。
+		 *
+		 * 预览曲线按整条信号计算（`[0, count]`，与「构建为新信号」逐位一致）。信号极大时每条
+		 * 曲线要扫描上亿个采样，后台线程被持续占满会**反过来拖慢前台绘制**（实测前台 14ms/帧，
+		 * 而绘制本身仅 0.4ms）。此时拖动期间沿用旧曲线、松手后再算一次最新的即可 ——
+		 * 整条信号的重算本来就追不上滑块速度，"冻结"与"每帧重排"观感相同，但后者拖慢前台。
+		 */
+		inline const std::size_t kHugeSignalPreviewSamples = 4000000ull;
+		inline const wchar_t* const kWeakPeakLevelLabel = L"调整幅度";	/**< 逐条目面板里「幅度」滑块行的标签（用户要求：滑动条前不再单独显示 `%`）。 */
+		inline const wchar_t* const kWeakPeakIterationsLabel = L"迭代次数 N";		/**< MEAN / CENTER 面板里「迭代次数」输入框的标签。 */
+		/** 「弱峰调整」迭代次数滑块行的标签（用户要求：滑动条前不再单独显示 `N`）。 */
+		inline const wchar_t* const kWeakPeakIterationsSliderLabel = L"迭代次数";
+		inline const wchar_t* const kWeakPeakTitle = L"弱峰调整";			/**< 弱峰调整面板标题。 */
+		inline const wchar_t* const kBuildSignalLabel = L"构建为新信号";	/**< 逐条目面板底部按钮文案（均值滤波 / 弱峰调整共用）。 */
+		/**
+		 * @brief 边沿统计累积状态上限。
+		 *
+		 * ⚠️ 必须足够大：`普通 + 中心轴` × 一个网格里的信号数（都勾选时）会被全部使用。
+		 * 上限太小会**淘汰其它信号的已扫完状态** → 它们从头重扫（表现为“改一个参数、
+		 * 其它几个信号也重新统计”）。一个状态仅占「块数组 ≈ (采样数/8192)×16B」+ 几十 KB
+		 * 本地曲线，64 个状态对内存无压力。
+		 * 真的超限时**优先淘汰「已扫完」的最旧状态**（它重新扫完很快），绝不淘汰正在推进的。
+		 */
+		inline const std::size_t kEdgeScanStateLimit = 64;
+		/**
+		 * @brief 「边沿计数」累积统计的分块大小（采样点数）。
+		 *
+		 * 每块各存上升/下降沿数：查询某个时间区间时，内部整块用存储值相加、只有两端边界块
+		 * 需要就地精确扫描（≤ 2 块），因此拖动时间光标的单帧代价与区间长度无关。
+		 * 取小一点 ⇒ 边界块扫描更便宜；取大一点 ⇒ 块数组更省内存。
+		 */
+		inline const std::size_t kEdgeBlockSamples = 8192;
+		/**
+		 * @brief 每一帧允许「边沿计数」扫描的采样对总数（跨全部累积状态共享）。
+		 *
+		 * 千万级信号整段扫描一次 ≈115ms（用户报告：5 条信号同一网格时单帧 ≈575ms，
+		 * 界面完全失去响应）。改成预算推进后，单帧最多只花 ≈5ms 在统计上，
+		 * 剩下的部分在后续帧里接着扫（未扫完时界面显示上一个完整结果 + “…”）。
+		 *
+		 * ⚠️ **必须按帧重置**（在 `Paint` 开头）：旧实现按 `GetTickCount64()` 分桶，
+		 * 而系统时钟粒度约 15.6ms —— 当帧率高于它时（`PostMessage` 自持重绘会把帧率拉高），
+		 * 同一 tick 内的多帧**完全不推进**（用户报告：“按住横向光标不动时统计卡在统计中”，
+		 * “回车确认参数后不移动鼠标就一直停在部分值”）。
+		 */
+		inline const std::size_t kEdgeScanPairsPerFrame = 1200000;
+		/**
+		 * @brief 每个累积状态每帧的扫描配额下限（防止多个状态时前面的把预算吃光）。
+		 *
+		 * 过去所有状态共享一个“本 tick 总预算”，而推进总是从列表中的第一个状态开始
+		 * —— 5 条信号时只有第一条有进展，其余 4 条长期显示“统计中…”（用户报告
+		 * “很多项都停在了统计中不更新”）。现在每个状态各自持有每帧配额，互不饿死。
+		 */
+		inline const std::size_t kEdgeScanPairsPerStateMin = 60000;
+		/**
+		 * @brief 计算每状态配额时假定的“最小并发状态数”。
+		 *
+		 * ⚠️ 不能直接用 `m_edgeScans.size()`：状态是在**同一帧内逐个创建**的，第一个状态的
+		 * 那一刻 `size() == 1`，会拿走整额预算 → 同帧后面新建的状态全部被截断为 0 配额
+		 *（首帧只有第一条信号推进）。按一个典型并发量（普通 + 中心轴 × 网格内信号数）
+		 * 下限分摊，可保证同一帧里所有状态都得到推进。
+		 */
+		inline const std::size_t kEdgeScanFairShare = 6;
+		/**
+		 * @brief 「边沿计数」结果里的**上升沿**部分文本。
+		 * @param [IN] rising 上升沿数量。 @param [IN] complete 是否为完整精确值。
+		 * @return 形如 "上升沿 123"（未算完时追加 " …"）的文本。
+		 */
+		inline std::wstring EdgeRisingText(std::size_t rising, bool complete)
+		{
+			std::wstring text = L"上升沿 " + std::to_wstring(rising);
+			if (!complete)
+			{
+				text += L" …";
+			}
+			return text;
+		}
+
+		/**
+		 * @brief 「边沿计数」结果里的**下降沿**部分文本。
+		 * @param [IN] falling 下降沿数量。 @param [IN] complete 是否为完整精确值。
+		 * @return 形如 "下降沿 456"（未算完时追加 " …"）的文本。
+		 */
+		inline std::wstring EdgeFallingText(std::size_t falling, bool complete)
+		{
+			std::wstring text = L"下降沿 " + std::to_wstring(falling);
+			if (!complete)
+			{
+				text += L" …";
+			}
+			return text;
+		}
+
+		/**
+		 * @brief 「边沿计数」是否处于“完全未算出”状态（用于显示“统计中…”）。
+		 */
+		inline bool EdgeCountsPending(std::size_t rising, std::size_t falling, bool complete)
+		{
+			return (!complete && rising == 0 && falling == 0);
+		}
+
+		/**
+		 * @brief 「边沿计数」结果的显示文本（合并成一行，用于宽度测量与兼容旧调用）。
+		 *
+		 * ⚠️ 未完成时**两个数字后面都要带 `…`**（旧实现只在整行末尾追加一个 `…`，
+		 * 视觉上只跟在“下降沿”的数字后面，用户明确要求“为上升沿也加上这个尾缀”）。
+		 * @param [IN] rising 上升沿数量。 @param [IN] falling 下降沿数量。
+		 * @param [IN] complete 是否为该阈值的完整精确值。
+		 * @return 面板/宽度测量共用的文本。
+		 */
+		[[maybe_unused]] inline std::wstring EdgeCountsText(std::size_t rising, std::size_t falling,
+		                                            bool complete)
+		{
+			if (EdgeCountsPending(rising, falling, complete))
+			{
+				return L"统计中…";
+			}
+			return EdgeRisingText(rising, complete) + L"    " + EdgeFallingText(falling, complete);
+		}
+
+		/**
+		 * @brief 判断坐标是否命中「弱峰调整」的某条滑块轨道。
+		 *
+		 * 轨道本身只有几个像素高，直接按轨道矩形命中很难抓住，因此把命中区在纵向上下各放宽
+		 * （至少一个轨道高度），与样式区滑块的交互一致。
+		 *
+		 * @param [IN] track 滑块轨道矩形（宽度为 0 表示当前没有滑块）。
+		 * @param [IN] scale DPI 缩放比例。
+		 * @param [IN] x 客户区横坐标。
+		 * @param [IN] y 客户区纵坐标。
+		 * @return 命中返回 true。
+		 */
+		inline bool WeakPeakSliderHit(const gd::RectF& track, float scale, float x, float y)
+		{
+			if (track.Width <= 0.0f)
+			{
+				return false;
+			}
+			gd::RectF hit = track;
+			const float pad = std::max(8.0f * scale, track.Height);
+			hit.Y -= pad;
+			hit.Height += pad * 2.0f;
+			return UiPointInRect(hit, x, y);
+		}
+
+		/**
+		 * @brief 「弱峰调整」滑块行右侧**数值列**的宽度（布局与面板宽度共用同一算式）。
+		 *
+		 * 取「+400%」与「10000」两者较宽者：前者是幅度滑块的最大显示文本
+		 *（**正负号始终显示**，且量程已扩到 ±400%），
+		 * 后者为迭代次数上限留出足够位宽（上限可被用户改大）。
+		 */
+		inline float WeakPeakValueColumnWidth(HFONT monoSmall)
+		{
+			return std::max(UiMeasureTextWidth(monoSmall, L"+400%"),
+			                UiMeasureTextWidth(monoSmall, L"10000"));
+		}
+
+		/** @brief 「弱峰调整」滑块行左侧**标签列**的宽度（两条标签取较宽者，保证轨道左对齐）。 */
+		inline float WeakPeakLabelColumnWidth(HFONT uiSmall)
+		{
+			return std::max(UiMeasureTextWidth(uiSmall, kWeakPeakLevelLabel),
+			                UiMeasureTextWidth(uiSmall, kWeakPeakIterationsSliderLabel));
+		}
+
+		/**
+		 * @brief 取折线（相邻采样点之间线性连接）在给定时刻的取值。
+		 *
+		 * 包络是按像素列聚合的，因此某一段折线可能**跨越列边界**：跨越边界的那一小段
+		 * 在两个列里都不属于"落在本列内的采样点"，只看列内采样点就会把它整段丢掉。
+		 * 该函数用于在列边界处取回这段折线的取值，使相邻两列的包络严丝合缝。
+		 *
+		 * @param [IN] time 时间轴。
+		 * @param [IN] values 采样值。
+		 * @param [IN] count 可用采样点数量。
+		 * @param [IN] style 显示外观（水平镜像时按**源下标反序**取值）。
+		 * @param [IN] firstIndex 第一个时间不小于查询时刻的采样下标（相交线段为 firstIndex-1 → firstIndex）。
+		 * @param [IN] t 查询时刻。
+		 * @param [OUT] out 输出取值。
+		 * @return 折线覆盖该时刻且取到有效值返回 true。
+		 */
+		inline bool PolylineValueAt(const std::vector<double>& time, const std::vector<double>& values,
+		                     std::size_t count, const SignalStyle& style, std::size_t firstIndex,
+		                     double t, double& out)
+		{
+			if (firstIndex == 0 || firstIndex >= count)
+			{
+				// 该时刻之前（或之后）没有采样点，折线并未延伸到这里。
+				return false;
+			}
+			const double t0 = time[firstIndex - 1];
+			const double t1 = time[firstIndex];
+			// 水平镜像时画面上的相邻两点取源数组中头尾对调后的两个采样。
+			const double v0 = values[SourceIndexFor(style, count, firstIndex - 1)];
+			const double v1 = values[SourceIndexFor(style, count, firstIndex)];
+			if (!std::isfinite(t0) || !std::isfinite(t1) || !std::isfinite(v0) || !std::isfinite(v1) ||
+			    !(t1 > t0))
+			{
+				return false;
+			}
+			double ratio = (t - t0) / (t1 - t0);
+			if (ratio < 0.0)
+			{
+				ratio = 0.0;
+			}
+			else if (ratio > 1.0)
+			{
+				ratio = 1.0;
+			}
+			out = v0 + (v1 - v0) * ratio;
+			return true;
+		}
+
+		/**
+		 * @brief 统计相邻采样对 (k-1, k) 中穿越判定基准的边沿数量。
+		 *
+		 * `deltaAt(k)` 返回第 k 个采样相对判定基准的偏差；返回非有限值（NaN）表示该采样
+		 * 不参与判定，并**打断连续性**（与前一点之间不计边沿）——这正好覆盖
+		 * 「采样缺失」与「采样落在统计时间区间之外」两种情况。
+		 *
+		 * 统计的是采样对 `k ∈ [pairFirst, pairLast]`（闭区间），每对的「前一点」为 `k-1`，
+		 * 因此起点对的连续性由 `deltaAt(pairFirst - 1)` 决定（它无效时从下一个有效点重新起算）。
+		 *
+		 * 该函数是增量统计的基本单位：只要把区间切成互不相交的若干段分别累加（或从总量中减去），
+		 * 结果与一次性扫描整段完全一致，因此拖动光标时可以只扫描两端差集。
+		 *
+		 * @param [IN] pairFirst 起始采样对的下标 k（含），必须 ≥ 1。
+		 * @param [IN] pairLast 结束采样对的下标 k（含）；小于起点时不做任何事。
+		 * @param [IN] deltaAt 偏差取值仿函数。
+		 * @param [IN,OUT] rising 累加的上升沿数量。
+		 * @param [IN,OUT] falling 累加的下降沿数量。
+		 */
+		template <typename DeltaAt>
+		inline void AccumulateEdgeCrossings(std::size_t pairFirst, std::size_t pairLast, DeltaAt deltaAt,
+		                             std::size_t& rising, std::size_t& falling)
+		{
+			if (pairFirst == 0 || pairFirst > pairLast)
+			{
+				return;
+			}
+			double previousDelta = deltaAt(pairFirst - 1);
+			bool hasPrevious = std::isfinite(previousDelta);
+			for (std::size_t index = pairFirst; index <= pairLast; ++index)
+			{
+				const double current = deltaAt(index);
+				if (!std::isfinite(current))
+				{
+					hasPrevious = false;
+					continue;
+				}
+				if (hasPrevious)
+				{
+					if (previousDelta < 0.0 && current >= 0.0)
+					{
+						++rising;
+					}
+					else if (previousDelta > 0.0 && current <= 0.0)
+					{
+						++falling;
+					}
+				}
+				previousDelta = current;
+				hasPrevious = true;
+			}
+		}
+
+		/**
+		 * @brief 「调整」变换 + 水平镜像的指纹（用于边沿统计缓存键）。
+		 *
+		 * 边沿判定基于**画出来的曲线**，因此任何一个变换项改变都可能改变计数结果；
+		 * 把这些项折叠成一个指纹后，样式一变就能立刻失效缓存项（否则会沿用变换前的旧计数）。
+		 *
+		 * @param [IN] style 信号外观。
+		 * @return 指纹值。
+		 */
+		inline std::uint64_t EdgeStyleKey(const SignalStyle& style)
+		{
+			std::uint64_t key = 1469598103934665603ull;
+			const auto mix = [&key](std::uint64_t value)
+			{
+				key ^= value;
+				key *= 1099511628211ull;
+			};
+			mix(static_cast<std::uint64_t>(
+			    std::llround(static_cast<double>(style.gain) * 1.0e6)));
+			mix(static_cast<std::uint64_t>(
+			    std::llround(static_cast<double>(style.offsetY) * 1.0e6)));
+			mix(style.absolute ? 1u : 0u);
+			mix(style.mirrorVertical ? 2u : 0u);
+			mix(style.mirrorHorizontal ? 4u : 0u);
+			return key;
+		}
+
+		/**
+		 * @brief 计算统计区间对应的采样下标区间 [begin, end)。
+		 *
+		 * 时间轴单调时用二分定位。⚠️ 区间**之外**的采样一律不参与计数，
+		 * 因此这里**不做任何外扩**：只有两端都落在 `[begin, end)` 内的采样对才会被累计
+		 *（调用方从 `begin + 1` 开始枚举采样对）。
+		 *
+		 * @param [IN] group 所属数据分组。
+		 * @param [IN] count 采样点数量。
+		 * @param [IN] hasRange 是否限定时间区间。
+		 * @param [IN] rangeMin 区间左端点时间。
+		 * @param [IN] rangeMax 区间右端点时间。
+		 * @param [OUT] begin 输出区间起点（含）。
+		 * @param [OUT] end 输出区间终点（不含）。
+		 * @return 计数是否完全由该下标区间决定（时间轴单调时为真）。
+		 */
+		inline bool EdgeIndexRange(const TimeAxis& axis, std::size_t count, bool hasRange, double rangeMin,
+		                    double rangeMax, std::size_t& begin, std::size_t& end)
+		{
+			begin = 0;
+			end = count;
+			if (!hasRange)
+			{
+				return true;
+			}
+			if (!axis.monotonic)
+			{
+				// 时间轴非单调时无法用下标区间表达统计范围（需逐点按时间过滤）。
+				return false;
+			}
+
+			const std::vector<double>& times = axis.time;
+			const std::size_t timeCount = std::min(times.size(), count);
+			begin = static_cast<std::size_t>(
+			    std::lower_bound(times.begin(), times.begin() + static_cast<std::ptrdiff_t>(timeCount),
+			                     rangeMin) -
+			    times.begin());
+			// ⚠️ **不要**在左端多取一个采样点：那会让“跨越区间边界的边沿”也算进来，
+			//    而用户明确要求“在光标选区外的点不要算入计数规则”。
+			//    （例：光标恰好落在越过阈值的第一个采样点 B 上时，A→B 这一段处于选区之外，
+			//      不计入；旧实现在左端多取一个点，于是 B 被错认成上升沿。）
+			end = static_cast<std::size_t>(
+			    std::upper_bound(times.begin(), times.begin() + static_cast<std::ptrdiff_t>(timeCount),
+			                     rangeMax) -
+			    times.begin());
+			end = std::min(end, timeCount);
+			begin = std::min(begin, end);
+			return true;
+		}
+
+		inline const std::uint64_t kHintHoldMs = 1300;	/**< 提示浮层完全显示的停留时长（毫秒）。 */
+		inline const std::uint64_t kHintFadeMs = 500;	/**< 提示浮层的淡出时长（毫秒）。 */
+
+		/**
+		 * @brief 实验性功能浮动面板的遍历顺序（命中测试与绘制共用，保证层序一致）。
+		 *
+		 * 顺序即绘制层序：先绘制的在下方，最后绘制的在最上方。
+		 */
+		inline const EdgePanelKind kEdgePanelKinds[] = {EdgePanelKind::COUNT, EdgePanelKind::CENTER,
+		                                        EdgePanelKind::MEAN, EdgePanelKind::PEAK};
+
+		/** 实验性功能浮动面板的种类数（遍历与命中测试统一用它，避免新增功能时漏改）。 */
+		inline const int kEdgePanelKindCount = static_cast<int>(sizeof(kEdgePanelKinds) / sizeof(kEdgePanelKinds[0]));
+
+		/**
+		 * @brief 计算一条派生曲线在给定采样窗口内的取值（同步路径与后台线程共用）。
+		 *
+		 * 只拷贝所需的窗口，再调用与「构建为新信号」完全相同的自由函数，因此
+		 * 预览曲线与构建出的采样值逐位一致。本函数**只读**入参、不接触任何成员状态，
+		 * 因此可以安全地在后台线程调用。
+		 *
+		 * @param [IN] signal 目标信号（数据只读）。
+		 * @param [IN] windowBegin 窗口起点（采样下标）。
+		 * @param [IN] windowEnd 窗口终点（不含）。
+		 * @param [IN] kind `DerivedCurveKind` 的整型值。
+		 * @param [IN] points 均值点数 X。
+		 * @param [IN] iterations 迭代次数 N。
+		 * @param [IN] amountPercent 弱峰调整幅度（-400–400）。
+		 * @param [IN] cancel 可选的取消标志（透传给算法，使过时任务尽快退出）。
+		 * @param [IN] throttle 是否在阶与阶之间让出 CPU（低内存设备的“少量多次”模式）。
+		 * @return 曲线数值（长度 = 有效窗口长度）。
+		 */
+		inline std::vector<float> ComputeDerivedWindow(const SignalData& signal, std::size_t windowBegin,
+		                                        std::size_t windowEnd, int kind, int points,
+		                                        int iterations, int amountPercent,
+		                                        const std::atomic<bool>* cancel, bool throttle)
+		{
+			std::vector<float> out;
+			const std::vector<double>& values = signal.values;
+			const std::size_t hi = std::min(windowEnd, values.size());
+			const std::size_t lo = std::min(windowBegin, hi);
+			if (hi <= lo)
+			{
+				return out;
+			}
+			// ⚠️ **整段窗口不要复制**：`VERY_BIG_DATA` 一条曲线要 8 B/采样 × 2580 万 ≈ 206 MB，
+			//    而“预览曲线一律按整条信号计算”正是最常见的情形。
+			//    采样在本函数执行期间不会被修改（结构变化前宿主会先 `PauseDerivedAsync`），
+			//    因此整段时直接引用原向量；只有子窗口才切片复制。
+			const bool wholeSignal = (lo == 0) && (hi == values.size());
+			const std::vector<double> window = wholeSignal
+			                                      ? std::vector<double>()
+			                                      : std::vector<double>(
+			                                            values.begin() + static_cast<std::ptrdiff_t>(lo),
+			                                            values.begin() + static_cast<std::ptrdiff_t>(hi));
+			const std::vector<double>& input = wholeSignal ? values : window;
+			if (kind == static_cast<int>(DerivedCurveKind::WEAK_PEAK))
+			{
+				ComputeWeakPeakAdjust(input, static_cast<double>(amountPercent) / 100.0, iterations, out,
+				                      cancel, throttle);
+			}
+			else
+			{
+				ComputeMovingAverageIterated(input, points, iterations, out, cancel, throttle);
+			}
+			return out;
+		}
+
+		/**
+		 * @brief 包络带的单个像素列（已映射到屏幕坐标）。
+		 */
+		struct BandColumn
+		{
+			float x = 0.0f;			/**< 列中心横坐标。 */
+			float top = 0.0f;		/**< 本列的**上**包络（较小的纵坐标）。 */
+			float bottom = 0.0f;	/**< 本列的**下**包络（较大的纵坐标）。 */
+		};
+
+		/**
+		 * @brief 把逐列极值拼成闭合的包络带多边形。
+		 *
+		 * 输出格式为「上包络正向 + 下包络反向」，调用方（`PaintLane`）依赖这个顺序把
+		 * 它拆成上下两条折线画成一个闭合环。
+		 *
+		 * ⚠️ **几何必须是精确的**：这里**不做任何**列窗口加宽。曾经为了让填充更快而做过
+		 * ±1 列的极值扩展，结果把"梳状"振荡糊成了实心块，波形细节整体丢失
+		 * （用户反馈"显示效果没有之前好了"）。性能问题改由**绘制侧**解决：把梳状带
+		 * 交给无抗锯齿填充（见 `spiky` 输出与 `PlotView::m_fastFrame`）。
+		 *
+		 * @param [IN] columns 逐列极值（同一段内按列顺序排列）。
+		 * @param [OUT] band 追加写入的包络顶点（上包络正向 + 下包络反向）。
+		 * @param [OUT] bandBreaks 追加写入的各段起点（相对 band 的下标）。
+		 * @param [OUT] spiky 该段是否为「梳状 / 密集满幅」（建议关闭抗锯齿）。
+		 * @param [IN] laneHeight 网格的可见像素高度（用于「覆盖率」判据；≤0 时跳过）。
+		 */
+		inline void EmitEnvelopeBand(const std::vector<BandColumn>& columns, std::vector<gd::PointF>& band,
+		                      std::vector<std::size_t>& bandBreaks, bool& spiky, float laneHeight)
+		{
+			if (columns.size() < 2)
+			{
+				return;
+			}
+			const std::size_t count = columns.size();
+			bandBreaks.push_back(band.size());
+
+			// 「梳状」判定：相邻列的上下包络几乎不相交（振荡周期与像素列宽相当时出现）。
+			// 这种形状下抗锯齿填充的扫描线代价暴涨，而抗锯齿对它的平滑作用几乎看不出来。
+			std::size_t inverted = 0;
+			const float slack = kEnvelopeMinPixelSpan;
+			for (std::size_t index = 1; index < count; ++index)
+			{
+				if (columns[index].top > columns[index - 1].bottom + slack ||
+				    columns[index].bottom < columns[index - 1].top - slack)
+				{
+					++inverted;
+				}
+			}
+			if (inverted * 8 > count)
+			{
+				spiky = true;
+			}
+
+			// 「密集满幅」判定：包络带在**每一列内部**都横跨了网格的大部分高度
+			//（编码器方波在 1~2 采样/像素时，多数像素列里都含一次整幅跳变）。
+			// GDI+ **抗锯齿**的代价与这些近竖直、满幅的边成正比：实测同一 4832 顶点的几何
+			// **抗锯齿 694ms、关抗锯齿 29ms（23 倍）**，而这么密的色块上抗锯齿的平滑作用肉眼不可辨。
+			// ⚠️ 只影响「本段是否关抗锯齿」，几何（逐列 min/max）完全不变。
+			if (laneHeight > 0.0f)
+			{
+				std::size_t tallColumns = 0;
+				double covered = 0.0;
+				for (const BandColumn& column : columns)
+				{
+					const float span = column.bottom - column.top;
+					covered += static_cast<double>(span);
+					if (span > 0.5f * laneHeight)
+					{
+						++tallColumns;
+					}
+				}
+				// 「锯齿」判定（最能代表 GDI+ 抗锯齿代价）：相邻列的上下包络**整幅跳变**。
+				std::size_t jumps = 0;
+				const float jumpThreshold = 0.25f * laneHeight;
+				for (std::size_t index = 1; index < count; ++index)
+				{
+					const float dTop = std::fabs(columns[index].top - columns[index - 1].top);
+					const float dBottom = std::fabs(columns[index].bottom - columns[index - 1].bottom);
+					if (dTop > jumpThreshold || dBottom > jumpThreshold)
+					{
+						++jumps;
+					}
+				}
+				if (tallColumns * 4 > count || jumps * 4 > count ||
+				    covered > 0.45 * static_cast<double>(count) * static_cast<double>(laneHeight))
+				{
+					spiky = true;
+				}
+			}
+
+			for (std::size_t index = 0; index < count; ++index)
+			{
+				band.push_back(gd::PointF(columns[index].x, columns[index].top));
+			}
+			for (std::size_t index = count; index-- > 0;)
+			{
+				band.push_back(gd::PointF(columns[index].x, columns[index].bottom));
+			}
+		}
+
+		/**
+		 * @brief 双光标差值的完整显示文本（"Δt：" + 复合单位间隔）。
+		 * @param [IN] seconds 时间间隔（秒）。
+		 * @return 形如 "Δt：1h 1min 2s" 的文本。
+		 */
+		inline std::wstring FormatSpanText(double seconds)
+		{
+			return L"Δt：" + FormatDurationCompound(seconds);
+		}
+
+		/**
+		 * @brief 时间光标的读数文本（"数值 + s 后缀"）。
+		 *
+		 * 时间轴本身就是秒，但与幅值读数放在一起时没有单位容易误读，
+		 * 因此读数恒带 "s" 后缀；内联编辑仍使用不带单位的纯数值（见 BeginEdit 调用处）。
+		 *
+		 * @param [IN] seconds 光标所在时刻（秒）。
+		 * @return 形如 "1.25s" 的文本。
+		 */
+		inline std::wstring FormatCursorTime(double seconds)
+		{
+			return FormatValue(seconds) + L"s";
+		}
+
+		/**
+		 * @brief 按比例缩放颜色的 alpha 通道（用于提示浮层淡出）。
+		 * @param [IN] argb 原始 0xAARRGGBB 颜色。
+		 * @param [IN] alpha 新的 alpha（0-255）。
+		 * @return 缩放后的颜色。
+		 */
+		inline std::uint32_t ScaleAlpha(std::uint32_t argb, unsigned int alpha)
+		{
+			const unsigned int a = std::min(255u, alpha);
+			return (argb & 0x00FFFFFFu) | (a << 24);
+		}
+
+		/**
+		 * @brief 将数值限制到合法区间。
+		 * @param [IN] value 输入值。
+		 * @param [IN] low 下限。
+		 * @param [IN] high 上限。
+		 * @return 限制后的数值。
+		 */
+		inline double ClampDouble(double value, double low, double high)
+		{
+			if (value < low)
+			{
+				return low;
+			}
+			if (value > high)
+			{
+				return high;
+			}
+			return value;
+		}
+
+		/**
+		 * @brief 组装图例文本：使用信号当前显示名（用户重命名后立即生效）。
+		 * @param [IN] data 信号数据。
+		 * @return 图例文本。
+		 */
+		inline std::wstring BuildLegendText(const SignalData& data)
+		{
+			return data.name;
+		}
+
+		/**
+		 * @brief 将信号样式颜色按不透明度换算为实际绘制颜色。
+		 * @param [IN] style 信号样式。
+		 * @return 叠加不透明度后的 0xAARRGGBB 颜色值。
+		 */
+		inline std::uint32_t StyleColor(const SignalStyle& style)
+		{
+			double opacity = static_cast<double>(style.opacity);
+			if (opacity < 0.0)
+			{
+				opacity = 0.0;
+			}
+			if (opacity > 1.0)
+			{
+				opacity = 1.0;
+			}
+			return WithAlpha(style.color, static_cast<unsigned int>(opacity * 255.0 + 0.5));
+		}
+
+		/**
+		 * @brief 由信号色派生一个「高对比度」颜色：保持色相、大幅拉开明度。
+		 *
+		 * 用途：「边沿计数（中心轴）」的平均值曲线叠加在原始波形之上，
+		 * 若直接用信号色会被波形淹没。这里把信号色向黑或白方向大幅偏移，
+		 * 并**同时考虑与原始波形色以及与绘图区底色的距离**，取对比更强的一侧，
+		 * 保证曲线既能与波形区分、又能压在底图上看得清。
+		 *
+		 * 结果是从信号色派生的，因此原信号改颜色时曲线颜色会自动跟着变。
+		 *
+		 * @param [IN] color 原始信号色（0xAARRGGBB）。
+		 * @param [IN] background 绘图区底色，用于评估可见度。
+		 * @return 派生出的高对比度颜色（alpha 与输入一致，由调用方再覆盖）。
+		 */
+		inline std::uint32_t HighContrastDerived(std::uint32_t color, std::uint32_t background = 0xFFFDF6E3u)
+		{
+			const auto squaredDistance = [](std::uint32_t a, std::uint32_t b)
+			{
+				const double dr =
+				    static_cast<double>((a >> 16) & 0xFFu) - static_cast<double>((b >> 16) & 0xFFu);
+				const double dg =
+				    static_cast<double>((a >> 8) & 0xFFu) - static_cast<double>((b >> 8) & 0xFFu);
+				const double db = static_cast<double>(a & 0xFFu) - static_cast<double>(b & 0xFFu);
+				return dr * dr + dg * dg + db * db;
+			};
+
+			const std::uint32_t darker = MixColor(color, 0xFF000000u, 0.72);
+			const std::uint32_t lighter = MixColor(color, 0xFFFFFFFFu, 0.72);
+			// 评分：与原始波形色的区分度为主（权重 1.0），与底色的可见度为辅（权重 0.6）。
+			const double scoreDarker =
+			    squaredDistance(darker, color) + 0.6 * squaredDistance(darker, background);
+			const double scoreLighter =
+			    squaredDistance(lighter, color) + 0.6 * squaredDistance(lighter, background);
+			return (scoreDarker >= scoreLighter) ? darker : lighter;
+		}
+		/** @brief FNV-1a 混合（面板像素缓存键共用）。 */
+		inline void MixPanelKey(std::uint64_t& hash, std::uint64_t value)
+		{
+			hash ^= value;
+			hash *= 1099511628211ull;
+		}
+	} // namespace pvdetail
+
+	using namespace pvdetail;
+
+} // namespace jdi
+
+#endif // __PLOT_VIEW_INTERNAL_HPP__
+
diff --git a/Components/PlotView/Src/PlotViewPaint.cpp b/Components/PlotView/Src/PlotViewPaint.cpp
new file mode 100644
index 0000000..23433a0
--- /dev/null
+++ b/Components/PlotView/Src/PlotViewPaint.cpp
@@ -0,0 +1,6365 @@
+// PlotView 实现分片 —— 本文件只包含 PlotView 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与工具函数在 PlotViewInternal.hpp（命名空间 `pvdetail`，全部 inline）。
+// 四个分片的职责划分（按功能）：
+//   core        视图核心：构造/析构、上下文绑定、布局、坐标映射、视界与平移、网格结构与归属、
+//               选区/网格划分、拖动取消
+//   paint       渲染与像素缓存：全部绘制（Paint*/Render*）、场景缓存、装饰缓存、每网格图层、
+//               宽基底与滚动补条、并行图层重建
+//   interaction 交互与编辑：命中测试、鼠标与键盘处理、光标形状、内联输入框、浮动面板层序与命中
+//   features    视图特性与派生数据：光标状态与读数、提示浮层、缩放模式、自适应、光标吸附、
+//               单点信号、派生曲线线程池、边沿统计、实验性功能（均值滤波 / 弱峰调整）参数
+#include "PlotViewInternal.hpp"
+
+namespace jdi
+{
+
+	float PlotView::EdgePanelWidth(int laneIndex, EdgePanelKind kind) const
+	{
+		if (m_tab == nullptr || m_fonts == nullptr || laneIndex < 0 ||
+		    laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return kEdgePanelWidth * m_scale;
+		}
+		const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		const bool centerAxis = (kind == EdgePanelKind::CENTER);
+		const bool meanFilter = (kind == EdgePanelKind::MEAN);
+		const bool weakPeak = (kind == EdgePanelKind::PEAK);
+		// 「均值滤波」「中心轴边沿计数」「弱峰调整」都是逐条目面板（名称 + 复选框）。
+		const bool itemized = (centerAxis || meanFilter || weakPeak);
+
+		// 标题行 = “GX” 徽标 + 标题（“边沿计数” / “中心轴边沿计数” / “均值滤波” / “弱峰调整”
+		// + 光标区间尾缀）。
+		const std::wstring title =
+		    meanFilter ? std::wstring(L"均值滤波")
+		               : (weakPeak ? std::wstring(kWeakPeakTitle)
+		                            : ((centerAxis ? L"中心轴边沿计数" : L"边沿计数") + EdgeRangeSuffix()));
+		float width = kEdgePanelPad * 2.0f * m_scale + kLaneBadgeWidth * m_scale +
+		              8.0f * m_scale + UiMeasureTextWidth(m_fonts->uiSmall, title) +
+		              kEdgePanelTitleHeight * m_scale;
+
+		// 数据行 = 名称与“上升沿 N / 下降沿 M”两行，取较宽者。
+		// ⚠️ 名称宽度有上限（`kEdgePanelNameMaxWidth`）：超长信号名不再把面板顶得很长，
+		//    绘制时超出部分用省略号（用户明确要求“超过某个长度就省略名称显示”）。
+		// ⚠️ 统计信息按「上升沿 / 下降沿」**两列**排版（列起点固定）→ 多条信号时文字垂直对齐。
+		float nameColumnWidth = 0.0f;
+		float statRisingWidth = 0.0f;
+		float statFallingWidth = 0.0f;
+		for (const SignalRef& ref : lane.signals)
+		{
+			const ResolvedSignal resolved = ResolveSignal(ref);
+			if (resolved.data == nullptr || !resolved.visible)
+			{
+				continue;
+			}
+			const float nameWidth =
+			    std::min(UiMeasureTextWidth(m_fonts->uiSmall, resolved.data->name),
+			             kEdgePanelNameMaxWidth * m_scale);
+			nameColumnWidth = std::max(nameColumnWidth, nameWidth);
+			if (itemized)
+			{
+				// 逐条目面板：第一排 = 名称 + 复选框；第三排（中心轴）= 统计结果。
+				width = std::max(width, kEdgePanelPad * 2.0f * m_scale + nameWidth +
+				                              kEdgePanelMeanCheckSize * m_scale + 6.0f * m_scale);
+			}
+			std::size_t rising = 0;
+			std::size_t falling = 0;
+			bool complete = true;
+			if (meanFilter || weakPeak)
+			{
+				continue;
+			}
+			if (centerAxis)
+			{
+				const Lane::EdgeCenterItem* item = lane.FindEdgeCenterItem(ref);
+				if (item == nullptr)
+				{
+					continue;
+				}
+				EdgeCenterCountsFor(*resolved.axis, *resolved.data, *resolved.style, item->points,
+				                    item->iterations, EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(),
+				                    rising, falling, complete);
+			}
+			else
+			{
+				EdgeCountsFor(*resolved.axis, *resolved.data, *resolved.style, lane.edgeValue,
+				              EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(), rising, falling, complete);
+			}
+			// 宽度按实际要显示的文本测量（含未算完时的“…”），否则推进过程中数字变长会被截断。
+			// 完全未算出时整行显示“统计中…”，因此两列都要预留它的宽度。
+			const float pendingWidth = UiMeasureTextWidth(m_fonts->monoSmall, L"统计中…");
+			statRisingWidth = std::max(
+			    statRisingWidth,
+			    std::max(UiMeasureTextWidth(m_fonts->monoSmall, EdgeRisingText(rising, complete)),
+			             pendingWidth));
+			statFallingWidth =
+			    std::max(statFallingWidth,
+			             UiMeasureTextWidth(m_fonts->monoSmall, EdgeFallingText(falling, complete)));
+		}
+		if (statRisingWidth > 0.0f || statFallingWidth > 0.0f)
+		{
+			// 两列**等宽**（取两列最大值中的较大者）→ 绘制时两列起点固定，
+			// 多条信号的“上升沿 / 下降沿”文字严格垂直对齐（用户明确要求）。
+			const float maxColumn = std::max(statRisingWidth, statFallingWidth);
+			const float countsWidth = maxColumn * 2.0f + kEdgePanelStatColumnGap * m_scale;
+			width = std::max(width, kEdgePanelPad * 2.0f * m_scale +
+			                            std::max(nameColumnWidth, countsWidth));
+		}
+
+		if (centerAxis || meanFilter)
+		{
+			// 参数行 = 两个「说明文字 + 数值框」，必须保证文字不被数值框压住。
+			// （MEAN / CENTER：「均值点数 X」+「迭代次数 N」。标签与数值框各占半行。）
+			const float labelXWidth = UiMeasureTextWidth(m_fonts->uiSmall, L"均值点数 X");
+			const float labelN = UiMeasureTextWidth(m_fonts->uiSmall, L"迭代次数 N");
+			const float fieldWidth =
+			    std::max(kEdgePanelEditFieldWidth * m_scale * 0.75f,
+			             UiMeasureTextWidth(m_fonts->monoSmall, L"1000000") + 18.0f * m_scale);
+			const float halfWidth = std::max(labelXWidth, labelN) + 6.0f * m_scale + fieldWidth;
+			const float rowWidth = halfWidth * 2.0f + 8.0f * m_scale;
+			width = std::max(width, kEdgePanelPad * 2.0f * m_scale + rowWidth);
+		}
+
+		if (weakPeak)
+		{
+			// 滑块行 = 「标签列 + 轨道（最小宽度）+ 数值列 + 复位按钮」（等级与迭代次数两行共用同一列宽）。
+			const float rowWidth = WeakPeakLabelColumnWidth(m_fonts->uiSmall) + 6.0f * m_scale +
+			                       kWeakPeakTrackMinWidth * m_scale + 6.0f * m_scale +
+			                       WeakPeakValueColumnWidth(m_fonts->monoSmall) +
+			                       kWeakPeakResetGap * m_scale + kWeakPeakResetButtonSize * m_scale;
+			width = std::max(width, kEdgePanelPad * 2.0f * m_scale + rowWidth);
+		}
+
+		if (meanFilter || weakPeak)
+		{
+			// 底部按钮行 = 「构建为新信号」，按按钮文字实测宽度确定下限。
+			const float buttonWidth =
+			    UiMeasureTextWidth(m_fonts->uiSmall, kBuildSignalLabel) + 28.0f * m_scale;
+			width = std::max(width, kEdgePanelPad * 2.0f * m_scale + buttonWidth);
+		}
+
+		// 夹在绘图区宽度之内（过窄的网格也不至于把面板挤到外面）。
+		return std::min(width, std::max(120.0f * m_scale, m_plotRect.Width - 8.0f * m_scale));
+	}
+
+	const PlotView::PolylineCacheEntry* PlotView::AcquirePolyline(const SignalRef& ref,
+	                                                             const ResolvedSignal& resolved,
+	                                                             const LaneVisual& lane) const
+	{
+		if (resolved.data == nullptr || resolved.group == nullptr)
+		{
+			return nullptr;
+		}
+
+		// ⚠️ **横向补条渲染：不进缓存**。补条只构建"条带区间"的折线顶点，若写进缓存，
+		// 后续整块渲染命中同键时会拿到这段**不完整**的折线（只画了条带那一段）。
+		// 因此补条专用一个独立条目，避免污染按"宽窗口几何"键控的缓存。
+		if (m_stripRenderActive)
+		{
+			BuildPolyline(resolved, lane, m_stripPolylineEntry.points, m_stripPolylineEntry.breaks,
+			              m_stripPolylineEntry.band, m_stripPolylineEntry.bandBreaks,
+			              m_stripPolylineEntry.bandMode, m_stripPolylineEntry.bandSpiky);
+			return &m_stripPolylineEntry;
+		}
+
+		// 键 = 构建折线时实际读取的全部输入：
+		// 信号（引用 + 文件内容 + 采样点数）、时间轴显示范围、绘图区横向几何、网格纵向几何。
+		// 这些值全部相同时，BuildPolyline 的输出必然完全一致，可直接复用。
+		const std::size_t sampleCount = std::min(resolved.axis->time.size(), resolved.data->values.size());
+		const double viewMin = Tab().ViewMin();
+		const double viewMax = Tab().ViewMax();
+		// 绘制前的数值变换（系数/绝对值/镜像/偏移）会改变顶点，必须进缓存键。
+		const float gain = (resolved.style != nullptr) ? resolved.style->gain : 1.0f;
+		const bool absolute = (resolved.style != nullptr) && resolved.style->absolute;
+		const bool mirrorVertical = (resolved.style != nullptr) && resolved.style->mirrorVertical;
+		const bool mirrorHorizontal = (resolved.style != nullptr) && resolved.style->mirrorHorizontal;
+		const float offsetY = (resolved.style != nullptr) ? resolved.style->offsetY : 0.0f;
+		const double offsetTime = (resolved.style != nullptr) ? resolved.style->offsetTime : 0.0;
+
+		for (const PolylineCacheEntry& entry : m_polylineCache)
+		{
+			if (entry.ref == ref && entry.group == resolved.group && entry.sampleCount == sampleCount &&
+			    entry.viewMin == viewMin && entry.viewMax == viewMax && entry.plotX == m_plotRect.X &&
+			    entry.plotWidth == m_plotRect.Width && entry.laneY == lane.rect.Y &&
+			    entry.laneHeight == lane.rect.Height && entry.laneYMin == lane.yMin &&
+			    entry.laneYMax == lane.yMax && entry.gain == gain && entry.absolute == absolute &&
+			    entry.mirrorVertical == mirrorVertical && entry.mirrorHorizontal == mirrorHorizontal &&
+			    entry.offsetY == offsetY && entry.offsetTime == offsetTime)
+			{
+				return &entry;
+			}
+		}
+
+		// 未命中：重建并写入缓存（deque 保证已有元素的引用在追加后依然有效）。
+		// 缓存只用于消除重复计算，容量上限约等于“网格数 × 每网格信号数”的两倍。
+		if (m_polylineCache.size() >= kPolylineCacheLimit)
+		{
+			m_polylineCache.clear();
+		}
+		m_polylineCache.push_back(PolylineCacheEntry());
+		PolylineCacheEntry& entry = m_polylineCache.back();
+		entry.ref = ref;
+		entry.group = resolved.group;
+		entry.sampleCount = sampleCount;
+		entry.viewMin = viewMin;
+		entry.viewMax = viewMax;
+		entry.plotX = m_plotRect.X;
+		entry.plotWidth = m_plotRect.Width;
+		entry.laneY = lane.rect.Y;
+		entry.laneHeight = lane.rect.Height;
+		entry.laneYMin = lane.yMin;
+		entry.laneYMax = lane.yMax;
+		entry.gain = gain;
+		entry.absolute = absolute;
+		entry.mirrorVertical = mirrorVertical;
+		entry.mirrorHorizontal = mirrorHorizontal;
+		entry.offsetY = offsetY;
+		entry.offsetTime = offsetTime;
+
+		BuildPolyline(resolved, lane, entry.points, entry.breaks, entry.band, entry.bandBreaks,
+		              entry.bandMode, entry.bandSpiky);
+		// BuildPolyline 通过引用填充，push_back 过程中不会再次进入本函数，引用安全。
+		return &m_polylineCache.back();
+	}
+
+	void PlotView::BuildPolyline(const ResolvedSignal& resolved, const LaneVisual& lane,
+	                             std::vector<gd::PointF>& points, std::vector<std::size_t>& breaks,
+	                             std::vector<gd::PointF>& band, std::vector<std::size_t>& bandBreaks,
+	                             bool& bandMode, bool& bandSpiky) const
+	{
+		points.clear();
+		breaks.clear();
+		band.clear();
+		bandBreaks.clear();
+		bandMode = false;
+		bandSpiky = false;
+
+		if (resolved.data == nullptr || resolved.group == nullptr)
+		{
+			return;
+		}
+
+		const std::vector<double>& time = resolved.axis->time;
+		const std::vector<double>& values = resolved.data->values;
+		const std::size_t count = std::min(time.size(), values.size());
+		if (count == 0 || m_plotRect.Width <= 1.0f)
+		{
+			return;
+		}
+
+		const double viewMin = Tab().ViewMin();
+		const double viewMax = Tab().ViewMax();
+
+		// 时间偏移：采样画在 `t + offsetTime` 处，因此“落在当前视界内的采样”
+		// 其源时刻位于 `[viewMin - offsetTime, viewMax - offsetTime]`。
+		const double timeShift = resolved.style->offsetTime;
+		const double sourceMin = viewMin - timeShift;
+		const double sourceMax = viewMax - timeShift;
+
+		std::size_t begin = 0;
+		std::size_t end = count;
+
+		if (resolved.axis->monotonic)
+		{
+			const std::vector<double>::const_iterator first = std::lower_bound(time.begin(), time.end(), sourceMin);
+			begin = static_cast<std::size_t>(first - time.begin());
+			if (begin > 0)
+			{
+				--begin;
+			}
+			const std::vector<double>::const_iterator last = std::lower_bound(time.begin(), time.end(), sourceMax);
+			end = static_cast<std::size_t>(last - time.begin());
+			if (end < count)
+			{
+				++end;
+			}
+		}
+
+		if (end <= begin)
+		{
+			return;
+		}
+
+		// ⚠️ **横向补条裁剪**（只对本函数后半段的"逐点描边"路径生效，见 `budget` 之后）：
+		// 图层横向补条只覆盖位图里的一条窄竖带（`m_area` 的 x 区间），其余像素由已有图层像素提供，
+		// 因此折线只需构建并绘制落在条带 x 范围内的那一段顶点。放在"包络/描边"分支判定**之后**
+		// 是必须的 —— 若先裁剪，`visibleCount` 会变成条带内的采样数，可能改变"走包络还是走描边"
+		// 的判定，使条带与整块渲染的像素不一致（出现接缝）。
+
+		const float limitTop = lane.rect.Y - lane.rect.Height * 4.0f;
+		const float limitBottom = lane.rect.Y + lane.rect.Height * 5.0f;
+
+		const std::size_t visibleCount = end - begin;
+
+		// 顶点预算由绘图区宽度决定（而不是固定值）：折线顶点数直接决定
+		// GDI+ 抗锯齿折线的绘制耗时，百万级采样文件若按固定 20000 顶点绘制，
+		// 会把大量顶点堆在同一个像素列上（画出来完全重合），纯粹浪费 CPU。
+		std::size_t budget =
+		    static_cast<std::size_t>(std::max(1.0f, m_plotRect.Width)) * kPolylinePointsPerPixel;
+		budget = std::max(budget, kMinPolylinePoints);
+		budget = std::min(budget, kMaxPolylinePoints);
+
+		// 采样点密度超过像素分辨率时改用“像素列上下包络”抽稀：
+		// 每个像素列只保留最小/最大两个顶点（按出现先后排序），
+		// 既不会漏掉尖峰（等间隔抽样会整段跳过），又把顶点数压到像素量级。
+		//
+		// ⚠️ **阈值必须是「每像素列 1 个采样」而不是 `budget`（每列 2 个）**：
+		// 逐点描边（`DrawLines`）的代价与「竖向线段数 × 覆盖行数」成正比 ——
+		// 方波/编码器这类信号在 1~2 采样/像素时会形成**满幅高的锯齿**，GDI+ 抗锯齿
+		// 逐段扫描这些竖直段，实测 **4481 个顶点要 712ms**（关抗锯齿也无用，因为瓶颈是
+		// 每段的扫描线而非边缘平滑），而同样画面的「像素列包络」只要 ~1.7ms。
+		// 把阈值降到 1 采样/像素后，1~2 采样/像素区间走包络带（逐列 min/max 与折线在该密度下
+		// 几乎等价，且**保留抗锯齿**），彻底消除这一区间的病态卡顿。
+		const bool useEnvelopeBand = (visibleCount > static_cast<std::size_t>(m_plotRect.Width)) &&
+		                             resolved.axis->monotonic && (m_plotRect.Width > 1.0f);
+
+		// 逐点描边路径若处于"横向补条"渲染：把采样区间裁剪到条带对应的 x 范围
+		//（两侧各留少量像素余量以避免接缝与抗锯齿溢出）。逐点描边路径必然 `visibleCount <= budget`
+		//（否则走包络），此时 `stride == 1`，裁剪后条带内的顶点序列与整块渲染完全一致 → 像素不变。
+		if (!useEnvelopeBand && m_stripRenderActive && resolved.axis->monotonic &&
+		    m_stripX1 > m_stripX0)
+		{
+			const float marginPx =
+			    std::max(4.0f, std::max(1.0f, resolved.style->lineWidth) * m_scale + 3.0f);
+			// 条带边界是**绘制时刻**，换算成源时刻要减去时间偏移。
+			const double ta = XToTime(m_stripX0 - marginPx) - timeShift;
+			const double tb = XToTime(m_stripX1 + marginPx) - timeShift;
+			const double clipLo = std::min(ta, tb);
+			const double clipHi = std::max(ta, tb);
+			std::size_t sBegin = static_cast<std::size_t>(
+			    std::lower_bound(time.begin(), time.end(), clipLo) - time.begin());
+			if (sBegin > 0)
+			{
+				--sBegin;	// 多含一个采样点：让跨越条带左界的线段完整绘出。
+			}
+			std::size_t sEnd = static_cast<std::size_t>(
+			    std::lower_bound(time.begin(), time.end(), clipHi) - time.begin());
+			if (sEnd < count)
+			{
+				++sEnd;
+			}
+			if (sBegin > begin)
+			{
+				begin = sBegin;
+			}
+			if (sEnd < end)
+			{
+				end = sEnd;
+			}
+			if (end <= begin)
+			{
+				return;
+			}
+		}
+
+		// 采样点密度远超像素分辨率时改用“像素列上下包络”抽稀：
+		// 每个像素列只保留最小/最大两个顶点（按出现先后排序），
+		// 既不会漏掉尖峰（等间隔抽样会整段跳过），又把顶点数压到像素量级。
+		if (useEnvelopeBand)
+		{
+			const double viewSpan = viewMax - viewMin;
+			const float plotLeft = m_plotRect.X;
+			const float plotWidth = m_plotRect.Width;
+			const std::size_t columns = std::max<std::size_t>(1, budget / 2);
+			const float columnWidth = plotWidth / static_cast<float>(columns);
+
+			const std::vector<double>::const_iterator rangeEnd = time.begin() + static_cast<std::ptrdiff_t>(end);
+
+			// 粗粒度包络层（若已构建）：每列只需读取覆盖到的分组，
+			// 数据量从“可见采样数”降到“像素列数 × 少量分组”，
+			// 且分组内存的就是真实极值，绘制结果与逐点扫描完全一致。
+			const std::vector<double>& coarseMin = resolved.data->coarseMin;
+			const std::vector<double>& coarseMax = resolved.data->coarseMax;
+			const std::size_t coarseStride = resolved.data->coarseStride;
+			// ⚠️ 粗粒度分组只存了逐组的 min/max：取绝对值 / 垂直镜像会把两者互换，
+			// 此时分组层无法再给出正确的包络，必须回退到逐采样点变换（见 `DrawTransformOrderPreserving`）。
+			// Y 偏移是保序的（整体加常数），因此仍可用分组层 —— 只需把偏移一并加上。
+			const bool hasCoarse =
+			    (coarseStride > 0) && !coarseMin.empty() && (coarseMin.size() == coarseMax.size()) &&
+			    DrawTransformOrderPreserving(*resolved.style);
+			// 保序变换（正系数 + Y 偏移）下：分组极值 × 系数 + 偏移 即为变换后的极值
+			//（系数 1、偏移 0 时逐位不变）。
+			const double coarseScale = static_cast<double>(resolved.style->gain);
+			const double coarseOffset = static_cast<double>(resolved.style->offsetY);
+
+			bool inSegment = false;
+
+			// 稠密包络带：逐列记录上/下包络，收段时拼成「上包络正向 + 下包络反向」的
+			// 闭合多边形。绘制时一次 FillPath 即可，实测比逐段描边快约 8 倍
+			// （1224 列：14.3ms → 1.7ms），且**保留抗锯齿**，
+			// 因此静态帧与拖拽帧的观感完全一致（不是"交互降级"）。
+			bandMode = true;
+			const float strokeHalf =
+			    std::max(1.0f, resolved.style->lineWidth) * m_scale * 0.5f;
+			std::vector<BandColumn> segmentColumns;
+			const auto flushBandSegment = [&band, &bandBreaks, &segmentColumns, &bandSpiky, &lane]()
+			{
+				bool spiky = false;
+				EmitEnvelopeBand(segmentColumns, band, bandBreaks, spiky, lane.rect.Height);
+				bandSpiky = bandSpiky || spiky;
+				segmentColumns.clear();
+			};
+
+			std::size_t searchFrom = begin;
+			for (std::size_t column = 0; column < columns; ++column)
+			{
+				// `t0/t1` 是**绘制时刻**的列边界；源时刻要减去时间偏移（偏移为 0 时二者相同）。
+				const double t0 = viewMin + viewSpan * (static_cast<double>(column) / static_cast<double>(columns));
+				const double t1 =
+				    viewMin + viewSpan * (static_cast<double>(column + 1) / static_cast<double>(columns));
+				const double s0 = t0 - timeShift;
+				const double s1 = t1 - timeShift;
+
+				// 列边界随 column 单调递增，从上一列的位置继续二分，
+				// 把每次搜索的范围压到剩余区间，避免 2400 次全区间二分带来的缓存缺失。
+				const std::size_t i0 = static_cast<std::size_t>(
+				    std::lower_bound(time.begin() + static_cast<std::ptrdiff_t>(searchFrom), rangeEnd, s0) -
+				    time.begin());
+				searchFrom = i0;
+				const std::size_t i1 = (column + 1 == columns)
+				                           ? end
+				                           : static_cast<std::size_t>(
+				                                 std::lower_bound(time.begin() + static_cast<std::ptrdiff_t>(i0),
+				                                                  rangeEnd, s1) -
+				                                 time.begin());
+
+				double low = std::numeric_limits<double>::infinity();
+				double high = -std::numeric_limits<double>::infinity();
+				std::size_t lowOrder = 0;
+				std::size_t highOrder = 0;
+				bool broken = false;
+
+				// （一）落在本列区间内的采样点。
+				// 水平镜像时取的是**源下标**（区间同样反转），因此先把列区间映射到源下标区间。
+				const std::size_t srcA = std::min(SourceIndexFor(*resolved.style, count, i0),
+				                                 SourceIndexFor(*resolved.style, count, (i1 > 0) ? (i1 - 1) : 0));
+				const std::size_t srcB = std::max(SourceIndexFor(*resolved.style, count, i0),
+				                                 SourceIndexFor(*resolved.style, count, (i1 > 0) ? (i1 - 1) : 0));
+				if (i1 > i0 && hasCoarse && (i1 - i0) >= 2 * coarseStride)
+				{
+					const std::size_t firstBucket = srcA / coarseStride;
+					const std::size_t lastBucket =
+					    std::min(srcB / coarseStride, coarseMin.size() - 1);
+					for (std::size_t bucket = firstBucket; bucket <= lastBucket; ++bucket)
+					{
+						const double bucketLow = coarseMin[bucket] * coarseScale + coarseOffset;
+						const double bucketHigh = coarseMax[bucket] * coarseScale + coarseOffset;
+						if (!std::isfinite(bucketLow))
+						{
+							// 该分组全部是无效值：包络到此断开，后续另起一段。
+							broken = true;
+							continue;
+						}
+						if (bucketLow < low)
+						{
+							low = bucketLow;
+							lowOrder = bucket;
+						}
+						if (bucketHigh > high)
+						{
+							high = bucketHigh;
+							highOrder = bucket;
+						}
+					}
+				}
+				else if (i1 > i0)
+				{
+					for (std::size_t index = srcA; index <= srcB; ++index)
+					{
+						const double value = ApplyDrawTransform(*resolved.style, values[index]);
+						if (!std::isfinite(value))
+						{
+							// 该列含无效值：包络绘制到本列结束，后续另起一段。
+							broken = true;
+							continue;
+						}
+						if (value < low)
+						{
+							low = value;
+							lowOrder = index;
+						}
+						if (value > high)
+						{
+							high = value;
+							highOrder = index;
+						}
+					}
+				}
+
+				// （二）跨越列边界的两段折线在边界处的取值。
+				//
+				// 波形按相邻采样点之间的**直线**绘制，而包络是按像素列聚合的。采样间隔
+				// 可能大于一个像素列（本仓库的 Problem_Data.csv 相邻采样间隔约 27µs 且不固定，
+				// 放大到 10ms/大格时一个像素列约 60µs），此时一次跃变的两个端点会分别落在
+				// 相邻两列里：对每一列来说"落在本列内的采样点"都在同一边，于是这段竖向折线
+				// 在两侧的包络里都不出现 → 波形在这些跃变处被整段丢掉，看上去就是"断开"。
+				//
+				// 把列边界处的折线取值计入本列包络即可消除该现象：折线在列内是线性的，
+				// 其极值必然出现在采样点或列边界上，因此「列内采样点 + 两侧边界取值」就是
+				// 该列包络的精确解，且相邻两列在边界处取到同一个值，包络带严丝合缝。
+				double boundary = 0.0;
+				if (PolylineValueAt(time, values, count, *resolved.style, i0, s0, boundary))
+				{
+					boundary = ApplyDrawTransform(*resolved.style, boundary);
+					if (boundary < low)
+					{
+						low = boundary;
+						lowOrder = (i0 > 0) ? SourceIndexFor(*resolved.style, count, i0 - 1) : 0;
+					}
+					if (boundary > high)
+					{
+						high = boundary;
+						highOrder = (i0 > 0) ? SourceIndexFor(*resolved.style, count, i0 - 1) : 0;
+					}
+				}
+				if (PolylineValueAt(time, values, count, *resolved.style, i1, s1, boundary))
+				{
+					boundary = ApplyDrawTransform(*resolved.style, boundary);
+					const std::size_t order = SourceIndexFor(*resolved.style, count, (i1 > 0) ? (i1 - 1) : 0);
+					if (boundary < low)
+					{
+						low = boundary;
+						lowOrder = order;
+					}
+					if (boundary > high)
+					{
+						high = boundary;
+						highOrder = order;
+					}
+				}
+
+				if (!(low <= high))
+				{
+					// 本列没有任何有效取值：折线尚未开始、已经结束，或该处数据缺失。
+					inSegment = false;
+					flushBandSegment();
+					continue;
+				}
+
+				const float x = plotLeft + (static_cast<float>(column) + 0.5f) * columnWidth;
+				const float yTop =
+				    static_cast<float>(ClampDouble(ValueToY(high, lane), limitTop, limitBottom));
+				const float yBottom =
+				    static_cast<float>(ClampDouble(ValueToY(low, lane), limitTop, limitBottom));
+
+				// 包络带每列都记录（上下各外扩半个线宽，保证细波动也有可见粗细）。
+				BandColumn bandColumn;
+				bandColumn.x = x;
+				bandColumn.top = yTop - strokeHalf;
+				bandColumn.bottom = yBottom + strokeHalf;
+				segmentColumns.push_back(bandColumn);
+
+				if (yBottom - yTop < kEnvelopeMinPixelSpan)
+				{
+					// 波动不足半个像素：只留一个顶点，避免无意义的重复顶点。
+					if (!inSegment)
+					{
+						breaks.push_back(points.size());
+						inSegment = true;
+					}
+					points.push_back(gd::PointF(x, yTop));
+				}
+				else
+				{
+					if (!inSegment)
+					{
+						breaks.push_back(points.size());
+						inSegment = true;
+					}
+					// 按采样点出现的先后顺序连接上下包络，保持走线方向一致。
+					if (lowOrder <= highOrder)
+					{
+						points.push_back(gd::PointF(x, yBottom));
+						points.push_back(gd::PointF(x, yTop));
+					}
+					else
+					{
+						points.push_back(gd::PointF(x, yTop));
+						points.push_back(gd::PointF(x, yBottom));
+					}
+				}
+
+				if (broken)
+				{
+					inSegment = false;
+					flushBandSegment();
+				}
+			}
+
+			flushBandSegment();
+			return;
+		}
+
+		std::size_t stride = 1;
+		if (visibleCount > budget)
+		{
+			stride = (visibleCount + budget - 1) / budget;
+		}
+
+		bool inSegment = false;
+
+		for (std::size_t index = begin; index < end; index += stride)
+		{
+			const double t = time[index];
+			// 水平镜像 = 数据反序：画面上第 index 个位置取源下标 count-1-index 的值。
+			const double value = ApplyDrawTransform(
+			    *resolved.style, values[SourceIndexFor(*resolved.style, count, index)]);
+			if (!std::isfinite(t) || !std::isfinite(value))
+			{
+				inSegment = false;
+				continue;
+			}
+
+			// 时间偏移：该采样画在 `t + offsetTime` 处（例如 t=1s、偏移 -0.5s → 画在 0.5s）。
+			const float x = TimeToX(t + timeShift);
+			float y = ValueToY(value, lane);
+			y = static_cast<float>(ClampDouble(y, limitTop, limitBottom));
+
+			if (!inSegment)
+			{
+				breaks.push_back(points.size());
+				points.push_back(gd::PointF(x, y));
+				inSegment = true;
+			}
+			else
+			{
+				points.push_back(gd::PointF(x, y));
+			}
+		}
+	}
+
+	void PlotView::PaintEmptyState(gd::Graphics& g)
+	{
+		std::wstring message;
+		if (m_dataSet == nullptr || m_dataSet->Empty())
+		{
+			message = L"打开数据文件以查看波形";
+		}
+		else
+		{
+			message = L"请在左侧勾选需要查看的信号（可同时加载多个文件，各自成为一个分组）";
+		}
+		UiText(g, message, m_fonts->ui, m_area, m_theme->textMuted, TextAlign::CENTER);
+	}
+
+	void PlotView::Paint(gd::Graphics& g)
+	{
+		if (m_theme == nullptr || m_fonts == nullptr)
+		{
+			return;
+		}
+
+		// 本帧整帧都在改写渲染状态（`m_area` / `m_plotRect` / 视界 / 图层…），
+		// 因此必须与「后台派生曲线计算」线程隔离：本锁同时保护渲染状态与派生缓存。
+		// ⚠️ 图层渲染**只在本线程内进行**（见头文件说明）：后台线程一旦改写
+		// `m_area` / `m_plotRect` / `Tab().ViewMin()`，就会覆盖用户正在进行的平移。
+		std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+
+		BuildLaneVisuals();
+
+		// 「边沿计数」的扫描预算**按帧重置**（见 `m_edgeScanFrame` 的说明）：
+		// 旧实现按 `GetTickCount64()` 分桶，帧率一高（`PostMessage` 自持重绘会把它拉高）
+		// 就会在同一系统 tick 内连画多帧而**完全不推进**统计 —— 用户报告
+		// “按住横向光标不动时统计卡住不更新”“回车确认参数后不移动鼠标就停在部分值”。
+		++m_edgeScanFrame;
+		m_edgeScanBudget = kEdgeScanPairsPerFrame;
+
+		// 双缓冲：清掉上一帧钉住的曲线条目（本帧会按需重新钉住），并清理已被更新条目覆盖 /
+		// 超出内存预算的旧条目。此刻没有任何条目被钉住，回收是安全的。
+		m_curvePins.clear();
+		{
+			std::lock_guard<std::mutex> lock(m_curveMutex);
+			PruneCurveEntriesLocked();
+		}
+		// 后台算好了新曲线：
+		//  * **静止**时：整幅作废一次，让新曲线（与新的静态场景缓存）立刻出现。
+		//  * **拖拽中**（拖弱峰调整/均值滤波参数滑块）：**不作废整幅** —— 拖拽时参数每帧都在变，
+		//    本来就每帧走"样式补丁"路径，补丁会直接取到最新曲线；若此时还整幅作废，
+		//    每帧会退化成整幅重绘（实测单帧 150ms+，与"拖动要跟手"直接冲突）。
+		//    改为标记"已降级"，等拖拽结束后再补一帧全质量。
+		if (m_curveSceneDirty.exchange(false, std::memory_order_relaxed))
+		{
+			if (m_dragMode == PlotDragMode::NONE)
+			{
+				InvalidateSceneCache();
+			}
+			else
+			{
+				m_sceneDegraded = true;
+			}
+		}
+
+		if (m_lanes.empty())
+		{
+			InvalidateSceneCache();
+			PaintEmptyState(g);
+			return;
+		}
+
+		// 「快速绘制（关闭抗锯齿）」只在**会改变画面主体（波形/网格几何）**的拖拽期间启用：
+		// 这些拖拽每帧都要重画波形，关掉抗锯齿能显著加速（同一条包络带 27.6ms → 3.2ms）。
+		// ⚠️ 像「拖时间光标」「选区框选」「拖浮动面板」这类**只改叠加层、画面主体不变**的交互，
+		// 一旦启用快速帧就会给静态场景缓存打上「已降级」标记 → 缓存失效 → 每帧整幅重画
+		//（实测拖光标从约 1ms 骤升到十几毫秒）。因此这里**不**把它们算作快速帧，
+		// 让它们直接复用静态场景缓存（贴图 ~1ms）+ 叠加层，做到真正跟手。
+		const bool sceneChangingDrag =
+		    (m_dragMode == PlotDragMode::PAN) || (m_dragMode == PlotDragMode::SCROLL_LANES) ||
+		    (m_dragMode == PlotDragMode::LANE_REORDER) || (m_dragMode == PlotDragMode::MOVE_SIGNAL);
+		m_fastFrame = sceneChangingDrag;
+
+		// 贴图之后、静态场景之外的全部内容（随鼠标变化或位于最上层）。
+		// 三个分支（完全命中 / 局部重画 / 整幅重绘）共用同一段，保证观感完全一致。
+		const auto paintOverlays = [this, &g]()
+		{
+			PaintHoverHighlight(g);
+			PaintLegendHighlight(g);
+			PaintRubberBand(g);
+			PaintCursor(g, m_lanes);
+			PaintEdgeCursor(g, m_lanes);
+			PaintSignalInteraction(g);
+			PaintHint(g);
+			// 网格 Y 轴上下限的输入框、以及「弱峰调整 → 迭代次数上限」的输入框都绘制在最上层
+			//（后者覆盖在浮动面板的滑块行之上）。
+			if (m_editTarget == PlotEditTarget::LANE_Y_MAX ||
+			    m_editTarget == PlotEditTarget::LANE_Y_MIN ||
+			    m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX)
+			{
+				PaintEditField(g);
+			}
+			PaintScrollBar(g);
+
+			// 绘图区外框（比网格内部分界线更重，形成明确整体边界）。
+			// 用 GDI 画 4 条线：GDI+ 的 DrawRectangle 带抗锯齿时单帧要花掉 1ms 以上。
+			{
+				const float left = m_plotRect.X;
+				const float top = m_plotRect.Y;
+				const float right = m_plotRect.X + m_plotRect.Width;
+				const float bottom = m_plotRect.Y + m_plotRect.Height;
+				const float border[16] = {left, top, right, top, right, top, right, bottom,
+				                          right, bottom, left, bottom, left, bottom, left, top};
+				UiDrawSolidLines(g, gd::RectF(left - 2.0f, top - 2.0f, m_plotRect.Width + 4.0f,
+				                             m_plotRect.Height + 4.0f),
+				                 border, 4, m_theme->axisLine | 0xFF000000u, 2);
+			}
+		};
+
+		// 网格次序拖拽：静态场景缓存仍然有效，但各网格要按位移重新"摆放"。
+		// 这里逐网格把缓存中的横向条带平移贴回（几十微秒），
+		// 因此拖动百万级采样的网格时依然流畅，且被拖网格的波形随鼠标自由移动。
+		if (m_dragMode == PlotDragMode::LANE_REORDER && m_laneDragFrom >= 0 && m_sceneValid)
+		{
+			PaintLaneReorder(g);
+			paintOverlays();
+			return;
+		}
+
+		// 静态场景复用（不再局限于拖拽）：只要视图几何、信号集合与显示样式都没变，
+		// "绘图区底色 + 全部网格 + 时间轴"就逐像素相同，直接贴图即可。
+		// 大文件下整幅重绘约 80ms，贴图约 1ms —— 鼠标悬停、拖拽选区这些
+		// "只改一小块叠加层"的交互因此不再重绘波形。
+		// 随鼠标变化的内容（悬停高亮、读数框、选区、光标、拖拽虚影、输入框）一律画在贴图之后。
+		if (SceneCacheMatches() && BlitSceneCache(g))
+		{
+			// ⚠️ **顺手做一次"空闲预热"**：图层不存在（刚加载 / 网格数量变化）或仍是旧跨度时，
+			// 在这里用既有预算机制**每帧至多补 1 个网格**。若不预热，用户第一次平移 / 选区放大
+			// 时，`Paint` 会在那一帧里**同步重建全部网格图层**（5 个网格实测 30~80ms）——
+			// 这正是"选区放大的第一帧特别卡"的根因（该帧其余工作只有约 16ms 的占位拉伸）。
+			// 命中静态场景缓存 ⇒ 本帧视图与缓存同源（视界没变），因此预热出来的图层不会白费。
+			WarmLaneLayersStep();
+			paintOverlays();
+			return;
+		}
+
+		// 视界平移 / 派生预览曲线参数变化：画面**基底**（网格/波形）不变，只是横向平移或
+		// 叠加的派生曲线变化。直接复用「宽缓冲区」已渲染的**基底**像素，只把派生曲线作为
+		// 叠加层重画 —— 前台 O(1)，不重画波形，因此无论放大到多深都保持跟手。
+		// 判定：网格结构未变（几何指纹一致）且**逐信号外观样式未变** → 属视图/派生变化，可用宽基底；
+		// 外观样式（颜色/粗细/透明度/模式）变化 → 交给下方"样式补丁"分支局部重画。
+		// ⚠️ 位置必须在"静态场景贴图"**之后**：视界与样式都没变时（典型：鼠标悬停移动）
+		//    应由静态场景贴图命中，绝不能落到这里 —— 否则每两帧就会触发一次"结算整幅重绘"，
+		//    悬停反而变卡。而它又必须在"样式补丁"**之前**：派生曲线参数变化（拖弱峰调整 /
+		//    均值滤波滑块）同样只需叠加重画派生曲线，走本分支比"逐网格补丁"更快且质量更高。
+		// ⚠️ **不要求"正在拖拽"**：非拖拽的视界变化（键盘方向键 / 工具栏）同样走此快路径，
+		//    避免该放大区间"整幅重绘约 124ms"的卡顿。
+		bool wideUsable = false;
+		if (HasDrawableContent() && m_sceneValid && m_sceneGeometryHash == SceneGeometryHash())
+		{
+			std::vector<std::vector<SceneStyleEntry>> currentStyles;
+			CollectSceneStyles(currentStyles);
+			wideUsable = (currentStyles == m_sceneStyles);
+		}
+		if (wideUsable)
+		{
+			// 内容（含视界）与本帧上一条快路径帧相同 → 视界已停止变化 → 走一次整幅"结算"
+			// 全质量帧（保证最终呈现**像素精确**；此后命中静态场景缓存，不再回到本分支）。
+			std::uint64_t wideKey = SceneContentHash(true);
+			wideKey ^= static_cast<std::uint64_t>(std::llround(Tab().ViewMin() * 1.0e6));
+			wideKey *= 1099511628211ull;
+			wideKey ^= static_cast<std::uint64_t>(std::llround(Tab().ViewMax() * 1.0e6));
+
+			// 「结算」：视界已停止变化（内容与视界都与上一条快路径帧相同）、**不在拖拽中**、
+			// 且**全部网格图层都已就绪** → 落到下方整幅全质量重绘，保证最终呈现像素精确
+			// （此后命中静态场景缓存，不再回到本分支）。
+			//
+			// ⚠️ 三个条件缺一不可：
+			//  * **不在拖拽中**：拖拽期间不做结算，否则每两帧就会穿插一次整幅重绘 ——
+			//    而拖拽帧的 `m_fastFrame` 为真（关抗锯齿），于是出现"波形质量轮流变差/抖动"
+			//    与周期性卡顿（这正是用户报告的"按住拖拽时显示效果下降、断线"的根因）。
+			//  * **全部图层就绪**：还有网格没画好时不能结算，否则结算帧之后的格子又是旧的。
+			//  * 记录已消费本 key，避免下一帧重复结算。
+			const bool viewStopped = (m_wideLastValid && m_wideLastKey == wideKey);
+			if (viewStopped && m_dragMode == PlotDragMode::NONE && LanesAllReadyForView())
+			{
+				m_wideLastValid = false;	// 结算：落到下方整幅重绘（非拖拽 → 全质量）
+			}
+			else
+			{
+				// ⚠️ **绝不在这里同步整批重建全部图层**：跨度变化（选区放大 / 键盘缩放 /
+				// 工具栏缩放）时若一次性重建 5 个网格，实测 70~80ms —— 这正是"缩放首帧卡顿"
+				// 的根因。改为：
+				//   * 只有"图层数量与网格数量不符"（首次绘制 / 增删网格）才必须同步整批建立；
+				//   * 跨度/内容过期的网格一律登记到待重画队列，由 `RollWideBuffer` 登记、
+				//     `RenderPendingLaneRebuilds` 按预算逐帧补齐；其间 `BlitWideBuffer`
+				//     会用**旧跨度像素拉伸**当占位图（低分辨率但立即可用，O(1)）。
+				if (!LayersAllocated())
+				{
+					RebuildWideBuffer();
+				}
+				// 逐网格滚动跟随视界。⚠️ `RollWideBuffer` **不做整块重画**：内容过期 / 锚点
+				// 过远的网格只登记到待重画队列，因此前台每帧的工作量恒定且很小。
+				RollWideBuffer();
+				// 预算内补画"待重画"的网格：**本帧最多一个**，其余留到后续帧
+				//（即使 5 个网格同时需要重画，前台也不会在某一帧里做完整批而卡顿）。
+				// ⚠️ **必须在贴图之前**：否则本帧画好的网格要到下一帧才显示，
+				// 拖拽时表现为"波形比鼠标慢半拍"、快速拖动时出现"断线"（图层覆盖不到视界）。
+				//
+				// ⚠️ **只在视界稳定后才花预算做精细重绘**（视界仍在变化的每一帧只贴"旧跨度像素拉伸"
+				// 的占位图，O(1)，把重建推迟到视界停下来之后 —— 用户要求"先画了再说，别卡住前台"），
+				// 且**仍按预算逐个补**（不用一次把全部过期网格塞进同一帧）：实测同一台机器上 4 线程
+				// 真并行（3.98x），但**图层光栅化（GDI+）本身会被串行化**，并行重建 5 个网格 ≈ 逐个重建
+				//（1.03x）→ 一次性补齐只会把一帧从 ~10ms 抬到 ~31ms（更容易掉帧）。
+				// 因此保持"视界停后**每帧补一个网格**"（`RenderPendingLaneRebuilds` 在 `budget>1` 时才走并行）。
+				const bool morePending =
+				    viewStopped ? RenderPendingLaneRebuilds(1) : !m_layerRebuildPending.empty();
+				// 绘图区底色（覆盖时间轴与侧边留白区域）。
+				UiFillRect(g, m_area, m_theme->plotBg);
+				// 贴基底（绘图区：网格 + 波形）。图层没覆盖到的部分先留空，后续帧补齐。
+				if (BlitWideBuffer(g))
+				{
+					m_wideLastKey = wideKey;
+					m_wideLastValid = true;
+					// 时间轴：宽缓冲不含它，前台按当前视图绘制。
+					const double wideViewMin = Tab().ViewMin();
+					const double wideViewMax = Tab().ViewMax();
+					const double wideSpanNow = wideViewMax - wideViewMin;
+					const double wideTimeStep =
+					    NiceStep((wideSpanNow > 0.0) ? wideSpanNow : 1.0, kTimeTickTarget);
+					std::vector<double> wideTimeTicks;
+					BuildTicks(wideViewMin, wideViewMax, wideTimeStep, wideTimeTicks);
+					PaintTimeAxis(g, wideTimeTicks, wideTimeStep);
+					// 网格分界线：图层里**不含**它（它锚定在网格的屏幕位置，会被纵向偏移贴图带走），
+					// 因此在这里补画一次（与整幅重绘同一套颜色与线宽）。
+					PaintLaneDividers(g);
+					// 派生预览曲线：基底不含它们（拖参数滑块时基底不变、可直接复用像素）。
+					for (std::size_t i = 0; i < m_lanes.size(); ++i)
+					{
+						PaintLaneDerivedOverlays(g, static_cast<int>(i), m_lanes[i]);
+					}
+					// 装饰（Y 轴刻度 + GX 编号 + 图例）：基底不含（否则平移会重影）。
+					// 内容指纹一致 → 直接按 `AlphaBlend` 贴回缓存（省掉文字绘制）；
+					// 否则先把装饰单独绘制进透明缓存位图，再贴回。
+					// ⚠️ 贴回的是**带 alpha 的圆角图形**：圆角之外是全透明，
+					// 因此透出的是**当前**波形 —— 既没有"直角白边"，也不会残留旧波形像素。
+					m_useDecorCache = m_decorValid && (m_decorKey == SceneDecorHash());
+					if (!m_useDecorCache && RenderDecorCache())
+					{
+						m_decorKey = SceneDecorHash();
+						m_useDecorCache = true;
+					}
+					if (m_useDecorCache)
+					{
+						BlitDecorCache(g);
+					}
+					else
+					{
+						// 退化路径（无法建立透明缓存，例如系统不提供 AlphaBlend）：
+						// 直接把装饰画进后备缓冲区（就地绘制，不做缓存）。
+						m_renderDecorOnly = true;
+						for (std::size_t i = 0; i < m_lanes.size(); ++i)
+						{
+							PaintLane(g, static_cast<int>(i), m_lanes[i], wideTimeTicks);
+						}
+						m_renderDecorOnly = false;
+					}
+					paintOverlays();
+					if (morePending)
+					{
+						// 请宿主再送一帧（与派生曲线就绪用同一条消息：只失效绘图区且不置脏）。
+						const HWND host = m_host;
+						if (host != nullptr)
+						{
+							PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
+						}
+					}
+					return;
+				}
+			}
+		}
+
+		// 只有"外观样式"变化（典型场景：拖动自定义颜色滑块实时调色）：网格结构、视图几何、
+		// 波形采样都没变，只是颜色/不透明度/线宽/模式不同 —— 此时只重画受影响的网格，
+		// 再写回缓存。（VERY_BIG_DATA 实测：整幅重绘 30ms+，单网格重画约 4ms。）
+		{
+			std::vector<int> patchLanes;
+			if (FindStyleOnlyLanes(patchLanes) && BlitSceneCache(g))
+			{
+				// ⚠️ 样式**正在连续变化**（拖透明度 / 粗细 / 拾色滑块）：这本身就是一种"交互中"。
+				// 若不切换快速帧，本帧会用**抗锯齿**重画波形包络带 —— 实测单条网格的包络带
+				// AA 填充 ≈29ms（本机负载下 72ms），而关掉 AA 只要 ≈5.6ms。
+				// 因此补丁阶段强制快速帧，并在补丁后把场景缓存标记为"已降级"，
+				// 下一帧（参数稳定后）自动补一帧全质量 —— 既保证拖动手感，又不牺牲最终画质。
+				m_fastFrame = true;
+				RepaintSceneCachePatch(g, patchLanes);
+				m_sceneDegraded = true;
+				paintOverlays();
+				return;
+			}
+		}
+
+		const double viewMin = Tab().ViewMin();
+		const double viewMax = Tab().ViewMax();
+		const double span = viewMax - viewMin;
+		const double timeStep = NiceStep((span > 0.0) ? span : 1.0, kTimeTickTarget);
+		std::vector<double> timeTicks;
+		BuildTicks(viewMin, viewMax, timeStep, timeTicks);
+
+		// 绘图区整体底色。
+		UiFillRect(g, m_area, m_theme->plotBg);
+
+		// 波形区域底色。
+		UiFillRect(g, m_plotRect, m_theme->cardBg);
+
+		// 图例命中矩形每帧重建，避免残留已消失的信号。
+		m_legendHits.clear();
+
+		// 「装饰层」：装饰**不在网格循环里就地绘制**，而是统一由带 alpha 的装饰层贴回
+		// （这样圆角之外透出的是当前波形，不会出现"直角白边"）。
+		m_decorRects.clear();
+		m_useDecorCache = true;
+
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			PaintLane(g, static_cast<int>(index), m_lanes[index], timeTicks);
+		}
+
+		PaintTimeAxis(g, timeTicks, timeStep);
+
+		// 装饰层：缓存与当前内容同源则直接贴回；否则先把装饰绘制进透明缓存位图再贴回。
+		if (!m_decorValid || m_decorKey != SceneDecorHash())
+		{
+			if (RenderDecorCache())
+			{
+				m_decorKey = SceneDecorHash();
+			}
+		}
+		BlitDecorCache(g);
+
+		// 此刻画布上正好是"绘图区底色 + 全部网格 + 时间轴"，尚未绘制任何随鼠标变化的内容，
+		// 因此是捕获静态场景缓存的最佳时点（必须在裁剪区已全部恢复之后执行）。
+		// ⚠️ 快速帧（交互期间，关闭了抗锯齿）**仍然捕获**（这样拖动参数滑块时能走
+		// "只重画受影响网格"的快路径），但打上 `m_sceneDegraded` 标记 →
+		// `SceneCacheMatches()` 会拒绝命中，交互结束后的下一帧必定重画全质量版本。
+		CaptureSceneCache(g);
+		m_sceneDegraded = m_fastFrame;
+
+		paintOverlays();
+	}
+
+	void PlotView::PaintSignalHaloFor(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
+	                                  const PolylineCacheEntry& cached)
+	{
+		if (resolved.style == nullptr)
+		{
+			return;
+		}
+		// 光晕一律用折线描边（与"之前"的画法一致）。曾经在包络带模式下改成"带外扩填充"，
+		// 虽然更快但观感变了（用户反馈显示效果下降），因此恢复。
+		PaintSignalHalo(g, resolved, lane, cached.points, cached.breaks);
+	}
+
+	void PlotView::PaintSignalHalo(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
+	                               const std::vector<gd::PointF>& points,
+	                               const std::vector<std::size_t>& breaks)
+	{
+		// ⚠️ **只有单个数据点**的信号（默认样式是「点线」，那个点本身是一个粗圆点）：
+		// 折线光晕无从下手（不足两个顶点），改为在数据点外包一圈强调色圆环。
+		// 否则悬停时完全没有“可拖拽”的视觉反馈（用户 2026-10-15 报告）。
+		if (resolved.data != nullptr && resolved.data->finiteCount == 1)
+		{
+			gd::PointF dot;
+			if (SinglePointScreenPos(resolved, lane, dot))
+			{
+				const float radius = SinglePointDotRadius(resolved) + 3.0f * m_scale;
+				gd::Pen ring(ToGdiColor(WithAlpha(m_theme->accent, 0x88)), 2.0f * m_scale);
+				g.DrawEllipse(&ring, dot.X - radius, dot.Y - radius, radius * 2.0f, radius * 2.0f);
+			}
+			return;
+		}
+
+		const bool drawLine = (resolved.style->mode != DrawMode::SCATTER);
+		if (!drawLine || breaks.empty())
+		{
+			// 散点模式没有光晕（原实现同样只对折线绘制光晕）。
+			return;
+		}
+
+		gd::Pen halo(ToGdiColor(WithAlpha(m_theme->accent, 0x66)),
+		             (resolved.style->lineWidth + 4.0f) * m_scale);
+		halo.SetLineJoin(gd::LineJoinRound);
+		halo.SetStartCap(gd::LineCapRound);
+		halo.SetEndCap(gd::LineCapRound);
+		for (std::size_t k = 0; k < breaks.size(); ++k)
+		{
+			const std::size_t start = breaks[k];
+			const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
+			if (stop <= start + 1)
+			{
+				continue;
+			}
+			g.DrawLines(&halo, points.data() + start, static_cast<INT>(stop - start));
+		}
+	}
+
+	void PlotView::PaintHoverHighlight(gd::Graphics& g)
+	{
+		if (m_tab == nullptr || m_dragMode != PlotDragMode::NONE)
+		{
+			// 拖拽过程中不显示悬停提示（拖拽中的信号光晕已绘入静态场景缓存）。
+			return;
+		}
+
+		const int saveState = g.Save();
+		g.SetClip(m_area, gd::CombineModeIntersect);
+
+		// 悬停网格：一层很淡的强调色叠加。为了能画在静态场景之上，
+		// 这里用半透明而非不透明混色，观感与原实现基本一致。
+		// ⚠️ 高亮来源见 `EffectiveHoverLane()`（浮动面板悬停 / 信号列表悬停），
+		//    **不再**由"鼠标在网格里"触发。
+		const int hoverLane = EffectiveHoverLane();
+		if (hoverLane >= 0 && hoverLane < static_cast<int>(m_lanes.size()))
+		{
+			const gd::RectF& laneRect = m_lanes[static_cast<std::size_t>(hoverLane)].rect;
+			const float clipTop = std::max(laneRect.Y, m_plotRect.Y);
+			const float clipBottom = std::min(laneRect.Y + laneRect.Height, m_plotRect.Y + m_plotRect.Height);
+			if (clipBottom > clipTop)
+			{
+				// alpha 0x0A ≈ 4%，与原「不透明混色 3.5%」的观感基本一致。
+				UiFillRect(g, gd::RectF(laneRect.X, clipTop, laneRect.Width, clipBottom - clipTop),
+				           WithAlpha(m_theme->accent, 0x0A));
+			}
+		}
+
+		// 悬停信号：外扩一圈半透明强调色作为"可拖拽"提示。
+		// 鼠标在绘图区内直接命中时用 `m_hoverSignal`；信号列表 / 样式区悬停时用
+		// `m_externalHoverSignal`（二者高亮方式相同，用户要求列表悬停也要高亮曲线本身）。
+		SignalRef haloRef = m_hoverSignal;
+		if (!haloRef.IsValid())
+		{
+			haloRef = m_externalHoverSignal;
+		}
+		if (haloRef.IsValid())
+		{
+			const ResolvedSignal resolved = ResolveSignal(haloRef);
+			if (resolved.data != nullptr && resolved.style != nullptr && resolved.visible)
+			{
+				const int laneIndex = m_tab->LaneOfSignal(haloRef);
+				if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()))
+				{
+					const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
+					const PolylineCacheEntry* cached = AcquirePolyline(haloRef, resolved, lane);
+					if (cached != nullptr)
+					{
+						PaintSignalHaloFor(g, resolved, lane, *cached);
+					}
+				}
+			}
+		}
+
+		g.Restore(saveState);
+	}
+
+	void PlotView::PaintLegendHighlight(gd::Graphics& g)
+	{
+		if (m_tab == nullptr || m_lanes.empty())
+		{
+			return;
+		}
+
+		const int saveState = g.Save();
+		g.SetClip(m_area, gd::CombineModeIntersect);
+
+		// ------------------------------------------------------------------
+		// (1) 网格编号徽标（GX）的悬停高亮。
+		//     徽标本体画在静态场景 / 装饰缓存里（不随鼠标变化），因此悬停时必须在贴图之后
+		//     **把徽标重画一遍**（不透明底色 + 圆角 + 文字）—— 否则它在缓存里被冻结，
+		//     鼠标移上去看不到任何反馈（用户要求的"参考信号列表里 GX 徽标"的悬停提示）。
+		//     ⚠️ 只在**未拖拽**时绘制：`LANE_REORDER` 期间网格连同徽标被整体平移贴图，
+		//     这里按静态位置重画会画到错误的地方。
+		// ------------------------------------------------------------------
+		if (m_dragMode == PlotDragMode::NONE && m_hoverBadge >= 0 &&
+		    m_hoverBadge < static_cast<int>(m_lanes.size()))
+		{
+			const gd::RectF badge = LaneBadgeRect(m_hoverBadge);
+			if (badge.Width > 0.0f)
+			{
+				const float radius = kLaneBadgeHeight * m_scale * 0.5f;
+				// 只重画**圆角形状本身**（不透明）：圆角之外保持"贴图层"的像素，
+				// 因此不会出现直角白边。
+				UiFillRoundRect(g, badge, radius, m_theme->accentSoft);
+				UiDrawRoundRect(g, badge, radius, m_theme->accent, 1.0f);
+				UiText(g, L"G" + std::to_wstring(m_hoverBadge + 1), m_fonts->monoSmall, badge,
+				       m_theme->textStrong, TextAlign::CENTER);
+			}
+		}
+
+		// ------------------------------------------------------------------
+		// (2) 图例条目悬停：条目托底高亮 + **对应信号曲线**的光晕。
+		// ------------------------------------------------------------------
+		if (m_dragMode != PlotDragMode::NONE || !m_hoverLegend.IsValid())
+		{
+			g.Restore(saveState);
+			return;
+		}
+		const int laneIndex = m_tab->LaneOfSignal(m_hoverLegend);
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			g.Restore(saveState);
+			return;
+		}
+		const gd::RectF laneRect = m_lanes[static_cast<std::size_t>(laneIndex)].rect;
+		if (laneRect.Y > m_plotRect.Y + m_plotRect.Height ||
+		    laneRect.Y + laneRect.Height < m_plotRect.Y)
+		{
+			g.Restore(saveState);
+			return;
+		}
+
+		// 除了图例条目本身，还要把**对应的信号曲线**一并高亮：用户在网格图例上移动时
+		// 一眼就能确认这条条目对应哪条曲线（与"鼠标贴近曲线"时的光晕提示一致）。
+		const ResolvedSignal resolved = ResolveSignal(m_hoverLegend);
+		if (resolved.data != nullptr && resolved.style != nullptr && resolved.visible)
+		{
+			const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
+			if (const PolylineCacheEntry* cached = AcquirePolyline(m_hoverLegend, resolved, lane))
+			{
+				PaintSignalHaloFor(g, resolved, lane, *cached);
+			}
+		}
+
+		// 条目悬停高亮：**圆角托底 + 与选中态相同的高亮**（用户明确要求"悬停效果与 GX 标签
+		// 相同、选中状态与悬停提示效果相同"），并在其上**原样重绘色块与文字** ——
+		// 不透明托底若只画底色会把图例内容整块盖住（只剩一个空色块）。
+		for (const LegendHit& hit : m_legendHits)
+		{
+			if (hit.ref == m_hoverLegend)
+			{
+			const float radius = (hit.radius > 0.0f) ? hit.radius : (kLaneBadgeHeight * 0.5f * m_scale);
+				UiFillRoundRect(g, hit.rect, radius, m_theme->accentSoft);
+				UiDrawRoundRect(g, hit.rect, radius, m_theme->accent, 1.0f);
+				UiDrawSwatch(g, hit.swatch, hit.swatchColor, hit.swatchOpacity, 1.5f * m_scale, m_scale);
+				UiText(g, hit.label, m_fonts->uiTiny, hit.text, m_theme->textStrong, TextAlign::LEFT);
+				break;
+			}
+		}
+		g.Restore(saveState);
+	}
+
+	PlotView::SceneCacheKey PlotView::MakeSceneCacheKey() const
+	{
+		SceneCacheKey key;
+		key.viewMin = Tab().ViewMin();
+		key.viewMax = Tab().ViewMax();
+		key.laneScroll = Tab().LaneScroll();
+		key.laneCount = static_cast<int>(m_lanes.size());
+		key.areaX = m_area.X;
+		key.areaY = m_area.Y;
+		key.areaW = m_area.Width;
+		key.areaH = m_area.Height;
+		key.scale = m_scale;
+
+		const SignalRef halo = SceneHaloRef();
+		key.haloGroup = halo.groupIndex;
+		key.haloSignal = halo.signalIndex;
+		key.contentHash = SceneContentHash();
+		return key;
+	}
+
+	bool PlotView::SceneCacheMatches() const
+	{
+		if (!m_sceneValid)
+		{
+			return false;
+		}
+		// 缓存里存的是「快速帧」（关掉了抗锯齿）→ 不能直接命中：
+		// 必须重画一次全质量版本，否则降级的画面会一直留在屏幕上。
+		if (m_sceneDegraded)
+		{
+			return false;
+		}
+		const SceneCacheKey& cached = m_sceneKey;
+		const SceneCacheKey key = MakeSceneCacheKey();
+		return (key.viewMin == cached.viewMin) && (key.viewMax == cached.viewMax) &&
+		       (key.laneScroll == cached.laneScroll) && (key.laneCount == cached.laneCount) &&
+		       (key.areaX == cached.areaX) && (key.areaY == cached.areaY) &&
+		       (key.areaW == cached.areaW) && (key.areaH == cached.areaH) &&
+		       (key.scale == cached.scale) && (key.haloGroup == cached.haloGroup) &&
+		       (key.haloSignal == cached.haloSignal) && (key.contentHash == cached.contentHash);
+	}
+
+	SignalRef PlotView::SceneHaloRef() const
+	{
+		// 只有拖拽中的信号光晕是“整个拖拽过程都不变”的，可以安全地绘入静态场景缓存；
+		// 悬停光晕随鼠标移动，必须画在缓存之外（见 PaintHoverHighlight）。
+		if (m_dragMode == PlotDragMode::MOVE_SIGNAL && m_dragSignal.IsValid())
+		{
+			return m_dragSignal;
+		}
+		return SignalRef();
+	}
+
+	std::uint64_t PlotView::SceneContentHash(bool includeStyles, bool includeDerived,
+	                                        bool includeLaneRange) const
+	{
+		// FNV-1a：把“视图几何之外的一切影响绘图区像素的内容”折叠成一个指纹。
+		// 这样颜色/线宽/透明度/样式/重命名/信号增删等变化都会自动让缓存失效，
+		// 不需要在各处手工调用 InvalidateSceneCache（容易漏）。
+		// `includeStyles == false` 时跳过逐信号的外观样式（颜色/不透明度/线宽/模式），
+		// 得到的就是几何指纹：它一致说明“只有外观样式变了”。
+		std::uint64_t hash = 1469598103934665603ull;
+		const auto mix = [&hash](std::uint64_t value)
+		{
+			hash ^= value;
+			hash *= 1099511628211ull;
+		};
+		const auto mixFloat = [&mix](float value)
+		{
+			std::uint32_t bits = 0;
+			std::memcpy(&bits, &value, sizeof(bits));
+			mix(bits);
+		};
+		const auto mixText = [&mix](const std::wstring& text)
+		{
+			mix(text.size());
+			for (const wchar_t character : text)
+			{
+				mix(static_cast<std::uint64_t>(character));
+			}
+		};
+
+		mixFloat(m_plotRect.X);
+		mixFloat(m_plotRect.Y);
+		mixFloat(m_plotRect.Width);
+		mixFloat(m_plotRect.Height);
+		mixFloat(m_laneContentHeight);
+		mix(m_scrollBarVisible ? 1ull : 0ull);
+		// ⚠️ 网格纵向滚动量必须参与指纹：它只改变各网格的绘制位置。
+		// 若不参与，平移宽缓冲区 / 静态场景缓存会把旧滚动位置的像素当成当前内容贴回，
+		// 表现为“网格位置错位 / 拖影 / 残留”等错误元素。
+		mixFloat(Tab().LaneScroll());
+
+		// 选中信号会改变图例条目的底色与文字颜色（绘制在缓存的静态场景里），
+		// 因此必须参与指纹：否则在左侧信号面板点选后图例不会高亮联动。
+		{
+			const SignalRef selected = SelectedRef();
+			mix(selected.IsValid() ? 1ull : 0ull);
+			mix(static_cast<std::uint64_t>(selected.groupIndex));
+			mix(static_cast<std::uint64_t>(selected.signalIndex));
+		}
+
+		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
+		{
+			const LaneVisual& visual = m_lanes[laneIndex];
+			mixFloat(visual.rect.Y);
+			mixFloat(visual.rect.Height);
+			// ⚠️ 幅值范围只在 `includeLaneRange` 时计入：拖拽平移时的纵向分量会每帧小幅改动它，
+			// 若参与“宽基底可用性”判据，每一帧都会退化成整幅重绘（质量下降 + 卡顿）。
+			if (includeLaneRange)
+			{
+				mixFloat(static_cast<float>(visual.yMin));
+				mixFloat(static_cast<float>(visual.yMax));
+			}
+
+			const std::vector<SignalRef>& signals = Tab().Lanes()[laneIndex].signals;
+			// 「边沿计数（中心轴）」「均值滤波」「弱峰调整」的开关与每条被勾选信号的参数
+			// 会改变网格内的曲线绘制。它们**只影响网格内容**（不影响网格结构/几何），
+			// 因此只在 includeStyles 时计入 —— 于是拖参数滑块可以走“局部重画”快路径，
+			// 而不必整幅重绘（`FindStyleOnlyLanes` 用 `m_sceneDerived` 定位受影响的网格）。
+			// `includeDerived == false` 时连这些参数也不计入（用于装饰层指纹：图例/Y 轴刻度
+			// 与派生曲线参数无关，拖滑块时装饰层无需失效）。
+			if (includeStyles && includeDerived)
+			{
+				mix(Tab().Lanes()[laneIndex].edgeCenter ? 1ull : 0ull);
+				mix(static_cast<std::uint64_t>(Tab().Lanes()[laneIndex].edgeCenterItems.size()));
+				for (const Lane::EdgeCenterItem& item : Tab().Lanes()[laneIndex].edgeCenterItems)
+				{
+					mix(static_cast<std::uint64_t>(item.ref.groupIndex));
+					mix(static_cast<std::uint64_t>(item.ref.signalIndex));
+					mix(static_cast<std::uint64_t>(item.points));
+					mix(static_cast<std::uint64_t>(item.iterations));
+				}
+				mix(Tab().Lanes()[laneIndex].meanFilter ? 1ull : 0ull);
+				mix(static_cast<std::uint64_t>(Tab().Lanes()[laneIndex].meanFilterItems.size()));
+				for (const Lane::MeanFilterItem& item : Tab().Lanes()[laneIndex].meanFilterItems)
+				{
+					mix(static_cast<std::uint64_t>(item.ref.groupIndex));
+					mix(static_cast<std::uint64_t>(item.ref.signalIndex));
+					mix(static_cast<std::uint64_t>(item.points));
+					mix(static_cast<std::uint64_t>(item.iterations));
+				}
+				mix(Tab().Lanes()[laneIndex].weakPeak ? 1ull : 0ull);
+				mix(static_cast<std::uint64_t>(Tab().Lanes()[laneIndex].weakPeakItems.size()));
+				for (const Lane::WeakPeakItem& item : Tab().Lanes()[laneIndex].weakPeakItems)
+				{
+					// 逐信号参数（等级 + 迭代次数）都参与指纹：改任一条的参数都会重画。
+					mix(static_cast<std::uint64_t>(item.ref.groupIndex));
+					mix(static_cast<std::uint64_t>(item.ref.signalIndex));
+					mix(static_cast<std::uint64_t>(item.amountPercent));
+					mix(static_cast<std::uint64_t>(item.iterations));
+				}
+			}
+			mix(signals.size());
+			for (const SignalRef& ref : signals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				mix(static_cast<std::uint64_t>(ref.groupIndex));
+				mix(static_cast<std::uint64_t>(ref.signalIndex));
+				mix(resolved.visible ? 1ull : 0ull);
+				if (resolved.data == nullptr || resolved.style == nullptr)
+				{
+					continue;
+				}
+				// 以下四项是“只影响外观”的样式：仅在 includeStyles 时计入指纹。
+				// （不参与时得到的就是 SceneGeometryHash：它一致说明只有外观变了，
+				//   于是可以只重画颜色变了的网格，而不必整幅重绘。）
+				if (includeStyles)
+				{
+					mix(static_cast<std::uint64_t>(resolved.style->color));
+					mixFloat(resolved.style->opacity);
+					mixFloat(resolved.style->lineWidth);
+					mix(static_cast<std::uint64_t>(resolved.style->mode));
+					// 绘制前的数值变换（系数 / 绝对值 / 镜像）会改变波形形状。
+					mixFloat(resolved.style->gain);
+					mix(resolved.style->absolute ? 1ull : 0ull);
+					mix(resolved.style->mirrorVertical ? 1ull : 0ull);
+					mix(resolved.style->mirrorHorizontal ? 1ull : 0ull);
+					// 偏移（Y 平移 + 时间平移）同样会改变波形。
+					mixFloat(resolved.style->offsetY);
+					mixFloat(static_cast<float>(resolved.style->offsetTime));
+				}
+				// 图例文案参与绘制，重命名必须让缓存失效。
+				mixText(resolved.data->name);
+				if (resolved.group != nullptr)
+				{
+					mixText(resolved.group->name);
+				}
+			}
+		}
+		return hash;
+	}
+
+	std::uint64_t PlotView::SceneGeometryHash() const
+	{
+		// 外观样式不参与；各网格的幅值范围也不参与（那由逐网格图层指纹负责，
+		// 这样拖拽时的纵向分量不会把整幅重绘的快路径打掉）。
+		return SceneContentHash(false, true, false);
+	}
+
+	std::uint64_t PlotView::SceneDecorHash() const
+	{
+		// 装饰层（图例 + Y 轴刻度）的指纹：含外观样式，但**不含派生曲线参数**
+		//（拖弱峰调整等级/迭代次数滑块时图例与刻度不变，装饰层缓存不应失效）。
+		return SceneContentHash(true, false);
+	}
+
+	void PlotView::CollectSceneStyles(std::vector<std::vector<SceneStyleEntry>>& out) const
+	{
+		out.clear();
+		out.resize(m_lanes.size());
+		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
+		{
+			const std::vector<SignalRef>& signals = Tab().Lanes()[laneIndex].signals;
+			std::vector<SceneStyleEntry>& lane = out[laneIndex];
+			lane.reserve(signals.size());
+			for (const SignalRef& ref : signals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				SceneStyleEntry entry;
+				if (resolved.style != nullptr)
+				{
+					entry.color = resolved.style->color;
+					entry.opacity = resolved.style->opacity;
+					entry.lineWidth = resolved.style->lineWidth;
+					entry.mode = static_cast<int>(resolved.style->mode);
+					entry.gain = resolved.style->gain;
+					entry.absolute = resolved.style->absolute;
+					entry.mirrorVertical = resolved.style->mirrorVertical;
+					entry.mirrorHorizontal = resolved.style->mirrorHorizontal;
+					entry.offsetY = resolved.style->offsetY;
+					entry.offsetTime = resolved.style->offsetTime;
+				}
+				lane.push_back(entry);
+			}
+		}
+	}
+
+	bool PlotView::FindStyleOnlyLanes(std::vector<int>& lanes) const
+	{
+		lanes.clear();
+		if (!m_sceneValid || m_sceneGeometryHash != SceneGeometryHash())
+		{
+			// 网格结构 / 视图几何 / 信号集合 / 图例文案有变化：必须整幅重绘。
+			return false;
+		}
+
+		// ⚠️ **必须额外确认“视图几何与缓存完全一致”**：`SceneGeometryHash()` 刻意不含视界，
+		// 所以它相等**并不能**说明视图没变。若视界已经变了还走“只重画受影响网格”的局部补丁，
+		// 就会把缓存里**旧视界**的画面（时间轴、其它网格、底色）留在屏上 —— 表现为用户反馈的
+		// “拖影 / 残留 / 错误元素”。因此这里逐项比较除内容指纹之外的缓存键。
+		{
+			const SceneCacheKey key = MakeSceneCacheKey();
+			if (key.viewMin != m_sceneKey.viewMin || key.viewMax != m_sceneKey.viewMax ||
+			    key.laneScroll != m_sceneKey.laneScroll || key.laneCount != m_sceneKey.laneCount ||
+			    key.areaX != m_sceneKey.areaX || key.areaY != m_sceneKey.areaY ||
+			    key.areaW != m_sceneKey.areaW || key.areaH != m_sceneKey.areaH ||
+			    key.scale != m_sceneKey.scale || key.haloGroup != m_sceneKey.haloGroup ||
+			    key.haloSignal != m_sceneKey.haloSignal)
+			{
+				return false;
+			}
+		}
+
+		std::vector<std::vector<SceneStyleEntry>> current;
+		CollectSceneStyles(current);
+		if (current.size() != m_sceneStyles.size())
+		{
+			return false;
+		}
+
+		// 叠加预览曲线（均值滤波 / 中心轴 / 弱峰调整）的参数变化同样只需局部重画。
+		std::vector<SceneDerivedEntry> currentDerived;
+		CollectSceneDerived(currentDerived);
+		const bool derivedComparable = (currentDerived.size() == m_sceneDerived.size());
+
+		for (std::size_t laneIndex = 0; laneIndex < current.size(); ++laneIndex)
+		{
+			const std::vector<SceneStyleEntry>& now = current[laneIndex];
+			const std::vector<SceneStyleEntry>& before = m_sceneStyles[laneIndex];
+			if (now.size() != before.size())
+			{
+				return false;
+			}
+			bool differs = false;
+			for (std::size_t index = 0; index < now.size() && !differs; ++index)
+			{
+				differs = (now[index].color != before[index].color) ||
+				          (now[index].opacity != before[index].opacity) ||
+				          (now[index].lineWidth != before[index].lineWidth) ||
+				          (now[index].mode != before[index].mode);
+			}
+			if (!differs && derivedComparable)
+			{
+				const SceneDerivedEntry& nowDerived = currentDerived[laneIndex];
+				const SceneDerivedEntry& beforeDerived = m_sceneDerived[laneIndex];
+				differs = (nowDerived.edgeCenter != beforeDerived.edgeCenter) ||
+				          (nowDerived.meanFilter != beforeDerived.meanFilter) ||
+				          (nowDerived.weakPeak != beforeDerived.weakPeak) ||
+				          (nowDerived.edgeCenterItems != beforeDerived.edgeCenterItems) ||
+				          (nowDerived.meanFilterItems != beforeDerived.meanFilterItems) ||
+				          (nowDerived.weakPeakItems != beforeDerived.weakPeakItems);
+			}
+			if (differs)
+			{
+				lanes.push_back(static_cast<int>(laneIndex));
+			}
+		}
+		return !lanes.empty();
+	}
+
+	void PlotView::CollectSceneDerived(std::vector<SceneDerivedEntry>& out) const
+	{
+		out.clear();
+		out.resize(m_lanes.size());
+		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
+		{
+			const Lane& lane = Tab().Lanes()[laneIndex];
+			SceneDerivedEntry entry;
+			entry.edgeCenter = lane.edgeCenter ? 1 : 0;
+			entry.meanFilter = lane.meanFilter ? 1 : 0;
+			entry.weakPeak = lane.weakPeak ? 1 : 0;
+			const auto flatten = [](const auto& items, std::vector<int>& target, auto valueOf)
+			{
+				target.clear();
+				target.reserve(items.size() * 4);
+				for (const auto& item : items)
+				{
+					target.push_back(item.ref.groupIndex);
+					target.push_back(item.ref.signalIndex);
+					// 均值滤波/中心轴取 points，弱峰调整取 amountPercent（由 `valueOf` 决定）。
+					target.push_back(static_cast<int>(valueOf(item)));
+					target.push_back(item.iterations);
+				}
+			};
+			flatten(lane.edgeCenterItems, entry.edgeCenterItems,
+			        [](const Lane::EdgeCenterItem& item) { return item.points; });
+			flatten(lane.meanFilterItems, entry.meanFilterItems,
+			        [](const Lane::MeanFilterItem& item) { return item.points; });
+			flatten(lane.weakPeakItems, entry.weakPeakItems,
+			        [](const Lane::WeakPeakItem& item) { return item.amountPercent; });
+			out[laneIndex] = std::move(entry);
+		}
+	}
+
+	void PlotView::RepaintSceneCachePatch(gd::Graphics& g, const std::vector<int>& lanes)
+	{
+		if (lanes.empty() || m_sceneDc == nullptr)
+		{
+			return;
+		}
+
+		// 重画范围 = 受影响网格与绘图区的交集（并且不超出缓存区域）。
+		float top = 1.0e9f;
+		float bottom = -1.0e9f;
+		for (const int laneIndex : lanes)
+		{
+			if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+			{
+				continue;
+			}
+			const gd::RectF& rect = m_lanes[static_cast<std::size_t>(laneIndex)].rect;
+			top = std::min(top, rect.Y);
+			bottom = std::max(bottom, rect.Y + rect.Height);
+		}
+		if (bottom <= top)
+		{
+			return;
+		}
+		top = std::max(top, m_plotRect.Y);
+		bottom = std::min(bottom, m_plotRect.Y + m_plotRect.Height);
+		if (bottom <= top)
+		{
+			return;
+		}
+
+		// ⚠️ 补丁矩形必须**向内**对齐到整数像素（ceil 上边界、floor 下边界）：
+		// 网格矩形是浮点数，而 GDI `FillRect`/`BitBlt` 会按 floor/ceil 向外取整，
+		// "向外"会多擦掉/多写回一整行，那一行属于相邻网格（例如它的分界线），
+		// 于是补丁边界上会留下一像素接缝。向内对齐后，边界外的行一律由缓存提供
+		// （缓存内容与整幅重绘逐像素一致，已由对照帧验证）。
+		const int x0 = std::max(static_cast<int>(std::ceil(m_area.X)), static_cast<int>(std::ceil(m_area.X)));
+		const int y0 = std::max(static_cast<int>(std::ceil(top)), static_cast<int>(std::ceil(m_area.Y)));
+		const int x1 = std::min(static_cast<int>(std::floor(m_area.X + m_area.Width)),
+		                        static_cast<int>(std::floor(m_area.X + m_area.Width)));
+		const int y1 = std::min(static_cast<int>(std::floor(bottom)),
+		                        static_cast<int>(std::floor(m_area.Y + m_area.Height)));
+		if (x1 <= x0 || y1 <= y0)
+		{
+			return;
+		}
+
+		const gd::RectF patch(static_cast<float>(x0), static_cast<float>(y0),
+		                      static_cast<float>(x1 - x0), static_cast<float>(y1 - y0));
+
+		// 补丁区域必须被**完整**重画：凡是与它相交的网格都要重画一遍
+		// （补丁已向内对齐，正常只会命中受影响的那几个网格）。
+		std::vector<int> repaint;
+		for (std::size_t laneIndex = 0; laneIndex < m_lanes.size(); ++laneIndex)
+		{
+			const gd::RectF& rect = m_lanes[laneIndex].rect;
+			if (rect.Y < static_cast<float>(y1) && rect.Y + rect.Height > static_cast<float>(y0))
+			{
+				repaint.push_back(static_cast<int>(laneIndex));
+			}
+		}
+		if (repaint.empty())
+		{
+			return;
+		}
+
+		// 与整幅重绘保持完全相同的绘制顺序：底色 → 逐网格内容（PaintLane 会与当前裁剪区求交）。
+		{
+			const int saveState = g.Save();
+			g.SetClip(patch, gd::CombineModeIntersect);
+			// ⚠️ 底色填充必须**按补丁矩形本身**填充，不能用 m_area / m_plotRect：
+			// `UiFillRect` 对大面积不透明矩形会走 GDI `FillRect` 快路径，而 GDI 绘制
+			// **不受 GDI+ 裁剪区约束**，会把已经贴好的缓存内容整片覆盖掉。
+			UiFillRect(g, patch, m_theme->plotBg);
+			const float cardTop = std::max(patch.Y, m_plotRect.Y);
+			const float cardBottom = std::min(patch.Y + patch.Height, m_plotRect.Y + m_plotRect.Height);
+			if (cardBottom > cardTop)
+			{
+				UiFillRect(g, gd::RectF(patch.X, cardTop, patch.Width, cardBottom - cardTop),
+				           m_theme->cardBg);
+			}
+
+			const double viewMin = Tab().ViewMin();
+			const double viewMax = Tab().ViewMax();
+			const double span = viewMax - viewMin;
+			const double timeStep = NiceStep((span > 0.0) ? span : 1.0, kTimeTickTarget);
+			std::vector<double> timeTicks;
+			BuildTicks(viewMin, viewMax, timeStep, timeTicks);
+
+			// ⚠️ **补丁必须就地绘制装饰**（而不是"跳过装饰"）：补丁范围覆盖整个受影响网格
+			// （含网格左缘的 Y 轴胶囊与图例），若跳过绘制，这部分像素会被网格底色/波形覆盖，
+			// 而补丁结果还会写回场景缓存 —— 表现为"改样式时图例/Y 轴读数闪掉一下"。
+			const bool savedUseDecorCache = m_useDecorCache;
+			m_useDecorCache = false;
+			for (const int laneIndex : repaint)
+			{
+				if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()))
+				{
+					PaintLane(g, laneIndex, m_lanes[static_cast<std::size_t>(laneIndex)], timeTicks);
+				}
+			}
+			m_useDecorCache = savedUseDecorCache;
+			g.Restore(saveState);
+		}
+
+		// 把重画结果写回缓存位图，使缓存与当前样式一致（下一帧即回到"完全命中"快路径）。
+		{
+			HDC target = g.GetHDC();
+			if (target != nullptr)
+			{
+				BitBlt(m_sceneDc, x0 - m_sceneX, y0 - m_sceneY, x1 - x0, y1 - y0, target, x0, y0, SRCCOPY);
+				g.ReleaseHDC(target);
+			}
+		}
+
+		m_sceneKey = MakeSceneCacheKey();
+		m_sceneGeometryHash = SceneGeometryHash();
+		CollectSceneStyles(m_sceneStyles);
+		CollectSceneDerived(m_sceneDerived);
+		m_sceneDegraded = m_sceneDegraded || m_fastFrame;
+	}
+
+	gd::RectF PlotView::LaneBadgeRect(int laneIndex) const
+	{
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return gd::RectF();
+		}
+		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
+		const gd::RectF legendBand(lane.rect.X + kLegendPad * m_scale, lane.rect.Y + kLegendPad * m_scale,
+		                           lane.rect.Width, kLegendHeight * m_scale);
+		// 网格被滚动出可视区时没有徽标可点。
+		const float visibleTop = std::max(lane.rect.Y, m_plotRect.Y);
+		const float visibleBottom =
+		    std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height);
+		if (!IsFullyVisible(legendBand, visibleTop, visibleBottom))
+		{
+			return gd::RectF();
+		}
+
+		const float height = kLegendHeight * m_scale;
+		const float badgeHeight = kLaneBadgeHeight * m_scale;
+		return gd::RectF(legendBand.X, legendBand.Y + (height - badgeHeight) * 0.5f,
+		                 kLaneBadgeWidth * m_scale, badgeHeight);
+	}
+
+	void PlotView::PaintLaneReorder(gd::Graphics& g)
+	{
+		if (m_dragMode != PlotDragMode::LANE_REORDER || m_laneDragFrom < 0 || m_sceneDc == nullptr ||
+		    m_lanes.empty())
+		{
+			return;
+		}
+
+		const float laneHeight = m_lanes.front().rect.Height;
+		if (!(laneHeight > 0.0f))
+		{
+			return;
+		}
+
+		// 1) 先把整个绘图区（含时间轴）从静态场景缓存贴回：网格次序拖拽只改变网格内部的
+		//    条带位置，时间轴/边框等内容必须原样保留，否则鼠标拖到工具栏或时间轴上时
+		//    那一区域会残留上一帧的内容。
+		if (!BlitSceneCache(g))
+		{
+			return;
+		}
+
+		// 2) 把"网格区域"整片铺成绘图区底色：让位留下的空档就是它的原色，
+		//    网格线/波形随后按各自位移贴回。
+		UiFillRect(g, m_plotRect, m_theme->cardBg);
+
+		HDC target = g.GetHDC();
+		if (target == nullptr)
+		{
+			return;
+		}
+
+		// 逐网格把缓存中该网格的横向条带按位移贴到屏幕上（非常廉价，整幅波形不必重绘）。
+		// 被拖拽的网格最后贴，因此始终压在最上层，形成"被拎起来"的观感。
+		std::vector<int> laneOrder;
+		for (int index = 0; index < static_cast<int>(m_lanes.size()); ++index)
+		{
+			if (index != m_laneDragFrom)
+			{
+				laneOrder.push_back(index);
+			}
+		}
+		if (m_laneDragFrom < static_cast<int>(m_lanes.size()))
+		{
+			laneOrder.push_back(m_laneDragFrom);
+		}
+
+		for (const int index : laneOrder)
+		{
+			const gd::RectF& rect = m_lanes[static_cast<std::size_t>(index)].rect;
+			const float offset = LaneDragOffset(index);
+			// 源：缓存中该网格的条带；目标：屏幕上的同一条带平移 offset。
+			const float sourceTop = rect.Y;
+			const float destTop = rect.Y + offset;
+			// 与绘图区求交（并夹进缓存区域），避免把波形贴到工具栏或时间轴上。
+			const float clipTop = std::max(std::max(destTop, m_plotRect.Y), m_plotRect.Y);
+			const float clipBottom =
+			    std::min(std::min(destTop + rect.Height, m_plotRect.Y + m_plotRect.Height),
+			             m_plotRect.Y + m_plotRect.Height);
+			if (clipBottom - clipTop < 1.0f)
+			{
+				continue;
+			}
+
+			const int x = static_cast<int>(std::floor(rect.X));
+			const int width = static_cast<int>(std::ceil(rect.X + rect.Width)) - x;
+			const int y0 = static_cast<int>(std::ceil(clipTop));
+			const int y1 = static_cast<int>(std::floor(clipBottom));
+			if (y1 <= y0 || width <= 0)
+			{
+				continue;
+			}
+
+			const int sourceY = static_cast<int>(std::lround(sourceTop + (static_cast<float>(y0) - destTop)));
+			BitBlt(target, x, y0, width, y1 - y0, m_sceneDc, x - m_sceneX, sourceY - m_sceneY, SRCCOPY);
+		}
+		g.ReleaseHDC(target);
+
+		// 3) 目标位置的高亮提示与被拖网格的轮廓都**必须夹在网格区域内**绘制：
+		//    鼠标拖到工具栏/时间轴上时，若不裁剪，强调色边框会画到那些区域上。
+		{
+			const int clipState = g.Save();
+			g.SetClip(m_plotRect, gd::CombineModeIntersect);
+
+			// 目标位置的高亮提示（吸附提示）：在被拖网格将要落到的槽位上画一层强调色底 + 边框。
+			const int dropSlot = (m_laneDragTarget >= 0) ? m_laneDragTarget : m_laneDragFrom;
+			float slotTop = m_lanes.front().rect.Y + static_cast<float>(dropSlot) * laneHeight;
+			if (dropSlot > m_laneDragFrom)
+			{
+				slotTop -= laneHeight;
+			}
+			const gd::RectF slot(m_plotRect.X, slotTop, m_plotRect.Width, laneHeight);
+			if (slot.Height > 0.0f)
+			{
+				UiFillRect(g, slot, WithAlpha(m_theme->accent, 0x1E));
+				UiDrawRoundRect(g, gd::RectF(slot.X + 1.0f * m_scale, slot.Y + 1.0f * m_scale,
+				                             slot.Width - 2.0f * m_scale, slot.Height - 2.0f * m_scale),
+				                3.0f * m_scale, m_theme->accent, 1.6f * m_scale);
+			}
+
+			// 被拖网格的轮廓：加强"整块网格被拎起"的观感。
+			const gd::RectF& dragged = m_lanes[static_cast<std::size_t>(m_laneDragFrom)].rect;
+			const float destTop = dragged.Y + LaneDragOffset(m_laneDragFrom);
+			const gd::RectF outline(dragged.X + 1.0f * m_scale, destTop + 1.0f * m_scale,
+			                        dragged.Width - 2.0f * m_scale, dragged.Height - 2.0f * m_scale);
+			UiFillRoundRect(g, gd::RectF(outline.X + 2.0f * m_scale, outline.Y + 3.0f * m_scale,
+			                             outline.Width, outline.Height),
+			                3.0f * m_scale, 0x22000000u);
+			UiDrawRoundRect(g, outline, 3.0f * m_scale, m_theme->accent, 1.8f * m_scale);
+			g.Restore(clipState);
+		}
+	}
+
+	bool PlotView::EnsureSceneCache(int width, int height)
+	{
+		if (width <= 0 || height <= 0)
+		{
+			return false;
+		}
+		// 位图尺寸必须与当前缓存区域**严格一致**：贴图时按位图尺寸整块拷贝，
+		// 若沿用更大的旧位图，缩小窗口后会把旧像素画到绘图区之外。
+		if (m_sceneDc != nullptr && m_sceneWidth == width && m_sceneHeight == height)
+		{
+			return true;
+		}
+
+		ReleaseSceneCache();
+		// 场景位图重建 → 面板图层里缓存的"面板背后的场景"随之失效。
+		m_panelValid = false;
+
+		HDC screen = GetDC(nullptr);
+		if (screen == nullptr)
+		{
+			return false;
+		}
+		m_sceneDc = CreateCompatibleDC(screen);
+		m_sceneBitmap = CreateCompatibleBitmap(screen, width, height);
+		ReleaseDC(nullptr, screen);
+
+		if (m_sceneDc == nullptr || m_sceneBitmap == nullptr)
+		{
+			ReleaseSceneCache();
+			return false;
+		}
+		m_sceneOldBitmap = SelectObject(m_sceneDc, m_sceneBitmap);
+		m_sceneWidth = width;
+		m_sceneHeight = height;
+		return true;
+	}
+
+	bool PlotView::CaptureSceneCache(gd::Graphics& g)
+	{
+		// 缓存区域严格限定为绘图区本身（m_area）：工具栏/标签栏/面板由宿主每帧绘制，
+		// 因为它们各自带有悬停态；绘图区的波形才是真正昂贵的部分（大文件约 80ms/帧）。
+		const int x = static_cast<int>(std::floor(m_area.X));
+		const int y = static_cast<int>(std::floor(m_area.Y));
+		const int right = static_cast<int>(std::ceil(m_area.X + m_area.Width));
+		const int bottom = static_cast<int>(std::ceil(m_area.Y + m_area.Height));
+		const int width = right - x;
+		const int height = bottom - y;
+		if (width <= 0 || height <= 0)
+		{
+			m_sceneValid = false;
+			return false;
+		}
+
+		m_sceneX = x;
+		m_sceneY = y;
+
+		if (!EnsureSceneCache(width, height))
+		{
+			m_sceneValid = false;
+			return false;
+		}
+
+		HDC source = g.GetHDC();
+		if (source == nullptr)
+		{
+			m_sceneValid = false;
+			return false;
+		}
+		const BOOL ok = BitBlt(m_sceneDc, 0, 0, width, height, source, m_sceneX, m_sceneY, SRCCOPY);
+		g.ReleaseHDC(source);
+
+		if (ok == FALSE)
+		{
+			m_sceneValid = false;
+			return false;
+		}
+
+		m_sceneKey = MakeSceneCacheKey();
+		m_sceneGeometryHash = SceneGeometryHash();
+		CollectSceneStyles(m_sceneStyles);
+		CollectSceneDerived(m_sceneDerived);
+		m_sceneDegraded = false;
+		m_sceneValid = true;
+		return true;
+	}
+
+	bool PlotView::BlitSceneCache(gd::Graphics& g)
+	{
+		if (!m_sceneValid || m_sceneDc == nullptr)
+		{
+			return false;
+		}
+
+		HDC target = g.GetHDC();
+		if (target == nullptr)
+		{
+			return false;
+		}
+		const BOOL ok = BitBlt(target, m_sceneX, m_sceneY, m_sceneWidth, m_sceneHeight, m_sceneDc, 0, 0,
+		                       SRCCOPY);
+		g.ReleaseHDC(target);
+		return ok != FALSE;
+	}
+
+	void PlotView::InvalidateSceneCache()
+	{
+		m_sceneValid = false;
+		m_sceneStyles.clear();
+		m_sceneDerived.clear();
+		m_sceneDegraded = false;
+		m_sceneGeometryHash = 0;
+		// 面板像素图层与场景缓存同源（面板像素里含"面板背后的场景"）：
+		// 信号增删、重命名、参数变化等一律连带作废，避免面板里残留旧波形。
+		m_panelValid = false;
+	}
+
+	void PlotView::ReleaseSceneCache()
+	{
+		m_sceneValid = false;
+		if (m_sceneDc != nullptr)
+		{
+			if (m_sceneOldBitmap != nullptr)
+			{
+				SelectObject(m_sceneDc, m_sceneOldBitmap);
+				m_sceneOldBitmap = nullptr;
+			}
+			DeleteDC(m_sceneDc);
+			m_sceneDc = nullptr;
+		}
+		if (m_sceneBitmap != nullptr)
+		{
+			DeleteObject(m_sceneBitmap);
+			m_sceneBitmap = nullptr;
+		}
+		m_sceneWidth = 0;
+		m_sceneHeight = 0;
+	}
+
+	bool PlotView::EnsureDecorCache(int width, int height)
+	{
+		if (width <= 0 || height <= 0)
+		{
+			return false;
+		}
+		if (m_decorDc != nullptr && m_decorBits != nullptr && m_decorW == width && m_decorH == height)
+		{
+			return true;
+		}
+		ReleaseDecorCache();
+		HDC screen = GetDC(nullptr);
+		if (screen == nullptr)
+		{
+			return false;
+		}
+		// ⚠️ **必须用 32bpp DIB 段**（而不是 `CreateCompatibleBitmap`）：
+		// 装饰要带真 alpha（圆角之外全透明），才能用 `AlphaBlend` 合成到波形之上；
+		// 同时 DIB 段的像素可直接写（用于 alpha 修补与清空）。
+		BITMAPINFO info = {};
+		info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+		info.bmiHeader.biWidth = width;
+		info.bmiHeader.biHeight = -height;		// 自上而下
+		info.bmiHeader.biPlanes = 1;
+		info.bmiHeader.biBitCount = 32;
+		info.bmiHeader.biCompression = BI_RGB;
+		void* bits = nullptr;
+		HBITMAP dib = CreateDIBSection(screen, &info, DIB_RGB_COLORS, &bits, nullptr, 0);
+		ReleaseDC(nullptr, screen);
+		if (dib == nullptr || bits == nullptr)
+		{
+			if (dib != nullptr)
+			{
+				DeleteObject(dib);
+			}
+			return false;
+		}
+		HDC dc = CreateCompatibleDC(nullptr);
+		if (dc == nullptr)
+		{
+			DeleteObject(dib);
+			return false;
+		}
+		m_decorOldBitmap = SelectObject(dc, dib);
+		m_decorDc = dc;
+		m_decorBitmap = dib;
+		m_decorBits = bits;
+		m_decorW = width;
+		m_decorH = height;
+		return true;
+	}
+
+	void PlotView::ReleaseDecorCache()
+	{
+		m_decorValid = false;
+		m_decorCapturedRects.clear();
+		if (m_decorDc != nullptr)
+		{
+			if (m_decorOldBitmap != nullptr)
+			{
+				SelectObject(m_decorDc, m_decorOldBitmap);
+				m_decorOldBitmap = nullptr;
+			}
+			DeleteDC(m_decorDc);
+			m_decorDc = nullptr;
+		}
+		if (m_decorBitmap != nullptr)
+		{
+			DeleteObject(m_decorBitmap);
+			m_decorBitmap = nullptr;
+		}
+		m_decorBits = nullptr;
+		m_decorW = 0;
+		m_decorH = 0;
+	}
+
+	void* PlotView::ResolveAlphaBlend()
+	{
+		// `AlphaBlend` 由 msimg32 导出、并由 gdi32 的 `GdiAlphaBlend` 实现；
+		// 两个来源都试一遍，取到即缓存（静态局部变量，仅解析一次）。
+		static void* cached = nullptr;
+		static bool resolved = false;
+		if (resolved)
+		{
+			return cached;
+		}
+		resolved = true;
+		HMODULE gdi = GetModuleHandleW(L"gdi32.dll");
+		if (gdi != nullptr)
+		{
+			cached = reinterpret_cast<void*>(GetProcAddress(gdi, "GdiAlphaBlend"));
+		}
+		if (cached == nullptr)
+		{
+			HMODULE msimg = LoadLibraryW(L"msimg32.dll");
+			if (msimg != nullptr)
+			{
+				cached = reinterpret_cast<void*>(GetProcAddress(msimg, "AlphaBlend"));
+			}
+		}
+		return cached;
+	}
+
+	bool PlotView::RenderDecorCache()
+	{
+		m_decorValid = false;
+		if (m_theme == nullptr || m_fonts == nullptr || m_lanes.empty())
+		{
+			return false;
+		}
+		// 位图覆盖「客户区原点 → 绘图区右下角」：绘制坐标与正常绘制完全一致，
+		// 不需要任何平移（GDI 文本不认 GDI+ 变换，平移会让文字错位）。
+		const int width = static_cast<int>(std::ceil(m_area.X + m_area.Width));
+		const int height = static_cast<int>(std::ceil(m_area.Y + m_area.Height));
+		if (!EnsureDecorCache(width, height))
+		{
+			return false;
+		}
+		// 清空为全透明（圆角之外必须保持透明，贴回时才不会盖住波形）。
+		std::memset(m_decorBits, 0, static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * 4u);
+
+		m_decorRects.clear();
+		{
+			gd::Graphics g(m_decorDc);
+			g.SetSmoothingMode(gd::SmoothingModeAntiAlias);
+			g.SetPixelOffsetMode(gd::PixelOffsetModeHalf);
+			g.SetTextRenderingHint(gd::TextRenderingHintClearTypeGridFit);
+
+			const bool savedUse = m_useDecorCache;
+			m_useDecorCache = false;		// 本次是"真正绘制"：不允许走"跳过绘制"的分支
+			m_renderDecorOnly = true;		// 只画装饰（跳过网格线与波形）
+			const std::vector<double> noTicks;
+			for (std::size_t index = 0; index < m_lanes.size(); ++index)
+			{
+				PaintLane(g, static_cast<int>(index), m_lanes[index], noTicks);
+			}
+			m_renderDecorOnly = false;
+			m_useDecorCache = savedUse;
+		}
+
+		// ⚠️ **alpha 修补**：GDI 的文本绘制（`DrawTextW`）会把它写入的像素 alpha 清成 0
+		// （GDI 不维护 alpha），若原样保留，贴上后文字位置会变成"透明洞"（透出波形）。
+		// 在这里把装饰矩形内"有颜色但 alpha 为 0"的像素还原为不透明即可 —— 装饰本身
+		// 是画在不透明底板上的，这些像素本来就该不透明。
+		for (const gd::RectF& rect : m_decorRects)
+		{
+			const int x0 = std::max(0, static_cast<int>(std::floor(rect.X)));
+			const int y0 = std::max(0, static_cast<int>(std::floor(rect.Y)));
+			const int x1 = std::min(width, static_cast<int>(std::ceil(rect.X + rect.Width)));
+			const int y1 = std::min(height, static_cast<int>(std::ceil(rect.Y + rect.Height)));
+			for (int y = y0; y < y1; ++y)
+			{
+				unsigned char* row = static_cast<unsigned char*>(m_decorBits) +
+				                     (static_cast<std::size_t>(y) * static_cast<std::size_t>(width)) * 4u;
+				for (int x = x0; x < x1; ++x)
+				{
+					unsigned char* p = row + static_cast<std::size_t>(x) * 4u;
+					if (p[3] == 0 && (p[0] | p[1] | p[2]) != 0)
+					{
+						p[3] = 255;
+					}
+				}
+			}
+		}
+
+		m_decorCapturedRects = m_decorRects;
+		m_decorValid = true;
+		return true;
+	}
+
+	bool PlotView::BlitDecorCache(gd::Graphics& g)
+	{
+		if (!m_decorValid || m_decorDc == nullptr || m_decorCapturedRects.empty())
+		{
+			return false;
+		}
+		void* proc = ResolveAlphaBlend();
+		if (proc == nullptr)
+		{
+			return false;		// 极小概率：系统不提供 AlphaBlend（贴回会带透明洞，故直接放弃）
+		}
+		using AlphaBlendFn = BOOL(WINAPI*)(HDC, int, int, int, int, HDC, int, int, int, int, BLENDFUNCTION);
+		AlphaBlendFn blend = reinterpret_cast<AlphaBlendFn>(proc);
+		HDC target = g.GetHDC();
+		if (target == nullptr)
+		{
+			return false;
+		}
+		// 装饰位图原点 = 客户区 (0,0)：源坐标与目标坐标**相同**。
+		BLENDFUNCTION fn = {};
+		fn.BlendOp = AC_SRC_OVER;
+		fn.SourceConstantAlpha = 255;
+		fn.AlphaFormat = AC_SRC_ALPHA;		// 源为**预乘** alpha（GDI+ 写入 DIB 段即预乘）
+		bool any = false;
+		for (const gd::RectF& rect : m_decorCapturedRects)
+		{
+			const int x = static_cast<int>(std::floor(rect.X));
+			const int y = static_cast<int>(std::floor(rect.Y));
+			const int w = static_cast<int>(std::ceil(rect.X + rect.Width)) - x;
+			const int h = static_cast<int>(std::ceil(rect.Y + rect.Height)) - y;
+			if (w <= 0 || h <= 0)
+			{
+				continue;
+			}
+			if (blend(target, x, y, w, h, m_decorDc, x, y, w, h, fn) != FALSE)
+			{
+				any = true;
+			}
+		}
+		g.ReleaseHDC(target);
+		return any;
+	}
+
+	bool PlotView::EnsureLaneLayer(LaneLayer& layer, int width, int height)
+	{
+		if (width <= 0 || height <= 0)
+		{
+			return false;
+		}
+		if (layer.dc != nullptr && layer.width == width && layer.height == height)
+		{
+			return true;
+		}
+		ReleaseLaneLayer(layer);
+		HDC screen = GetDC(nullptr);
+		if (screen == nullptr)
+		{
+			return false;
+		}
+		layer.dc = CreateCompatibleDC(screen);
+		layer.bitmap = CreateCompatibleBitmap(screen, width, height);
+		ReleaseDC(nullptr, screen);
+		if (layer.dc == nullptr || layer.bitmap == nullptr)
+		{
+			ReleaseLaneLayer(layer);
+			return false;
+		}
+		layer.oldBitmap = SelectObject(layer.dc, layer.bitmap);
+		layer.width = width;
+		layer.height = height;
+		layer.valid = false;
+		return true;
+	}
+
+	void PlotView::ReleaseLaneLayer(LaneLayer& layer)
+	{
+		layer.valid = false;
+		if (layer.dc != nullptr)
+		{
+			if (layer.oldBitmap != nullptr)
+			{
+				SelectObject(layer.dc, layer.oldBitmap);
+				layer.oldBitmap = nullptr;
+			}
+			DeleteDC(layer.dc);
+			layer.dc = nullptr;
+		}
+		if (layer.bitmap != nullptr)
+		{
+			DeleteObject(layer.bitmap);
+			layer.bitmap = nullptr;
+		}
+		layer.width = 0;
+		layer.height = 0;
+	}
+
+	void PlotView::ReleaseWideBuffer()
+	{
+		std::lock_guard<std::mutex> lock(m_layerMutex);
+		for (LaneLayer& layer : m_layerFront)
+		{
+			ReleaseLaneLayer(layer);
+		}
+		m_layerFront.clear();
+		m_layerRebuildPending.clear();
+	}
+
+	void PlotView::InvalidateWideBuffer()
+	{
+		std::lock_guard<std::mutex> lock(m_layerMutex);
+		for (LaneLayer& layer : m_layerFront)
+		{
+			layer.valid = false;
+		}
+		m_layerRebuildPending.clear();
+	}
+
+	std::uint64_t PlotView::LaneLayerKey(int laneIndex) const
+	{
+		// 图层只含基底（不含派生曲线与装饰），因此指纹 = **该网格自己的内容**
+		// ⊕ 网格下标 ⊕ 视界跨度 ⊕ 绘图区宽度（决定像素/时间与位图尺寸）。
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		std::uint64_t key = LaneLayerHash(laneIndex);
+		key ^= static_cast<std::uint64_t>(laneIndex + 1) * 1315423911ull;
+		key *= 1099511628211ull;
+		key ^= static_cast<std::uint64_t>(std::llround(span * 1.0e6));
+		key *= 1099511628211ull;
+		key ^= static_cast<std::uint64_t>(std::llround(m_plotRect.Width));
+		return key;
+	}
+
+	std::uint64_t PlotView::LaneLayerHash(int laneIndex) const
+	{
+		// 单个网格图层的内容 = 位图高度（= 网格高度）+ 幅值**跨度** + 本网格各信号的
+		// 可见性与外观 + 图例文案（图例不在图层里，但一起计入无妨且更安全）。
+		//
+		// ⚠️ **只计跨度、不计幅值的绝对范围**：图层的纵向锚点（`anchorYMax`）与 `wideMin`
+		// 一样是"贴图偏移"的来源，幅值整体平移不改变图层内容（只是贴图时纵向偏移若干像素），
+		// 因此纵向拖动不会让图层失效。真正改变内容的是**跨度**（决定像素/数值与刻度步长）。
+		std::uint64_t hash = 1469598103934665603ull;
+		const auto mix = [&hash](std::uint64_t value)
+		{
+			hash ^= value;
+			hash *= 1099511628211ull;
+		};
+		const auto mixFloat = [&mix](float value)
+		{
+			std::uint32_t bits = 0;
+			std::memcpy(&bits, &value, sizeof(bits));
+			mix(bits);
+		};
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return hash;
+		}
+		const LaneVisual& visual = m_lanes[static_cast<std::size_t>(laneIndex)];
+		mixFloat(visual.rect.Height);
+		mixFloat(static_cast<float>(visual.yMax - visual.yMin));
+		const std::vector<SignalRef>& signals = Tab().Lanes()[static_cast<std::size_t>(laneIndex)].signals;
+		mix(signals.size());
+		for (const SignalRef& ref : signals)
+		{
+			const ResolvedSignal resolved = ResolveSignal(ref);
+			mix(static_cast<std::uint64_t>(ref.groupIndex));
+			mix(static_cast<std::uint64_t>(ref.signalIndex));
+			mix(resolved.visible ? 1ull : 0ull);
+			if (resolved.data == nullptr || resolved.style == nullptr)
+			{
+				continue;
+			}
+			mix(static_cast<std::uint64_t>(resolved.style->color));
+			mixFloat(resolved.style->opacity);
+			mixFloat(resolved.style->lineWidth);
+			mix(static_cast<std::uint64_t>(resolved.style->mode));
+			// 「调整」变换会改变图层里的波形，也必须让图层失效
+			//（否则贴回的旧像素会与当前样式不一致）。
+			mixFloat(resolved.style->gain);
+			mix(resolved.style->absolute ? 1ull : 0ull);
+			mix(resolved.style->mirrorVertical ? 1ull : 0ull);
+			mix(resolved.style->mirrorHorizontal ? 1ull : 0ull);
+			mixFloat(resolved.style->offsetY);
+			mixFloat(static_cast<float>(resolved.style->offsetTime));
+		}
+		return hash;
+	}
+
+	int PlotView::LayerMarginX() const
+	{
+		const int width = static_cast<int>(std::lround(m_plotRect.Width));
+		return std::max(1, width / 2);		// 左右各半屏
+	}
+
+	int PlotView::LayerMarginY(float laneHeight) const
+	{
+		// 上下各半个网格高：一整屏的额外内容已足够覆盖实际拖拽范围，
+		// 又不至于让每个横向补条 / 整块重画按三倍高度放大（横向平移因此不受影响）。
+		const int half = static_cast<int>(std::lround(static_cast<double>(laneHeight) * 0.5));
+		return std::max(1, half);
+	}
+
+	double PlotView::LayerDefaultWideMin() const
+	{
+		// 以当前视界为中心：位图左右各留半个视界宽，因此可向两侧平移 ±半屏。
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		const int width = static_cast<int>(std::lround(m_plotRect.Width));
+		if (!(span > 0.0) || width <= 0)
+		{
+			return Tab().ViewMin();
+		}
+		const double scale = static_cast<double>(width) / span;
+		return Tab().ViewMin() - static_cast<double>(LayerMarginX()) / scale;
+	}
+
+	bool PlotView::LayersStructurallyReady() const
+	{
+		std::lock_guard<std::mutex> lock(m_layerMutex);
+		if (m_layerFront.size() != m_lanes.size() || m_layerFront.empty())
+		{
+			return false;
+		}
+		const float plotWidth = m_plotRect.Width;
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(plotWidth > 8.0f) || !(span > 0.0))
+		{
+			return false;
+		}
+		const int width = static_cast<int>(std::lround(plotWidth));
+		const int bitmapWidth = width + 2 * LayerMarginX();
+		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
+		{
+			const LaneLayer& layer = m_layerFront[index];
+			if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth)
+			{
+				return false;
+			}
+			// 跨度必须一致：跨度变了像素/时间的映射就不同，旧像素不能再当“坐标偏移”用。
+			if (std::fabs(span - layer.span) > 1.0e-12)
+			{
+				return false;
+			}
+			// 高度也要一致：网格高度变化会让贴图纵向错位（含上下预渲染余量）。
+			const float laneHeight = m_lanes[index].rect.Height;
+			const int bitmapHeight =
+			    static_cast<int>(std::ceil(laneHeight)) + 2 * LayerMarginY(laneHeight);
+			if (layer.height != bitmapHeight)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	bool PlotView::LayersAllocated() const
+	{
+		std::lock_guard<std::mutex> lock(m_layerMutex);
+		return !m_layerFront.empty() && m_layerFront.size() == m_lanes.size();
+	}
+
+	bool PlotView::LaneLayerReady(int laneIndex) const
+	{
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return false;
+		}
+		std::lock_guard<std::mutex> lock(m_layerMutex);
+		if (laneIndex >= static_cast<int>(m_layerFront.size()))
+		{
+			return false;
+		}
+		const LaneLayer& layer = m_layerFront[static_cast<std::size_t>(laneIndex)];
+		const float plotWidth = m_plotRect.Width;
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(plotWidth > 8.0f) || !(span > 0.0))
+		{
+			return false;
+		}
+		const int width = static_cast<int>(std::lround(plotWidth));
+		const int bitmapWidth = width + 2 * LayerMarginX();
+		const float laneHeight = m_lanes[static_cast<std::size_t>(laneIndex)].rect.Height;
+		const int bitmapHeight = static_cast<int>(std::ceil(laneHeight)) + 2 * LayerMarginY(laneHeight);
+		if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth ||
+		    layer.height != bitmapHeight || std::fabs(layer.span - span) > 1.0e-12)
+		{
+			return false;
+		}
+		return layer.key == LaneLayerKey(laneIndex);
+	}
+
+	bool PlotView::LanesAllReadyForView() const
+	{
+		if (m_lanes.empty())
+		{
+			return false;
+		}
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			if (!LaneLayerReady(static_cast<int>(index)))
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	void PlotView::QueueLaneRebuild(int laneIndex)
+	{
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return;
+		}
+		for (const int existing : m_layerRebuildPending)
+		{
+			if (existing == laneIndex)
+			{
+				return;		// 已经在队列里
+			}
+		}
+		m_layerRebuildPending.push_back(laneIndex);
+	}
+
+	bool PlotView::RenderPendingLaneRebuilds(int budget)
+	{
+		if (m_layerRebuildPending.empty() || budget <= 0)
+		{
+			return !m_layerRebuildPending.empty();
+		}
+		const double defaultWideMin = LayerDefaultWideMin();
+		// 本批要重画的网格：`budget` 足够大时一次取完（视界已停时调用方会传很大的预算）。
+		const int available = static_cast<int>(m_layerRebuildPending.size());
+		const int take = std::min(budget, available);
+		std::vector<int> batch;
+		batch.reserve(static_cast<std::size_t>(take));
+		for (int index = 0; index < take; ++index)
+		{
+			const int laneIndex = m_layerRebuildPending[static_cast<std::size_t>(index)];
+			if (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()))
+			{
+				batch.push_back(laneIndex);
+			}
+		}
+		m_layerRebuildPending.erase(m_layerRebuildPending.begin(),
+		                            m_layerRebuildPending.begin() + take);
+
+		if (batch.size() > 1)
+		{
+			// **多网格一次补齐**：并行渲染（各网格用隔离上下文），比"一帧只补 1 个"收敛快 N 倍。
+			RebuildLaneLayersParallel(batch, defaultWideMin);
+		}
+		else
+		{
+			for (const int laneIndex : batch)
+			{
+				// 加锁顺序与前台一致：先 `m_renderMutex` 再 `m_layerMutex`。
+				std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+				std::lock_guard<std::mutex> layerLock(m_layerMutex);
+				if (m_layerFront.size() != m_lanes.size())
+				{
+					break;
+				}
+				LaneLayer& layer = m_layerFront[static_cast<std::size_t>(laneIndex)];
+				// ⚠️ **跨度过期（缩放瞬间）也在这里就地整块重画**（按**新跨度**）。
+				// 旧实现遇到跨度不符就 `continue`（把该网格推给"下一次整批重建"），
+				// 而"整批重建"正是那个 70~80ms 的同步卡顿源；现在改为一帧补一个网格，
+				// 其余网格由 `BlitWideBuffer` 的占位拉伸顶着 → 前台永不因图层未就绪而滞后。
+				// 整块重画：整个图层都对齐到"当前 `yMax`"（锚点 = 当前 yMax）。
+				if (!RenderLaneLayerRegion(laneIndex, layer, 0, 0, 0, 0, defaultWideMin,
+				                           m_lanes[static_cast<std::size_t>(laneIndex)].yMax))
+				{
+					continue;
+				}
+			}
+		}
+		return !m_layerRebuildPending.empty();
+	}
+
+	void PlotView::EnsureLayerWorkers()
+	{
+		unsigned int hardware = std::thread::hardware_concurrency();
+		const int want = std::max(1, std::min(static_cast<int>(hardware == 0 ? 2u : hardware), 4));
+		if (m_layerWorkerCount == want && static_cast<int>(m_layerWorkers.size()) == want)
+		{
+			// 字体 / 主题 / 缩放 / 数据源可能已变化：刷新一次绑定（不重建线程上下文）。
+			for (int index = 0; index < want; ++index)
+			{
+				m_layerWorkers[static_cast<std::size_t>(index)]->Setup(m_fonts, m_theme);
+				m_layerWorkers[static_cast<std::size_t>(index)]->SetScale(m_scale);
+				m_layerWorkers[static_cast<std::size_t>(index)]->m_dataSet = m_dataSet;
+				m_layerWorkers[static_cast<std::size_t>(index)]->m_dataSetWritable = m_dataSetWritable;
+			}
+			return;
+		}
+		ReleaseLayerWorkers();
+		m_layerWorkers.reserve(static_cast<std::size_t>(want));
+		for (int index = 0; index < want; ++index)
+		{
+			auto worker = std::make_unique<PlotView>();
+			worker->Setup(m_fonts, m_theme);
+			worker->SetScale(m_scale);
+			// ⚠️ `m_tab` 置空 → worker 的 `Tab()` 返回它**自带的** `m_localTab` 副本，
+			// 于是它改写视界 / 网格矩形时不会碰到共享的标签页配置（安全并行的前提）。
+			worker->m_dataSet = m_dataSet;
+			worker->m_dataSetWritable = m_dataSetWritable;
+			// ⚠️ `m_tab` **必须非空**（`BuildLaneVisuals()` 在空时会清空 `m_lanes`）；
+			// 指向 worker **自有**的 `m_workerTab`，这样它改写视界 / 网格矩形时不会碰到共享标签页。
+			worker->m_tab = &worker->m_workerTab;
+			worker->RefreshLanes();
+			m_layerWorkers.push_back(std::move(worker));
+		}
+		m_layerWorkerCount = want;
+	}
+
+	void PlotView::ReleaseLayerWorkers()
+	{
+		m_layerWorkers.clear();
+		m_layerWorkerCount = 0;
+	}
+
+	void PlotView::RebuildLaneLayersParallel(const std::vector<int>& laneIndices, double wideMin)
+	{
+		if (laneIndices.empty() || m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+		// 单网格 / 单核：直接顺序走既有路径（避免线程开销）。
+		unsigned int hardware = std::thread::hardware_concurrency();
+		if (laneIndices.size() <= 1 || (hardware == 0 ? 2u : hardware) <= 1)
+		{
+			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+			std::lock_guard<std::mutex> layerLock(m_layerMutex);
+			if (m_layerFront.size() != m_lanes.size())
+			{
+				return;
+			}
+			for (const int laneIndex : laneIndices)
+			{
+				if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+				{
+					continue;
+				}
+				RenderLaneLayerRegion(laneIndex, m_layerFront[static_cast<std::size_t>(laneIndex)], 0, 0, 0,
+				                      0, wideMin, m_lanes[static_cast<std::size_t>(laneIndex)].yMax);
+			}
+			return;
+		}
+
+		{
+			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+			std::lock_guard<std::mutex> layerLock(m_layerMutex);
+			if (m_layerFront.size() != m_lanes.size())
+			{
+				return;
+			}
+		}
+		EnsureLayerWorkers();
+		if (m_layerWorkerCount <= 1)
+		{
+			return;	// 保守回退：让调用方走顺序路径
+		}
+
+		// 主线程**先快照**工作线程需要的一切（之后它们只读，不再触碰共享状态）。
+		const TabConfig tabSnapshot = *m_tab;
+		const gd::RectF plotRectSnapshot = m_plotRect;
+		const gd::RectF areaSnapshot = m_area;
+		const float scaleSnapshot = m_scale;
+		const std::vector<LaneVisual> laneSnapshot = m_lanes;
+		// 目标图层位图数组（已确认尺寸与网格数一致，线程内不会扩容）。
+		std::vector<LaneLayer>* const front = &m_layerFront;
+
+		const int workerCount = m_layerWorkerCount;
+		std::atomic<std::size_t> next{0};
+		std::vector<std::thread> threads;
+		threads.reserve(static_cast<std::size_t>(workerCount));
+		for (int workerIndex = 0; workerIndex < workerCount; ++workerIndex)
+		{
+			threads.emplace_back([&, workerIndex]()
+			{
+				PlotView* worker = m_layerWorkers[static_cast<std::size_t>(workerIndex)].get();
+				for (;;)
+				{
+					const std::size_t slot = next.fetch_add(1, std::memory_order_relaxed);
+					if (slot >= laneIndices.size())
+					{
+						break;
+					}
+					const int laneIndex = laneIndices[slot];
+					if (laneIndex < 0 || laneIndex >= static_cast<int>(laneSnapshot.size()) ||
+					    laneIndex >= static_cast<int>(tabSnapshot.Lanes().size()))
+					{
+						continue;
+					}
+					// 隔离上下文：自带标签页副本 + 只含该网格 + 只读的数据源 / 字体 / 主题。
+					worker->m_workerTab = tabSnapshot;
+					worker->m_workerTab.Lanes() = {tabSnapshot.Lanes()[static_cast<std::size_t>(laneIndex)]};
+					worker->m_tab = &worker->m_workerTab;
+					worker->m_fonts = m_fonts;
+					worker->m_theme = m_theme;
+					worker->m_scale = scaleSnapshot;
+					worker->m_dataSet = m_dataSet;
+					worker->m_dataSetWritable = m_dataSetWritable;
+					worker->m_area = areaSnapshot;
+					worker->m_plotRect = plotRectSnapshot;
+					worker->m_lanes = {laneSnapshot[static_cast<std::size_t>(laneIndex)]};
+					// ⚠️ 工作线程用**自己的** `m_workerTab` / `m_area` / `m_plotRect` / `m_lanes` 渲染，
+					// 因此不会与 UI 线程或其它工作线程互相覆盖渲染状态（这正是 2026-10-12 移除
+					// "后台图层线程"的根因）。目标图层位图按 `laneIndex` 各自不同，可并发写入。
+					worker->RenderLaneLayerRegion(0, (*front)[static_cast<std::size_t>(laneIndex)], 0, 0, 0, 0,
+					                              wideMin,
+					                              laneSnapshot[static_cast<std::size_t>(laneIndex)].yMax);
+				}
+			});
+		}
+		for (std::thread& thread : threads)
+		{
+			if (thread.joinable())
+			{
+				thread.join();
+			}
+		}
+
+		// 合并（主线程）：工作线程内部以 `laneIndex = 0` 渲染，因此图层内容指纹要按**真实网格下标**重算。
+		std::lock_guard<std::mutex> layerLock(m_layerMutex);
+		if (m_layerFront.size() != m_lanes.size())
+		{
+			return;
+		}
+		std::uint64_t rendered = 0;
+		for (const int laneIndex : laneIndices)
+		{
+			if (laneIndex < 0 || laneIndex >= static_cast<int>(m_layerFront.size()))
+			{
+				continue;
+			}
+			LaneLayer& target = m_layerFront[static_cast<std::size_t>(laneIndex)];
+			if (!target.valid)
+			{
+				continue;
+			}
+			target.key = LaneLayerKey(laneIndex);
+			++rendered;
+		}
+		m_layerRenderCount.fetch_add(rendered, std::memory_order_relaxed);
+	}
+
+	bool PlotView::RenderLaneLayerRegion(int laneIndex, LaneLayer& layer, int stripX, int stripW,
+	                                     int stripY, int stripH, double wideMin, double anchorYMax)
+	{
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return false;
+		}
+		std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+
+		const float plotWidth = m_plotRect.Width;
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(plotWidth > 8.0f) || !(span > 0.0))
+		{
+			layer.valid = false;
+			return false;
+		}
+
+		const int width = static_cast<int>(std::lround(plotWidth));
+		const int margin = LayerMarginX();		// 左右各半屏 → 可平移 ±半屏
+		const int bitmapWidth = width + 2 * margin;
+		const float laneHeight = m_lanes[static_cast<std::size_t>(laneIndex)].rect.Height;
+		const int lanePixelHeight = static_cast<int>(std::ceil(laneHeight));
+		const int marginY = LayerMarginY(laneHeight);	// 上下各半个网格高 → 幅值可平移 ±半个网格高
+		const int bitmapHeight = lanePixelHeight + 2 * marginY;
+		if (bitmapHeight <= 0 || !EnsureLaneLayer(layer, bitmapWidth, bitmapHeight))
+		{
+			return false;
+		}
+
+		const double scale = static_cast<double>(width) / span;		// 像素 / 时间
+		const double laneSpan = m_lanes[static_cast<std::size_t>(laneIndex)].yMax -
+		                        m_lanes[static_cast<std::size_t>(laneIndex)].yMin;
+		const double pxPerValue = (laneSpan > 0.0) ? static_cast<double>(laneHeight) / laneSpan : 0.0;
+
+		if (stripW <= 0 || stripX < 0 || stripX + stripW > bitmapWidth)
+		{
+			stripX = 0;
+			stripW = bitmapWidth;
+		}
+		// 纵向同理：`stripH <= 0` 表示纵向整块（横向滚动的细条就是这种情形）。
+		if (stripH <= 0 || stripY < 0 || stripY + stripH > bitmapHeight)
+		{
+			stripY = 0;
+			stripH = bitmapHeight;
+		}
+
+		// 保存当前布局 / 视图 / 网格，临时切换到"宽窗口"映射后离屏渲染，再恢复。
+		const gd::RectF savedArea = m_area;
+		const gd::RectF savedPlot = m_plotRect;
+		const double savedViewMin = Tab().ViewMin();
+		const double savedViewMax = Tab().ViewMax();
+		const std::vector<LaneVisual> savedLanes = m_lanes;
+		const bool savedFastFrame = m_fastFrame;
+		const bool savedRenderWide = m_renderWide;
+		const float savedScroll = Tab().LaneScroll();
+		const double savedWideTickSpan = m_wideTickSpan;
+		const float savedWideTickHeight = m_wideTickHeight;
+		const double savedRenderTimeStep = m_renderTimeStep;
+
+		m_plotRect = gd::RectF(0.0f, 0.0f, static_cast<float>(bitmapWidth),
+		                       static_cast<float>(bitmapHeight));
+		// 只把 `m_area` 限为待渲染的那一段 x 区间，使 GDI/GDI+ 的裁剪只落在它上面；
+		// x 坐标仍用**整条宽窗口**的映射（`m_plotRect` 为完整宽图），因此网格线位置与整块图层一致。
+		m_area = gd::RectF(static_cast<float>(stripX), static_cast<float>(stripY),
+		                   static_cast<float>(stripW), static_cast<float>(stripH));
+		// 横向补条（窄竖带）：把折线的构建与描边裁剪到条带的 x 范围（见 `m_stripRenderActive`）。
+		// 纵向补条（整宽 × 窄 y）不裁剪 x —— 那一方向本来就需要整条折线的顶点。
+		const bool stripIsHorizontalBand = (static_cast<float>(stripW) < static_cast<float>(bitmapWidth) - 0.5f);
+		const bool savedStripActive = m_stripRenderActive;
+		const float savedStripX0 = m_stripX0;
+		const float savedStripX1 = m_stripX1;
+		m_stripRenderActive = stripIsHorizontalBand;
+		m_stripX0 = static_cast<float>(stripX);
+		m_stripX1 = static_cast<float>(stripX + stripW);
+		Tab().ViewMin() = wideMin;
+		Tab().ViewMax() = wideMin + static_cast<double>(bitmapWidth) / scale;
+
+		m_renderWide = true;		// 图层只含基底：跳过派生曲线与装饰
+		// 图层必须与"同一视界的整幅渲染"**逐像素同源**：强制全质量抗锯齿（不受拖拽快速帧影响）。
+		m_fastFrame = false;
+		// 幅值刻度的参考跨度 / 参考高度取**前台可见网格**的值（而不是含上下余量的画布值）：
+		// 这样图层里的横向网格线步长与前台一致，纵向平移才是纯粹的像素平移。
+		m_wideTickSpan = laneSpan;
+		m_wideTickHeight = laneHeight;
+		BuildLaneVisuals();
+		// 沿用**当前视界**的 Y 轴范围，否则幅值映射与前台不一致。
+		for (std::size_t i = 0; i < m_lanes.size() && i < savedLanes.size(); ++i)
+		{
+			m_lanes[i].yMin = savedLanes[i].yMin;
+			m_lanes[i].yMax = savedLanes[i].yMax;
+		}
+		// ⚠️ **该网格的幅值映射必须以本次渲染的纵向锚点为准**（而不是"当前 `yMax`"）：
+		//  - 整块重画 / 纵向补条：锚点就是当前 `yMax`（纵向补条是滚动后的值），二者一致；
+		//  - **横向补细条**：只重画一条竖带，其余像素仍在**原锚点**上；若这里用当前 `yMax`
+		//    渲染，竖带与其余像素的纵向映射就不同源，贴图后出现撕裂/错位。
+		// 详见 `RenderLaneLayerRegion` 的 `anchorYMax` 形参说明。
+		m_lanes[static_cast<std::size_t>(laneIndex)].yMax = anchorYMax;
+		m_lanes[static_cast<std::size_t>(laneIndex)].yMin = anchorYMax - laneSpan;
+		// 该网格在本图层中的位置：横向铺满整条宽图，纵向铺满整张画布。
+		// 画布 = 「可见网格 + 上下各 `marginY` 行余量」。**上下扩展量按"像素行"精确换算**
+		//（而不是上下各扩展固定的数值量）：位图高度是整数（`ceil(laneHeight) + 2*marginY`），
+		// 只有当「扩展后总跨度 / 画布行数」严格等于前台的 px/数值 时，可见网格在画布里的映射
+		// 才与前台整幅渲染**逐像素同源**（否则会差一个 <1px 的纵向缩放误差，
+		// 让拖拽期间的像素残差明显变大）。
+		if (pxPerValue > 0.0)
+		{
+			const double topExtend = static_cast<double>(marginY) / pxPerValue;
+			const double bottomRows =
+			    static_cast<double>(bitmapHeight - marginY) - static_cast<double>(laneHeight);
+			const double bottomExtend = std::max(0.0, bottomRows) / pxPerValue;
+			m_lanes[static_cast<std::size_t>(laneIndex)].yMin -= bottomExtend;
+			m_lanes[static_cast<std::size_t>(laneIndex)].yMax += topExtend;
+		}
+		m_lanes[static_cast<std::size_t>(laneIndex)].rect =
+		    gd::RectF(0.0f, 0.0f, static_cast<float>(bitmapWidth), static_cast<float>(bitmapHeight));
+		{
+			gd::Graphics g(layer.dc);
+			g.SetSmoothingMode(gd::SmoothingModeAntiAlias);
+			g.SetPixelOffsetMode(gd::PixelOffsetModeHalf);
+			g.SetTextRenderingHint(gd::TextRenderingHintClearTypeGridFit);
+
+			UiFillRect(g, m_area, m_theme->plotBg);
+			UiFillRect(g, m_area, m_theme->cardBg);
+
+			// 竖向网格刻度沿用**前台视界跨度**（而非宽窗口的跨度），否则竖网格线会只有一半。
+			// ⚠️ 同时把它作为竖向网格的**主刻步长**传给 `PaintLane`（见 `m_renderTimeStep`）：
+			// 不传就会让图层用宽窗口跨度重算步长 → 竖向网格线与前台错位、部分整条丢失。
+			const double fgSpan = savedViewMax - savedViewMin;
+			const double timeStep = NiceStep((fgSpan > 0.0) ? fgSpan : 1.0, kTimeTickTarget);
+			m_renderTimeStep = timeStep;
+			std::vector<double> timeTicks;
+			BuildTicks(Tab().ViewMin(), Tab().ViewMax(), timeStep, timeTicks);
+			PaintLane(g, laneIndex, m_lanes[static_cast<std::size_t>(laneIndex)], timeTicks);
+			m_renderTimeStep = 0.0;
+		}
+		m_fastFrame = savedFastFrame;
+		m_renderWide = savedRenderWide;
+		m_wideTickSpan = savedWideTickSpan;
+		m_wideTickHeight = savedWideTickHeight;
+		m_renderTimeStep = savedRenderTimeStep;
+		m_stripRenderActive = savedStripActive;
+		m_stripX0 = savedStripX0;
+		m_stripX1 = savedStripX1;
+
+		// 恢复布局 / 视图 / 网格。
+		// ⚠️ **必须调用 `BuildLaneVisuals()`**（而不是只把 `m_lanes` 拷回去）：它会按正常布局
+		// 重算 `m_laneContentHeight`。该值参与内容指纹（`LaneLayerKey`），若残留上面"宽窗口"
+		// 布局算出的值，算出的图层指纹就与实际渲染不符 → 每帧都判定图层"过期"重画，白白耗性能。
+		m_area = savedArea;
+		m_plotRect = savedPlot;
+		Tab().ViewMin() = savedViewMin;
+		Tab().ViewMax() = savedViewMax;
+		BuildLaneVisuals();
+		// `BuildLaneVisuals()` 内部会 `ClampLaneScroll()`，用宽窗口布局可能夹出不同的滚动量，
+		// 因此把滚动量与各网格幅值范围一并还原回进入本函数前的状态。
+		Tab().LaneScroll() = savedScroll;
+		for (std::size_t i = 0; i < m_lanes.size() && i < savedLanes.size(); ++i)
+		{
+			m_lanes[i].yMin = savedLanes[i].yMin;
+			m_lanes[i].yMax = savedLanes[i].yMax;
+		}
+		// 恢复该网格的矩形（`BuildLaneVisuals` 已按正常布局给出，这里只为稳妥保持一致）。
+		if (laneIndex < static_cast<int>(m_lanes.size()) && laneIndex < static_cast<int>(savedLanes.size()))
+		{
+			m_lanes[static_cast<std::size_t>(laneIndex)] = savedLanes[static_cast<std::size_t>(laneIndex)];
+		}
+
+		layer.wideMin = wideMin;
+		layer.span = span;
+		layer.marginY = marginY;
+		// 纵向锚点 = 本次渲染的像素所对应的 `yMax`（由调用方按"改动了哪部分像素"决定；
+		// 横向补细条必须沿用图层原锚点，否则残余的纵向偏移会被静默清零 —— 见函数说明）。
+		layer.anchorYMax = anchorYMax;
+		layer.pxPerValue = pxPerValue;
+		layer.key = LaneLayerKey(laneIndex);
+		layer.valid = true;
+		m_layerRenderCount.fetch_add(1, std::memory_order_relaxed);
+		return true;
+	}
+
+	bool PlotView::RebuildWideBuffer()
+	{
+		const float plotWidth = m_plotRect.Width;
+		const float areaHeight = m_area.Height;
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(plotWidth > 8.0f) || !(areaHeight > 8.0f) || !(span > 0.0) || m_lanes.empty())
+		{
+			InvalidateWideBuffer();
+			return false;
+		}
+
+		// 只在**扩容 + 清空待重画队列**这一段持有 `m_layerMutex`；
+		// 随后释放，`RebuildLaneLayersParallel` 会各自重新获取（它内部还会取 `m_renderMutex`）。
+		// ⚠️ 如果这里一直持有 `m_layerMutex`，而并行重建内部再取一次 → `std::mutex` 不可重入 → 死锁。
+		{
+			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+			std::lock_guard<std::mutex> layerLock(m_layerMutex);
+			m_layerFront.resize(m_lanes.size());
+			m_layerRebuildPending.clear();
+		}
+
+		// 全部网格统一用"当前视界居中"的映射（与 `BlitWideBuffer` 的逐网格 `wideMin` 相容）。
+		const double wideMin = LayerDefaultWideMin();
+		std::vector<int> allLanes;
+		allLanes.reserve(m_lanes.size());
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			allLanes.push_back(static_cast<int>(index));
+		}
+		// **并行**重建全部网格（各网格用隔离上下文，多核时约等于一块网格的耗时）。
+		RebuildLaneLayersParallel(allLanes, wideMin);
+		std::lock_guard<std::mutex> layerLock(m_layerMutex);
+		bool ok = true;
+		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
+		{
+			if (!m_layerFront[index].valid)
+			{
+				ok = false;
+			}
+		}
+		return ok;
+	}
+
+	void PlotView::WarmLaneLayersStep()
+	{
+		if (m_dragMode != PlotDragMode::NONE || m_lanes.empty() || m_fonts == nullptr)
+		{
+			return;
+		}
+		if (!(m_plotRect.Width > 8.0f) || !(Tab().ViewMax() - Tab().ViewMin() > 0.0))
+		{
+			return;
+		}
+		{
+			std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+			std::lock_guard<std::mutex> layerLock(m_layerMutex);
+			if (m_layerFront.size() > m_lanes.size())
+			{
+				// 网格变少：先把多出来的图层位图释放掉（`resize` 不会调用 `ReleaseLaneLayer`）。
+				for (std::size_t index = m_lanes.size(); index < m_layerFront.size(); ++index)
+				{
+					ReleaseLaneLayer(m_layerFront[index]);
+				}
+			}
+			if (m_layerFront.size() != m_lanes.size())
+			{
+				m_layerFront.resize(m_lanes.size());
+			}
+		}
+		// 登记"跨度 / 内容不一致"的网格。空闲时视界未变 ⇒ `RollWideBuffer` 只登记、不做滚动，
+		// 也不会走"位移超出画布 → 立刻整块重画"那条分支。
+		RollWideBuffer();
+		const bool morePending = RenderPendingLaneRebuilds(1);
+		if (morePending)
+		{
+			const HWND host = m_host;
+			if (host != nullptr)
+			{
+				PostMessageW(host, kMessagePlotDerivedReady, 0, 0);
+			}
+		}
+	}
+
+	void PlotView::RollWideBuffer()
+	{
+		const float plotWidth = m_plotRect.Width;
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(plotWidth > 8.0f) || !(span > 0.0))
+		{
+			return;
+		}
+		const int width = static_cast<int>(std::lround(plotWidth));
+		const int margin = LayerMarginX();
+		const int bitmapWidth = width + 2 * margin;
+		const double scale = static_cast<double>(width) / span;
+
+		std::lock_guard<std::recursive_mutex> renderLock(m_renderMutex);
+		std::lock_guard<std::mutex> layerLock(m_layerMutex);
+		if (m_layerFront.size() != m_lanes.size() || m_layerFront.empty())
+		{
+			return;
+		}
+
+		// ⚠️ **逐网格独立滚动**：每个图层有自己的时间映射（`layer.wideMin`），
+		// 因此位移必须按各自的锚点分别计算。曾用**一个全局锚点**给所有图层算同一个位移，
+		// 结果各网格被平移了不同的真实距离 → 网格之间时间错位、贴回的像素互相矛盾，
+		// 表现为严重的绘制错误与波形抖动。
+		//
+		// ⚠️ **本函数绝不重画整块图层**：内容过期 / 锚点太远的网格只登记到待重画队列
+		//（由 `RenderPendingLaneRebuilds` 按预算在后续帧补画），本帧仍尽量用现有像素跟随视界。
+		// 这样前台**永远不会因为"图层没准备好"而做整批重绘**（那正是"拖拽时前台卡顿"的根因）。
+		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
+		{
+			LaneLayer& layer = m_layerFront[index];
+			const int laneIndex = static_cast<int>(index);
+
+			// 结构不可用（尺寸 / 跨度不符）：像素的时间映射已经不对，既不能贴也不能滚。
+			const float laneHeight = m_lanes[index].rect.Height;
+			const int bitmapHeight =
+			    static_cast<int>(std::ceil(laneHeight)) + 2 * LayerMarginY(laneHeight);
+			if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth ||
+			    layer.height != bitmapHeight || std::fabs(layer.span - span) > 1.0e-12)
+			{
+				QueueLaneRebuild(laneIndex);
+				continue;
+			}
+
+			// 视界左端当前落在该图层的哪个 x 上；期望它等于 `margin`（左右余量对称）。
+			const double desired = (Tab().ViewMin() - layer.wideMin) * scale;
+			const int shift = static_cast<int>(std::llround(desired - static_cast<double>(margin)));
+			// 内容（外观 / 网格几何 / 幅值**跨度** / 可见性…）与当前状态不一致。
+			const bool contentStale = (layer.key != LaneLayerKey(laneIndex));
+			// 纵向：幅值**平移**不改内容，只改贴图偏移（与横向同构）。
+			int vOffset = 0;
+			if (layer.pxPerValue > 0.0)
+			{
+				vOffset = static_cast<int>(
+				    std::llround((layer.anchorYMax - m_lanes[index].yMax) * layer.pxPerValue));
+			}
+
+			// ⚠️⚠️ **"距离太远"绝不允许退化成"排队等后续帧重画"**：
+			// 长距离拖拽（用户按着中键把视界移动好几个网格高、或横向拖很远）时，
+			// 每一帧的位移都会超过余量；若此时只登记待重画，就会出现
+			//   * 本帧 `BlitWideBuffer` 取不到源行 → 网格里出现**空白条带**；
+			//   * 每帧都重新入队 → 一帧只补 1 个网格 → **持续抽搐**且总是补不完。
+			// 正确做法是：
+			//   * 位移不超过画布 → **滚动**（O(1) BitBlt + 只补画暴露的细条）；
+			//   * 位移超过画布（内容整体滚出）→ 本帧**立刻整块重画并重新居中**（一次性），
+			//     等价于一次普通的整块渲染（实测 0.4ms），不会累积漂移也不会留空白。
+			// 只有**内容真的变了**（`contentStale`）才交给待重画队列（它可以等后续帧，
+			// 因为画面本身仍然是"旧内容"，不缺口）。
+			const bool fullRedraw = (std::abs(shift) >= bitmapWidth) ||
+			                        (std::abs(vOffset) >= layer.height);
+			if (fullRedraw)
+			{
+				// 两个方向都滚出画布：直接重新居中 + 整块重画（一次搞定，避免"滚动 + 巨幅补条"）。
+				if (contentStale || std::abs(shift) >= bitmapWidth)
+				{
+					QueueLaneRebuild(laneIndex);
+				}
+				// 整块重画：重新居中 + 纵向锚点取**当前** `yMax`。
+				RenderLaneLayerRegion(laneIndex, layer, 0, bitmapWidth, 0, 0, LayerDefaultWideMin(),
+				                      m_lanes[static_cast<std::size_t>(laneIndex)].yMax);
+				continue;
+			}
+			if (contentStale)
+			{
+				QueueLaneRebuild(laneIndex);
+			}
+
+			// ------------------------------------------------------------------
+			// 纵向（幅值）滚动：与横向**完全同构**——内容整体上下移动若干行，
+			// 再只补画新暴露的那一条（整宽 × 行数）。
+			//
+			// ⚠️ **必须先做纵向再做横向**：横向补条由 `RenderLaneLayerRegion` 渲染，
+			// 而该函数按传入的**纵向锚点**渲染细条；若先补横向，那时锚点还没跟上，
+			// 补出来的细条会带着一个错的纵向偏移（贴图后表现为波形错位/撕裂）。
+			// ⚠️ 没有这一步时：幅值一变就超出余量 → 每帧都排队**整块重画**（画布比可见网格高
+			// 3 倍，代价很大）→ 拖动时"抽搐"；而且在重画完成前，`BlitWideBuffer` 只能贴出部分
+			// 行（其余留空）→ 网格内出现**空白条带**（用户报告的"绘制异常"）。
+			//
+			// ⚠️ **滚动量必须量化**（`kLayerRollQuantum`）：不足一个量子的偏移**不滚**，
+			// 交给贴图时的纵向偏移（`srcY`）处理。这样图层的画布映射在拖动过程中**保持稳定**，
+			// 折线缓存（键含幅值映射）得以命中；否则每帧滚 1~30 行会让折线每帧重算
+			// （实测同样的拖动：量化前 3~4ms 的滚动 + 10~14ms 整帧，量化后回到 ~5ms 量级）。
+			// 余量足够大（上下各 `marginY`），因此"不滚只偏移"绝不会超出画布。
+			// 上面已保证 |vOffset| < 画布高，所以这里的 BitBlt 高度恒为正。
+			// ------------------------------------------------------------------
+			if (std::abs(vOffset) >= kLayerRollQuantum)
+			{
+				const int roll = vOffset;		// 正 = 内容整体上移 roll 行（窗口向下移动）
+				int stripY = 0;
+				int stripH = 0;
+				if (roll > 0)
+				{
+					// 内容上移：new[y] = old[y + roll]，底部暴露 roll 行。
+					BitBlt(layer.dc, 0, 0, bitmapWidth, layer.height - roll, layer.dc, 0, roll, SRCCOPY);
+					stripY = layer.height - roll;
+					stripH = roll;
+				}
+				else
+				{
+					const int amount = -roll;
+					// 内容下移：new[y] = old[y - amount]，顶部暴露 amount 行。
+					BitBlt(layer.dc, 0, amount, bitmapWidth, layer.height - amount, layer.dc, 0, 0,
+					       SRCCOPY);
+					stripY = 0;
+					stripH = amount;
+				}
+				// 锚点随之移动（与横向 `layer.wideMin += shift / scale` 同一套记账方式）。
+				layer.anchorYMax -= static_cast<double>(roll) / layer.pxPerValue;
+				// 补画暴露的那一条（整宽）。锚点用**滚动后**的值 —— 该条与已滚动的像素同一映射。
+				RenderLaneLayerRegion(laneIndex, layer, 0, bitmapWidth, stripY, stripH, layer.wideMin,
+				                      layer.anchorYMax);
+			}
+
+			if (shift == 0)
+			{
+				continue;
+			}
+
+			// 整数像素自贴图平移：内容整体移动 `shift` 像素。
+			if (shift > 0)
+			{
+				// 内容整体左移 shift：new[x] = old[x + shift]，右侧暴露 shift 列。
+				BitBlt(layer.dc, 0, 0, bitmapWidth - shift, layer.height, layer.dc, shift, 0, SRCCOPY);
+			}
+			else
+			{
+				const int amount = -shift;
+				BitBlt(layer.dc, amount, 0, bitmapWidth - amount, layer.height, layer.dc, 0, 0, SRCCOPY);
+			}
+			layer.wideMin += static_cast<double>(shift) / scale;
+
+			// 只补画新暴露的细条（每帧代价恒为 O(细条)）。
+			// ⚠️ 细条必须用**该图层更新后的映射**渲染（传 `layer.wideMin`）；若改用"当前视界"
+			// 的映射，细条与已平移的旧像素之间会有 ≤0.5px 的错位接缝 → 拖动时看起来在抖动。
+			// ⚠️ **纵向锚点必须沿用 `layer.anchorYMax`**（不能传当前 `yMax`）：横向补条只改一条
+			// 竖带，其余像素仍在原锚点上；同时该函数按锚点渲染这条竖带，因此竖带与其余像素
+			// 纵向同源。若在这里把锚点重置为当前 `yMax`，残余的纵向偏移会被静默清零、而像素
+			// 并未上移 → 整个网格的波形纵向错位（"垂直拖动后再横向平移出现纵向跳变"）。
+			const int stripWidth = std::min(std::abs(shift), bitmapWidth);
+			const int stripX = (shift > 0) ? (bitmapWidth - stripWidth) : 0;
+			RenderLaneLayerRegion(laneIndex, layer, stripX, stripWidth, 0, 0, layer.wideMin,
+			                      layer.anchorYMax);
+		}
+	}
+
+	bool PlotView::BlitWideBuffer(gd::Graphics& g) const
+	{
+		const float plotWidth = m_plotRect.Width;
+		const double span = Tab().ViewMax() - Tab().ViewMin();
+		if (!(plotWidth > 8.0f) || !(span > 0.0))
+		{
+			return false;
+		}
+		const int width = static_cast<int>(std::lround(plotWidth));
+		const int margin = LayerMarginX();
+		const int bitmapWidth = width + 2 * margin;
+		const double scale = static_cast<double>(width) / span;
+
+		std::lock_guard<std::mutex> lock(m_layerMutex);
+		if (m_layerFront.size() != m_lanes.size())
+		{
+			return false;
+		}
+		HDC target = g.GetHDC();
+		if (target == nullptr)
+		{
+			return false;
+		}
+		bool any = false;
+		for (std::size_t index = 0; index < m_layerFront.size(); ++index)
+		{
+			const LaneLayer& layer = m_layerFront[index];
+			if (!layer.valid || layer.dc == nullptr || layer.width != bitmapWidth)
+			{
+				continue;
+			}
+			const gd::RectF& lane = m_lanes[index].rect;
+			// 纵向映射是否仍然可用：图层高度必须等于"当前网格高 + 上下预渲染余量"。
+			// 高度变了（布局变化）时像素无法映射，只能等整块重画。
+			const int expectBitmapHeight =
+			    static_cast<int>(std::ceil(lane.Height)) + 2 * LayerMarginY(lane.Height);
+			if (layer.height != expectBitmapHeight)
+			{
+				continue;
+			}
+			// ⚠️ **跨度过期 = 该图层是"旧跨度"的像素**（典型：选区放大 / 键盘缩放的瞬间）。
+			// 旧实现直接 `continue` → 整个网格在重画完成前**空白**，且触发"同步整批重建"
+			// （实测 70~80ms）把前台卡住。
+			// 现在改为把它当作**占位图**用一次 StretchBlt 拉出来：旧图层覆盖的时间段
+			// [layer.wideMin, layer.wideMin + layer.span] 重新映射到新的视界上 ——
+			// 画面略糊（低分辨率），但**立即可用**；精确像素由后续按预算重画逐个替换。
+			const bool spanStale = (std::fabs(layer.span - span) > 1.0e-12);
+			const float top = std::max(lane.Y, m_plotRect.Y);
+			const float bottom = std::min(lane.Y + lane.Height, m_plotRect.Y + m_plotRect.Height);
+			if (bottom <= top)
+			{
+				continue;	// 网格整体移出可视区
+			}
+			const int destX = static_cast<int>(std::lround(m_plotRect.X));
+			const int destY = static_cast<int>(std::lround(top));
+			int height = static_cast<int>(std::lround(bottom - top));
+			if (height <= 0)
+			{
+				continue;
+			}
+
+			// ⚠️ **纵向偏移**：图层带「上下各半个网格高」的预渲染余量，幅值平移只改这里的
+			// 源行偏移（`anchorYMax` 与当前 `yMax` 之差换算成像素），不必重画图层 ——
+			// 这就是"纵向拖动与横向拖动同样是 O(1) 贴图"的关键。
+			int srcY = 0;
+			{
+				int vOffset = 0;
+				if (layer.pxPerValue > 0.0)
+				{
+					vOffset = static_cast<int>(
+					    std::llround((layer.anchorYMax - m_lanes[index].yMax) * layer.pxPerValue));
+				}
+				srcY = static_cast<int>(std::lround(top - lane.Y)) + layer.marginY + vOffset;
+			}
+			// 超出画布的上下两端只贴**有像素的那一段**（其余由底色填充，本帧的预算内重画会补齐）。
+			int destTopOffset = 0;
+			if (srcY < 0)
+			{
+				destTopOffset = -srcY;
+				height -= destTopOffset;
+				srcY = 0;
+			}
+			if (srcY + height > layer.height)
+			{
+				height = layer.height - srcY;
+			}
+			if (height <= 0)
+			{
+				continue;
+			}
+
+			if (spanStale)
+			{
+				// 占位拉伸：旧图层的时间跨度映射到当前视界（横向）。纵向映射不变。
+				if (!(layer.span > 0.0))
+				{
+					continue;
+				}
+				const double dx0 = static_cast<double>(destX) + (layer.wideMin - Tab().ViewMin()) * scale;
+				const double dx1 = dx0 + layer.span * scale;
+				if (!(dx1 > dx0))
+				{
+					continue;
+				}
+				const double cx0 = std::max(dx0, static_cast<double>(destX));
+				const double cx1 =
+				    std::min(dx1, static_cast<double>(destX) + static_cast<double>(width));
+				if (cx1 - cx0 < 1.0)
+				{
+					continue;
+				}
+				const double sx0 = (cx0 - dx0) / (dx1 - dx0) * static_cast<double>(layer.width);
+				const double sx1 = (cx1 - dx0) / (dx1 - dx0) * static_cast<double>(layer.width);
+				const int dstX = static_cast<int>(std::lround(cx0));
+				const int dstW = std::max(1, static_cast<int>(std::lround(cx1 - cx0)));
+				const int srcX2 = static_cast<int>(std::lround(sx0));
+				const int srcW = std::max(1, static_cast<int>(std::lround(sx1 - sx0)));
+				// HALFTONE 让拉伸后的占位图明显更接近成图（下采样尤其明显）；置一次即可。
+				SetStretchBltMode(target, HALFTONE);
+				SetBrushOrgEx(target, 0, 0, nullptr);
+				StretchBlt(target, dstX, destY + destTopOffset, dstW, height, layer.dc, srcX2, srcY,
+				           srcW, height, SRCCOPY);
+				any = true;
+				continue;
+			}
+
+			// ⚠️ **局部贴图**：图层只覆盖"视界 ± 半屏"，视界可能有一部分落在图层之外。
+			// 这里只贴**有像素的那一段**（其余留给底色填充，后续帧由预算内重画补齐），
+			// 而不是整块跳过 —— 跳过会让整个网格瞬间变空（"断线 / 空白"的直接原因）。
+			const double subX = (Tab().ViewMin() - layer.wideMin) * scale;
+			int srcX = static_cast<int>(std::lround(subX));
+			int destOffset = 0;				// 从视界左端起偏移多少像素开始贴
+			int blitWidth = width;
+			if (srcX < 0)
+			{
+				destOffset = -srcX;
+				blitWidth -= destOffset;
+				srcX = 0;
+			}
+			if (srcX + blitWidth > bitmapWidth)
+			{
+				blitWidth = bitmapWidth - srcX;
+			}
+			if (blitWidth <= 0)
+			{
+				continue;	// 完全没有可用像素（该网格待重画）
+			}
+			BitBlt(target, destX + destOffset, destY + destTopOffset, blitWidth, height, layer.dc, srcX,
+			       srcY, SRCCOPY);
+			any = true;
+		}
+		g.ReleaseHDC(target);
+		return any;
+	}
+
+	void PlotView::PaintRubberBand(gd::Graphics& g)
+	{
+		if (!m_dragMoved || m_rubberRect.Width <= 0.0f || m_rubberRect.Height <= 0.0f)
+		{
+			return;
+		}
+		if (m_dragMode != PlotDragMode::RUBBER_SELECT)
+		{
+			return;
+		}
+
+		// 轴向未定时不绘制选区，避免刚按下就闪出一个奇怪的方框。
+		const bool timeMode = (m_rubberAxis == PlotRubberAxis::TIME);
+		const bool valueMode = (m_rubberAxis == PlotRubberAxis::VALUE);
+		if (!timeMode && !valueMode)
+		{
+			return;
+		}
+
+		// 选区只应出现在绘图区内：即使内部矩形意外越界（例如鼠标被捕获到工具栏 /
+		// 信号面板上），也在这里再夹一次，绝不把选区块画到绘图区之外。
+		const float clipLeft = std::max(m_rubberRect.X, m_plotRect.X);
+		const float clipTop = std::max(m_rubberRect.Y, m_plotRect.Y);
+		const float clipRight =
+		    std::min(m_rubberRect.X + m_rubberRect.Width, m_plotRect.X + m_plotRect.Width);
+		const float clipBottom =
+		    std::min(m_rubberRect.Y + m_rubberRect.Height, m_plotRect.Y + m_plotRect.Height);
+		if (clipRight <= clipLeft || clipBottom <= clipTop)
+		{
+			return;
+		}
+		const gd::RectF bandRect(clipLeft, clipTop, clipRight - clipLeft, clipBottom - clipTop);
+
+		// 两种方向的选区使用**同一种强调色**，保持视觉一致。
+		const std::uint32_t band = m_theme->accent;
+		UiFillRect(g, bandRect, WithAlpha(band, 0x28));
+		UiDrawRoundRect(g, bandRect, 2.0f * m_scale, band, 1.4f);
+
+		// 选区跨度提示（时间用秒/数值用幅度量纲），放在选区顶部。
+		std::wstring text;
+		if (timeMode)
+		{
+			text = FormatValue(std::fabs(XToTime(m_rubberRect.X + m_rubberRect.Width) -
+			                             XToTime(m_rubberRect.X)));
+		}
+		else if (m_dragLane >= 0 && m_dragLane < static_cast<int>(m_lanes.size()))
+		{
+			const LaneVisual& lane = m_lanes[static_cast<std::size_t>(m_dragLane)];
+			text = FormatValue(std::fabs(YToValue(m_rubberRect.Y + m_rubberRect.Height, lane) -
+			                             YToValue(m_rubberRect.Y, lane)));
+		}
+		if (text.empty())
+		{
+			return;
+		}
+
+		const float textWidth = UiMeasureTextWidth(m_fonts->monoSmall, text) + 12.0f * m_scale;
+		const float textHeight = 18.0f * m_scale;
+		float labelX = bandRect.X + bandRect.Width * 0.5f - textWidth * 0.5f;
+		labelX = std::max(m_plotRect.X, std::min(labelX, m_plotRect.X + m_plotRect.Width - textWidth));
+		const gd::RectF labelRect(labelX, bandRect.Y + 3.0f * m_scale, textWidth, textHeight);
+
+		UiFillRoundRect(g, labelRect, 3.0f * m_scale, band);
+		UiText(g, text, m_fonts->monoSmall, labelRect, m_theme->textOnAccent, TextAlign::CENTER);
+	}
+
+	void PlotView::PaintHint(gd::Graphics& g)
+	{
+		if (m_hintText.empty() || m_fonts == nullptr || m_fonts->ui == nullptr || m_hintShownAt == 0)
+		{
+			return;
+		}
+
+		const std::uint64_t elapsed = GetTickCount64() - m_hintShownAt;
+		// 粘滞状态下不淡出（用于"拖动过程中维持显示"）。
+		if (!m_hintSticky && elapsed >= (kHintHoldMs + kHintFadeMs))
+		{
+			return;
+		}
+		// 停留结束后在 kHintFadeMs 内线性淡出（颜色 alpha 按比例缩放）。
+		const double fade = (m_hintSticky || elapsed <= kHintHoldMs)
+		                        ? 1.0
+		                        : (1.0 - static_cast<double>(elapsed - kHintHoldMs) /
+		                                     static_cast<double>(kHintFadeMs));
+		const unsigned int alpha =
+		    static_cast<unsigned int>(std::max(0.0, std::min(1.0, fade)) * 255.0);
+
+		// 提示条贴在绘图区底部居中；时间光标的时间读数也在底部，
+		// 因此光标启用时把提示条上移一行，避免两者互相遮挡。
+		const float reserved = (m_tab != nullptr && Tab().CursorEnabled()) ? 26.0f * m_scale : 0.0f;
+		const float width = UiMeasureTextWidth(m_fonts->ui, m_hintText) + 30.0f * m_scale;
+		const float height = 30.0f * m_scale;
+		float left = m_plotRect.X + (m_plotRect.Width - width) * 0.5f;
+		left = std::max(m_plotRect.X + 2.0f * m_scale,
+		                std::min(left, m_plotRect.X + m_plotRect.Width - width - 2.0f * m_scale));
+		const gd::RectF pill(left, m_plotRect.Y + m_plotRect.Height - height - 4.0f * m_scale - reserved,
+		                     width, height);
+
+		UiFillRoundRect(g, pill, 4.0f * m_scale, ScaleAlpha(m_theme->readoutBg, alpha));
+		UiDrawRoundRect(g, pill, 4.0f * m_scale, ScaleAlpha(m_theme->borderStrong, alpha), 1.2f);
+		// 文字走 GDI（不支持 alpha 通道），因此把文字颜色向胶囊底色**混色**来实现淡出。
+		const std::uint32_t textColor =
+		    MixColor(m_theme->textStrong, m_theme->readoutBg, 1.0f - static_cast<float>(fade));
+		UiText(g, m_hintText, m_fonts->ui, pill, textColor, TextAlign::CENTER);
+	}
+
+	void PlotView::PaintLane(gd::Graphics& g, int laneIndex, const LaneVisual& lane,
+	                         const std::vector<double>& timeTicks)
+	{
+		// 网格内容必须裁剪在绘图区之内：纵向滚动时网格会部分移出可视范围，
+		// 若不与 m_plotRect 求交，波形就会溢出到工具栏与时间轴区域。
+		const float clipTop = std::max(lane.rect.Y, m_plotRect.Y);
+		const float clipBottom =
+		    std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height);
+		if (clipBottom <= clipTop)
+		{
+			return;
+		}
+
+		const int saveState = g.Save();
+		// 与当前裁剪区求交（而不是替换）：局部重画（RepaintSceneCachePatch）时
+		// 外层已经按“需要重画的网格范围”设过裁剪区，这里必须保留，否则会重画到
+		// 其他网格上。整幅重绘时外层没有裁剪区，等同于原来的行为。
+		//
+		// ⚠️ **本次调用只允许改动 `m_area`** —— 它既是"整幅渲染"的绘图区，也是
+		// "信号图层"的**条带**（横向补条 = 窄 x 区间 × 全高；纵向补条 = 全宽 × 窄 y 区间）。
+		// GDI 绘制（网格线 / 分界线）**不受 GDI+ 裁剪约束**，所以它们的裁剪矩形必须
+		// **同时**与 `m_area` 求交：否则纵向补条时横向网格线会被画到条带之外的已正确像素上、
+		// 覆盖在波形之上（"网格线盖住波形"），并**永久烘进图层**、随之后的每次平移一起移动
+		// —— 正是用户报告的"上下拖动之后，左右/上下/斜向拖动都出现绘制错误"。
+		const gd::RectF laneClip = IntersectRect(
+		    gd::RectF(m_area.X, m_area.Y, m_area.Width, m_area.Height),
+		    gd::RectF(lane.rect.X, clipTop, lane.rect.Width, clipBottom - clipTop));
+		g.SetClip(laneClip, gd::CombineModeIntersect);
+
+
+		// 幅值网格线（先画线，标尺稍后作为覆盖层绘制，避免被波形遮挡）。
+		// 刻度密度随网格高度自适应：所有网格高度相同 → 各网格的刻度数量一致，
+		// 不会出现“有的网格只有 1 条标签、有的有 3 条”的不一致观感。
+		//
+		// ⚠️ 网格线一律用 **GDI** 批量绘制：GDI+ 的 DrawLine 每条约 0.1–0.19ms，
+		// 而一张网格有几十条网格线（5 个网格就是数百条），逐条调用会让单帧多花十几毫秒
+		// —— 这正是"放大后拖动网格视界很卡"的主因。GDI 绘制不受 GDI+ 裁剪约束，
+		// 因此显式传入裁剪矩形；半透明辅助线先与网格底色混合成不透明色。
+		const gd::RectF gridClip = laneClip;
+		/** 标尺数值文本的裁剪矩形（GDI 文本需要显式裁剪，否则会越过绘图区）。 */
+		const gd::RectF clipRectForLabels = gridClip;
+		const std::uint32_t minorLineColor = UiBlendOver(m_theme->cardBg, WithAlpha(m_theme->gridWeak, kMinorLineAlpha));
+		const std::uint32_t weakLineColor = m_theme->gridWeak | 0xFF000000u;
+		const std::uint32_t strongLineColor = m_theme->gridStrong | 0xFF000000u;
+
+		int yTickTarget = static_cast<int>(std::lround(lane.rect.Height / (kYTickSpacing * m_scale)));
+		yTickTarget = std::max(kYTickTargetMin, std::min(yTickTarget, kYTickTargetMax));
+		// ⚠️ 渲染「信号图层」时，幅值刻度必须以**前台可见网格**的跨度/高度为基准：
+		// 图层画布比可见网格高（上下各留预渲染余量），若按画布高度与扩展后的跨度取刻度，
+		// 图里的网格线密度就与整幅渲染不一致 —— 贴图后拖动时网格线会跳变。
+		// 用可见跨度取步长 + 按扩展范围铺满整张画布 ⇒ 刻度落在同一批绝对值格点上，
+		// 于是"纵向平移 = 纯粹的像素平移"（逐像素同源）。
+		const double tickSpan = (m_renderWide && m_wideTickSpan > 0.0)
+		                            ? m_wideTickSpan
+		                            : (lane.yMax - lane.yMin);
+		if (m_renderWide && m_wideTickHeight > 0.0f)
+		{
+			yTickTarget = static_cast<int>(
+			    std::lround(m_wideTickHeight / (kYTickSpacing * m_scale)));
+			yTickTarget = std::max(kYTickTargetMin, std::min(yTickTarget, kYTickTargetMax));
+		}
+		const double yStep = NiceStep(tickSpan, yTickTarget);
+		std::vector<double> yTicks;
+		BuildTicks(lane.yMin, lane.yMax, yStep, yTicks);
+
+		// 五等分估读线：在相邻主刻度之间再细分，便于目视读取中间值。
+		const double yMinorStep = yStep / static_cast<double>(kMinorDivisions);
+		std::vector<double> yMinorTicks;
+		BuildTicks(lane.yMin, lane.yMax, yMinorStep, yMinorTicks);
+		std::vector<float> minorSegments;
+		std::vector<float> weakSegments;
+		std::vector<float> strongSegments;
+		minorSegments.reserve(yMinorTicks.size() * 4);
+		weakSegments.reserve(yTicks.size() * 4);
+		for (const double tick : yMinorTicks)
+		{
+			// 与主刻度重合的位置跳过（主刻度会以更重的线条绘制）。
+			const double majorIndex = tick / yStep;
+			if (std::fabs(majorIndex - std::floor(majorIndex + 0.5)) < 1.0e-6)
+			{
+				continue;
+			}
+
+			const float y = ValueToY(tick, lane);
+			if (y < lane.rect.Y - 1.0f || y > lane.rect.Y + lane.rect.Height + 1.0f)
+			{
+				continue;
+			}
+			minorSegments.insert(minorSegments.end(),
+			                     {lane.rect.X, y, lane.rect.X + lane.rect.Width, y});
+		}
+
+		for (const double tick : yTicks)
+		{
+			const float y = ValueToY(tick, lane);
+			if (y < lane.rect.Y - 1.0f || y > lane.rect.Y + lane.rect.Height + 1.0f)
+			{
+				continue;
+			}
+
+			// 零线用更重的颜色（单独一批，避免为每段颜色切换画笔）。
+			std::vector<float>& target = (tick == 0.0) ? strongSegments : weakSegments;
+			target.insert(target.end(), {lane.rect.X, y, lane.rect.X + lane.rect.Width, y});
+		}
+
+		// 时间网格线（同样补充五等分估读线）。
+		// ⚠️ 主刻步长优先取 `m_renderTimeStep`（渲染信号图层时由前台跨度给出，见该成员的说明）：
+		// 图层渲染的 `Tab().ViewMin/ViewMax` 是**宽窗口**区间，直接拿它算 `NiceStep` 会得到比前台
+		// 更大的步长（往往正好 2 倍），使图层里的竖向网格线与前台错位、部分整条丢失。
+		const double timeSpan = Tab().ViewMax() - Tab().ViewMin();
+		const double timeMajorStep =
+		    (m_renderTimeStep > 0.0) ? m_renderTimeStep
+		                             : NiceStep((timeSpan > 0.0) ? timeSpan : 1.0, kTimeTickTarget);
+		const double timeMinorStep = timeMajorStep / static_cast<double>(kMinorDivisions);
+		std::vector<double> timeMinorTicks;
+		BuildTicks(Tab().ViewMin(), Tab().ViewMax(), timeMinorStep, timeMinorTicks);
+		for (const double tick : timeMinorTicks)
+		{
+			const double majorIndex = tick / timeMajorStep;
+			if (std::fabs(majorIndex - std::floor(majorIndex + 0.5)) < 1.0e-6)
+			{
+				continue;
+			}
+
+			const float x = TimeToX(tick);
+			if (x < lane.rect.X || x > lane.rect.X + lane.rect.Width)
+			{
+				continue;
+			}
+			minorSegments.insert(minorSegments.end(),
+			                     {x, lane.rect.Y, x, lane.rect.Y + lane.rect.Height});
+		}
+
+		for (const double tick : timeTicks)
+		{
+			const float x = TimeToX(tick);
+			if (x < lane.rect.X || x > lane.rect.X + lane.rect.Width)
+			{
+				continue;
+			}
+			weakSegments.insert(weakSegments.end(), {x, lane.rect.Y, x, lane.rect.Y + lane.rect.Height});
+		}
+
+		if (!m_renderDecorOnly)
+		{
+			if (!minorSegments.empty())
+			{
+				UiDrawSolidLines(g, gridClip, minorSegments.data(), minorSegments.size() / 4, minorLineColor);
+			}
+			if (!weakSegments.empty())
+			{
+				UiDrawSolidLines(g, gridClip, weakSegments.data(), weakSegments.size() / 4, weakLineColor);
+			}
+			if (!strongSegments.empty())
+			{
+				UiDrawSolidLines(g, gridClip, strongSegments.data(), strongSegments.size() / 4, strongLineColor);
+			}
+		}
+
+		// 波形绘制。
+		const std::vector<SignalRef>& laneSignals = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals;
+		if (m_renderDecorOnly)
+		{
+			// 只画装饰：网格线与波形已由宽基底提供，这里跳过。
+		}
+		else if (laneSignals.empty())
+		{
+			const gd::RectF visibleRect(lane.rect.X, clipTop, lane.rect.Width, clipBottom - clipTop);
+			UiText(g, L"（空网格）", m_fonts->uiSmall, visibleRect, m_theme->textMuted, TextAlign::CENTER);
+		}
+		else
+		{
+			const int waveSave = g.Save();
+			g.SetClip(lane.rect, gd::CombineModeIntersect);
+
+			// 只有拖拽中的信号光晕可以进入静态场景缓存（悬停光晕见 PaintHoverHighlight）。
+			const SignalRef haloRef = SceneHaloRef();
+			// 派生预览曲线（中心轴 / 均值滤波 / 弱峰调整）在下方"第二遍"统一叠加绘制，
+			// 见 `PaintLaneDerivedOverlays`（抽出以便宽缓冲区前台路径复用）。
+
+			for (const SignalRef& ref : laneSignals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
+				{
+					continue;
+				}
+
+				const DrawMode mode = resolved.style->mode;
+				// 顶点由“几何键”缓存提供：同一视图下重复绘制不再重算全量采样。
+				const PolylineCacheEntry* cached = AcquirePolyline(ref, resolved, lane);
+				if (cached == nullptr)
+				{
+					continue;
+				}
+				const std::vector<gd::PointF>& points = cached->points;
+				const std::vector<std::size_t>& breaks = cached->breaks;
+
+				const bool drawLine = (mode != DrawMode::SCATTER);
+				const bool drawScatter = (mode == DrawMode::SCATTER || mode == DrawMode::LINE_SCATTER);
+
+				// 悬停命中的信号先画一层浅色光晕，作为“可拖拽”的视觉提示。
+				// 这里只处理拖拽中的信号（其光晕在拖拽期间不变，可以进入静态场景缓存）；
+				// 悬停光晕随鼠标变化，改由 PaintHoverHighlight 在缓存贴图之后绘制。
+				const bool highlighted = (ref == haloRef);
+				if (highlighted)
+				{
+					PaintSignalHaloFor(g, resolved, lane, *cached);
+				}
+
+				if (drawLine && !breaks.empty())
+				{
+					const std::uint32_t lineColor = StyleColor(*resolved.style);
+					if (cached->bandMode && !cached->bandBreaks.empty())
+					{
+						// 稠密包络：一次 FillPath 填充包络带。
+						// **必须显式设为缠绕填充规则**：包络带自交（相邻列上下包络交叉）时，
+						// 交替（奇偶）规则会在交叠处挖出空洞。
+						//
+						// 抗锯齿开关：几何保持不变，只在"交互期间"或"梳状带"时关闭。
+						// 梳状带（振荡周期≈像素列宽）下抗锯齿的扫描线代价暴涨而观感几乎无差别，
+						// 实测同一条 2448 顶点的路径 27.6ms → 3.2ms。
+						const int savedSmoothing = g.GetSmoothingMode();
+						if (m_fastFrame || cached->bandSpiky)
+						{
+							g.SetSmoothingMode(gd::SmoothingModeNone);
+						}
+						gd::GraphicsPath bandPath;
+						bandPath.SetFillMode(gd::FillModeWinding);
+						for (std::size_t k = 0; k < cached->bandBreaks.size(); ++k)
+						{
+							const std::size_t start = cached->bandBreaks[k];
+							const std::size_t stop = (k + 1 < cached->bandBreaks.size())
+							                             ? cached->bandBreaks[k + 1]
+							                             : cached->band.size();
+							const std::size_t total = stop - start;
+							if (total < 4 || (total % 2) != 0)
+							{
+								continue;
+							}
+							const std::size_t half = total / 2;
+							bandPath.StartFigure();
+							bandPath.AddLines(cached->band.data() + start, static_cast<INT>(half));
+							bandPath.AddLines(cached->band.data() + start + half,
+							                  static_cast<INT>(half));
+							bandPath.CloseFigure();
+						}
+						if (bandPath.GetPointCount() > 0)
+						{
+							gd::SolidBrush brush(ToGdiColor(lineColor));
+							g.FillPath(&brush, &bandPath);
+						}
+						g.SetSmoothingMode(static_cast<gd::SmoothingMode>(savedSmoothing));
+					}
+					else
+					{
+						gd::Pen pen(ToGdiColor(lineColor), resolved.style->lineWidth * m_scale);
+						pen.SetLineJoin(gd::LineJoinRound);
+						pen.SetStartCap(gd::LineCapRound);
+						pen.SetEndCap(gd::LineCapRound);
+
+						for (std::size_t k = 0; k < breaks.size(); ++k)
+						{
+							const std::size_t start = breaks[k];
+							const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
+							if (stop <= start + 1)
+							{
+								continue;
+							}
+							g.DrawLines(&pen, points.data() + start, static_cast<INT>(stop - start));
+						}
+					}
+				}
+
+				if (drawScatter && !points.empty())
+				{
+					// 散点半径随线宽线性增长（达到上限前不过早触顶），使“线宽”直观控制数据点大小。
+					const float radius = static_cast<float>(
+					    ClampDouble(static_cast<double>(resolved.style->lineWidth) * kScatterRadiusScale,
+					                kMinScatterRadius, kMaxScatterRadius) *
+					    m_scale);
+					const std::size_t scatterStride =
+					    std::max<std::size_t>(1, points.size() / kMaxScatterPoints);
+					// 所有散点合并到一条 GraphicsPath 后只调用一次 FillPath：
+					// 逐点 FillEllipse 每次都要完整走一遍 GDI+ 的状态检查与光栅化入口，
+					// 实测 2500 点需要约 51ms；合并后约 1/9（实测基准 63ms → 7ms）。
+					// **必须显式设为缠绕填充规则**：GraphicsPath 默认是交替（奇偶）规则，
+					// 两个重叠的圆在交集处会互相抵消形成空洞，表现为"数据点重叠处出现异常白边"。
+					gd::GraphicsPath scatterPath;
+					scatterPath.SetFillMode(gd::FillModeWinding);
+					for (std::size_t k = 0; k < points.size(); k += scatterStride)
+					{
+						scatterPath.AddEllipse(points[k].X - radius, points[k].Y - radius, radius * 2.0f,
+						                       radius * 2.0f);
+					}
+					gd::SolidBrush brush(ToGdiColor(StyleColor(*resolved.style)));
+					if (scatterPath.GetPointCount() > 0)
+					{
+						g.FillPath(&brush, &scatterPath);
+					}
+				}
+			}
+
+			// 第二遍：把所有**派生预览曲线**统一绘制在**本网格全部原信号之上**。
+			// 渲染「宽缓冲区」时跳过：宽缓冲只存"基底"（网格/波形，不含派生曲线与装饰），
+			// 派生曲线改由前台叠加层绘制（见 `PaintLaneDerivedOverlays`），
+			// 这样拖派生参数滑块时基底不变、可复用宽缓冲像素。
+			// ⚠️ `m_renderDecorOnly`（把装饰单独画进透明缓存位图）时**也必须跳过**：
+			// 派生曲线是"随时间视界变化"的内容，若烘进装饰位图，贴回时会把旧视界的
+			// 预览曲线永久留在画面上。
+			if (!m_renderWide && !m_renderDecorOnly)
+			{
+				PaintLaneDerivedOverlays(g, laneIndex, lane);
+			}
+
+			// g.Restore 也会还原绘制状态，此处直接恢复图形状态即可。
+			g.Restore(waveSave);
+		}
+
+		// 网格分界线：网格之间不再留间隔，改用较重的横线明确分隔相邻网格。
+		// ⚠️ **渲染信号图层时跳过**：分界线锚定在网格的**屏幕位置**（`lane.rect.Y`），
+		// 而图层会被纵向偏移贴图（幅值平移）—— 若烘进图层，纵向拖动时它会跟着波形一起跑。
+		// 因此它在整幅重绘里由这里绘制，宽基底快路径则由 `PaintLaneDividers` 补画一次。
+		const float dividerY = lane.rect.Y;
+		if (!m_renderDecorOnly && !m_renderWide && dividerY >= m_plotRect.Y - 1.0f &&
+		    dividerY <= m_plotRect.Y + m_plotRect.Height)
+		{
+			const float dividerSegments[4] = {lane.rect.X, dividerY, lane.rect.X + lane.rect.Width, dividerY};
+			const std::uint32_t dividerColor =
+			    ((laneIndex == 0) ? m_theme->axisLine : m_theme->borderStrong) | 0xFF000000u;
+			UiDrawSolidLines(g, gridClip, dividerSegments, 1, dividerColor,
+			                 (laneIndex == 0) ? 2 : static_cast<int>(kLaneDividerWidth));
+		}
+
+		// 内侧纵轴标尺作为覆盖层绘制：每个刻度数值带半透明底，保证在波形之上仍清晰可读，
+		// 同时只在数值背后遮挡波形，不牺牲波形本身的可见范围。
+		// ⚠️ 渲染「宽缓冲区」时跳过 Y 轴刻度与图例：它们锚定在网格左缘、随视界横向移动，
+		// 而宽缓冲区会被平移截取，装饰必须由前台叠加层（装饰层缓存）单独绘制。
+		if (!m_renderWide)
+		{
+			const bool showLabels = (lane.rect.Height >= 34.0f * m_scale);
+			float lastLabelY = -1.0e9f;
+
+			// 网格较矮时同步收紧标签行距，让密度随可用高度提升而不是整片被过滤掉。
+			const float labelMinGap =
+			    std::min(kYLabelMinGap * m_scale,
+			             lane.rect.Height / static_cast<float>(yTickTarget + 1));
+
+			// 先收集需要绘制的数值底板：合并成一次 FillPath（几十个小圆角矩形逐个填充
+			// 会带来明显的 GDI+ 调用开销），文字再逐个绘制（GDI 文本无法合批）。
+			std::vector<gd::RectF> pills;
+			std::vector<std::wstring> pillTexts;
+			std::vector<bool> pillZero;
+			for (const double tick : yTicks)
+			{
+				if (!showLabels)
+				{
+					break;
+				}
+
+				const float y = ValueToY(tick, lane);
+				if (y < lane.rect.Y - 1.0f || y > lane.rect.Y + lane.rect.Height + 1.0f)
+				{
+					continue;
+				}
+				if (std::fabs(y - lastLabelY) < labelMinGap)
+				{
+					continue;
+				}
+				lastLabelY = y;
+
+				const std::wstring raw = FormatTick(tick, yStep);
+				const float textWidth = UiMeasureTextWidth(m_fonts->monoSmall, raw);
+				const float pillHeight = 17.0f * m_scale;
+				const gd::RectF pill(lane.rect.X + kLaneLabelPad * m_scale, y - pillHeight * 0.5f,
+				                     std::min(textWidth + 8.0f * m_scale,
+				                              lane.rect.Width - 2.0f * kLaneLabelPad * m_scale),
+				                     pillHeight);
+				if (pill.Width <= 0.0f)
+				{
+					continue;
+				}
+				// 与图例重叠时不再跳过：标尺值先绘制，随后绘制的图例会盖在其上层
+				// （顶层始终为图例），因此两者都不丢失。
+				// 数值**完全**移出可见区时才不绘制；只要还有一部分在区内就绘制未被遮挡的部分
+				// （裁剪交给 GDI 文本的 ETO_CLIPPED 与下面的底板夹取共同保证）。
+				const float visibleTop = std::max(pill.Y, clipTop);
+				const float visibleBottom = std::min(pill.Y + pill.Height, clipBottom);
+				if (visibleBottom <= visibleTop)
+				{
+					continue;
+				}
+
+				pills.push_back(gd::RectF(pill.X, visibleTop, pill.Width, visibleBottom - visibleTop));
+				pillTexts.push_back(
+				    UiEllipsize(raw, m_fonts->monoSmall, pill.Width - 6.0f * m_scale));
+				pillZero.push_back(tick == 0.0);
+			}
+
+			// 记录胶囊矩形（供装饰层绘制/贴回；略微外扩以容纳圆角与文字边缘）。
+			for (const gd::RectF& pill : pills)
+			{
+				m_decorRects.push_back(gd::RectF(pill.X - 2.0f * m_scale, pill.Y - 1.0f * m_scale,
+				                                 pill.Width + 4.0f * m_scale, pill.Height + 2.0f * m_scale));
+			}
+			// 命中装饰缓存：跳过重绘（文字 + 圆角底板），由上层整块贴回。
+			// ⚠️ 底板是**圆角且不透明**：装饰位图带 alpha，圆角之外必须保持全透明，
+			// 贴回时才能透出当前波形（避免"圆角外多出一圈直角白边"）。
+			if (!m_useDecorCache)
+			{
+				UiFillRoundRects(g, pills, 3.0f * m_scale, m_theme->cardBg | 0xFF000000u);
+				for (std::size_t index = 0; index < pills.size(); ++index)
+				{
+					const gd::RectF& pill = pills[index];
+					// 用 UiTextAtClipped 保证长文本不越过绘图区（GDI 文本不受 GDI+ 裁剪约束）。
+					UiTextAtClipped(g, pillTexts[index], m_fonts->monoSmall, pill.X + 4.0f * m_scale,
+					                gd::RectF(pill.X + 4.0f * m_scale, pill.Y, pill.Width - 8.0f * m_scale,
+					                          pill.Height),
+					                pillZero[index] ? m_theme->text : m_theme->textMuted,
+					                clipRectForLabels);
+				}
+			}
+		}
+
+		if (!m_renderWide && lane.rect.Height >= 24.0f * m_scale)
+		{
+			PaintLaneLegend(g, laneIndex, lane, clipTop, clipBottom);
+		}
+
+		g.Restore(saveState);
+	}
+
+	void PlotView::PaintLaneDividers(gd::Graphics& g) const
+	{
+		if (m_theme == nullptr)
+		{
+			return;
+		}
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			const gd::RectF& rect = m_lanes[index].rect;
+			const float dividerY = rect.Y;
+			if (dividerY < m_plotRect.Y - 1.0f || dividerY > m_plotRect.Y + m_plotRect.Height)
+			{
+				continue;
+			}
+			const float segments[4] = {rect.X, dividerY, rect.X + rect.Width, dividerY};
+			const std::uint32_t dividerColor =
+			    ((index == 0) ? m_theme->axisLine : m_theme->borderStrong) | 0xFF000000u;
+			// GDI 批绘不受 GDI+ 裁剪约束 → 显式给出只覆盖该分界线附近的裁剪矩形。
+			const gd::RectF clip(m_area.X, dividerY - 4.0f * m_scale, m_area.Width, 8.0f * m_scale);
+			UiDrawSolidLines(g, clip, segments, 1, dividerColor,
+			                 (index == 0) ? 2 : static_cast<int>(kLaneDividerWidth));
+		}
+	}
+
+	void PlotView::PaintLaneDerivedOverlays(gd::Graphics& g, int laneIndex, const LaneVisual& lane) const
+	{
+		if (m_tab == nullptr || laneIndex < 0 ||
+		    laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return;
+		}
+		const Lane& tabLane = Tab().Lanes()[static_cast<std::size_t>(laneIndex)];
+		const bool centerOn = tabLane.edgeCenter;
+		const bool meanFilterOn = tabLane.meanFilter;
+		const bool weakPeakOn = tabLane.weakPeak;
+		if (!centerOn && !meanFilterOn && !weakPeakOn)
+		{
+			return;
+		}
+		const int saveState = g.Save();
+		g.SetClip(lane.rect, gd::CombineModeIntersect);
+		for (const SignalRef& ref : tabLane.signals)
+		{
+			const ResolvedSignal resolved = ResolveSignal(ref);
+			if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
+			{
+				continue;
+			}
+			if (centerOn)
+			{
+				const Lane::EdgeCenterItem* centerItem = tabLane.FindEdgeCenterItem(ref);
+				if (centerItem != nullptr)
+				{
+					PaintMeanFilterCurve(g, resolved, lane, centerItem->points, centerItem->iterations);
+				}
+			}
+			if (meanFilterOn)
+			{
+				const Lane::MeanFilterItem* item = tabLane.FindMeanFilterItem(ref);
+				if (item != nullptr)
+				{
+					PaintMeanFilterCurve(g, resolved, lane, item->points, item->iterations);
+				}
+			}
+			if (weakPeakOn)
+			{
+				// 每个信号用自己的「增强等级 + 迭代次数」（与面板滑块、构建新信号完全一致）。
+				const Lane::WeakPeakItem* item = tabLane.FindWeakPeakItem(ref);
+				if (item != nullptr)
+				{
+					const int amountPercent =
+					    std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, item->amountPercent));
+					const int boostIterations = std::max(
+					    kWeakPeakIterationsMin,
+					    std::min(kWeakPeakIterationsMaxLimit, item->iterations));
+					PaintWeakPeakCurve(g, resolved, lane, amountPercent, boostIterations);
+				}
+			}
+		}
+		g.Restore(saveState);
+	}
+
+	void PlotView::PaintLaneLegend(gd::Graphics& g, int laneIndex, const LaneVisual& lane, float visibleTop,
+	                               float visibleBottom)
+	{
+		if (m_tab == nullptr || laneIndex < 0 || laneIndex >= static_cast<int>(m_tab->Lanes().size()))
+		{
+			return;
+		}
+
+		// 图例固定在网格左上角：网格被滚动出可视区时整体跳过，避免文字溢出到工具栏。
+		const gd::RectF legendBand(lane.rect.X + kLegendPad * m_scale,
+		                           lane.rect.Y + kLegendPad * m_scale, lane.rect.Width,
+		                           kLegendHeight * m_scale);
+		if (!IsFullyVisible(legendBand, visibleTop, visibleBottom))
+		{
+			return;
+		}
+
+		const std::vector<SignalRef>& laneSignals = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)].signals;
+		const bool multiGroup = LaneSpansMultipleGroups(laneIndex);
+
+		const float top = legendBand.Y;
+		const float height = kLegendHeight * m_scale;
+		const float swatchSize = kLegendSwatchSize * m_scale;
+		const float maxX = lane.rect.X + lane.rect.Width - kLanePadding * m_scale;
+
+		// 网格编号徽标（图例左侧）：与左侧信号面板每行末尾的 “GX” 徽标样式完全一致。
+		// 矩形由 LaneBadgeRect 统一计算，绘制与命中测试因此永远一致。
+		const gd::RectF badgeRect = LaneBadgeRect(laneIndex);
+		const float badgeHeight = kLaneBadgeHeight * m_scale;
+		float cursorX = badgeRect.X + badgeRect.Width + kLaneBadgeGap * m_scale;
+
+		// 图例条目的托底 = **与 GX 编号徽标完全同款**（用户明确要求）：
+		//   * 高度与徽标相同（`bgadeRect` 的上下边界一模一样，因此"上下边距相同"）；
+		//   * 圆角 = 高度的一半（胶囊形），与徽标的 `badgeHeight * 0.5f` 一致；
+		//   * 配色与描边宽度也与徽标一致（`cardBg/border`，选中态 `accentSoft/accent`）；
+		//   * 水平内边距 = 胶囊半径（若小于半径，内容会溢出圆角之外）。
+		//   * 文本改用**更小的字体**（`uiTiny`）：原用 `uiSmall` 时文字几乎顶满胶囊高度。
+		// ⚠️ 托底矩形**同时就是命中矩形**（看到的与点得到的严格一致）。
+		const float plateHeight = badgeHeight;
+		const float plateTop = badgeRect.Y;
+		const float platePadX = plateHeight * 0.5f;
+
+		// ------------------------------------------------------------------
+		// 1) 几何：算出"放得下"的条目及其矩形（**唯一来源**，命中 / 装饰 / 绘制共用）。
+		// ------------------------------------------------------------------
+		struct LegendItem
+		{
+			SignalRef ref;
+			float left = 0.0f;			// 色块左缘
+			float width = 0.0f;			// 条目**内容**宽度（色块 + 间距 + 文本）
+			float plateWidth = 0.0f;	// 托底宽度（内容 + 两侧内边距）
+			float textWidth = 0.0f;
+			std::wstring label;
+			bool selected = false;
+		};
+		std::vector<LegendItem> items;
+		int visibleCount = 0;
+		float contentRight = cursorX;
+		{
+			float probeX = cursorX;
+			for (const SignalRef& ref : laneSignals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
+				{
+					continue;
+				}
+				++visibleCount;
+				std::wstring label = BuildLegendText(*resolved.data);
+				if (multiGroup && resolved.group != nullptr)
+				{
+					label += L" · " + resolved.group->name;
+				}
+				const float maxTextWidth = kLegendMaxTextWidth * m_scale;
+				const float fullTextWidth = UiMeasureTextWidth(m_fonts->uiTiny, label);
+				const float textWidth = std::min(fullTextWidth, maxTextWidth);
+				const float contentWidth = swatchSize + 5.0f * m_scale + textWidth;
+				const float plateWidth = contentWidth + platePadX * 2.0f;
+				if (probeX + plateWidth > maxX)
+				{
+					break;		// 空间不足：其余条目省略，下方用 "+N" 提示
+				}
+				LegendItem item;
+				item.ref = ref;
+				item.left = probeX + platePadX;		// 色块左缘（托底内缩一个内边距）
+				item.width = contentWidth;
+				item.plateWidth = plateWidth;
+				item.textWidth = textWidth;
+				item.label = (fullTextWidth > maxTextWidth)
+				                 ? UiEllipsize(label, m_fonts->uiTiny, maxTextWidth)
+				                 : label;
+				item.selected = (SelectedRef() == ref);
+				items.push_back(std::move(item));
+				probeX += plateWidth + kLegendItemGap * m_scale;
+			}
+			contentRight = probeX;
+		}
+		const auto PlateRect = [&](const LegendItem& item)
+		{
+			return gd::RectF(item.left - platePadX, plateTop, item.plateWidth, plateHeight);
+		};
+		// 条目托底 = 与 GX 编号徽标同一套风格的**胶囊形圆角矩形**（半径 = 高度的一半）。
+		const float plateRadius = plateHeight * 0.5f;
+		// 「+N」（图例空间不足）与「（无可见信号）」提示的矩形。
+		// ⚠️ 它们同样属于装饰层、必须登记进 `m_decorRects`：否则会被画进装饰位图
+		// 却因不在贴回列表里而永远看不见。
+		const bool hasMoreText = (visibleCount > static_cast<int>(items.size())) &&
+		                         (contentRight + 20.0f * m_scale <= maxX);
+		const bool hasEmptyText = (visibleCount == 0);
+		const gd::RectF moreTextRect(contentRight, top, 24.0f * m_scale, height);
+		const gd::RectF emptyTextRect(legendBand.X, top, lane.rect.Width, height);
+
+		// ------------------------------------------------------------------
+		// 2) 命中矩形：**无论是否命中装饰缓存都必须重建**。
+		//    整幅重绘路径会先清空 `m_legendHits`；若这里因为"装饰缓存命中"而提前返回、
+		//    不写入新矩形，图例的悬停高亮 / 点击选中 / 双击改名就会**全部失效**
+		//（用户报告："用中键移动过视角之后图例点不动、悬停也没反应"）。
+		// ------------------------------------------------------------------
+		for (auto iterator = m_legendHits.begin(); iterator != m_legendHits.end();)
+		{
+			if (m_tab->LaneOfSignal(iterator->ref) == laneIndex)
+			{
+				iterator = m_legendHits.erase(iterator);
+			}
+			else
+			{
+				++iterator;
+			}
+		}
+		for (const LegendItem& item : items)
+		{
+			const ResolvedSignal resolved = ResolveSignal(item.ref);
+			LegendHit hit;
+			hit.ref = item.ref;
+			hit.rect = PlateRect(item);
+			hit.radius = plateRadius;
+			hit.swatch =
+			    gd::RectF(item.left, plateTop + (plateHeight - swatchSize) * 0.5f, swatchSize, swatchSize);
+			hit.text = gd::RectF(item.left + swatchSize + 5.0f * m_scale, plateTop,
+			                     std::max(8.0f, item.textWidth + 2.0f), plateHeight);
+			hit.label = item.label;
+			// 「选中」与「悬停」用同一套配色（用户明确要求），因此文字色在这里也按选中态取。
+			hit.textColor = item.selected ? m_theme->textStrong : m_theme->text;
+			if (resolved.style != nullptr)
+			{
+				hit.swatchColor = resolved.style->color;
+				hit.swatchOpacity = resolved.style->opacity;
+			}
+			m_legendHits.push_back(std::move(hit));
+			if (m_editTarget == PlotEditTarget::SIGNAL_NAME && m_editSignal == item.ref)
+			{
+				m_editFieldRect = PlateRect(item);
+			}
+		}
+
+		// 装饰矩形：**逐块**（徽标一块 + 每个条目一块），而不是覆盖整条图例带 ——
+		// 覆盖整条带没有必要，且逐块能减少装饰层贴图面积。
+		m_decorRects.push_back(badgeRect);
+		for (const LegendItem& item : items)
+		{
+			m_decorRects.push_back(PlateRect(item));
+		}
+		if (hasEmptyText)
+		{
+			m_decorRects.push_back(emptyTextRect);
+		}
+		if (hasMoreText)
+		{
+			m_decorRects.push_back(moreTextRect);
+		}
+
+		// 命中装饰缓存：徽标与图例的像素改由装饰层贴回，跳过重绘（命中矩形已在上方重建）。
+		if (m_useDecorCache)
+		{
+			return;
+		}
+
+		// ------------------------------------------------------------------
+		// 3) 绘制。托底是**圆角矩形**（与 GX 编号徽标同风格）：
+		//    "一个 GX 标签，只是内容换成了图例信息"（用户明确要求）。
+		//    ⚠️ **不再铺任何外扩的不透明直角底色**：装饰位图带 alpha，圆角之外必须保持
+		//    全透明，贴回时才能透出**当前**波形 —— 否则圆角外会多出一圈"直角白边"。
+		//    ⚠️ 徽标与条目的**悬停 / 激活高亮不在这里**（随鼠标变化，画在贴图之后，
+		//    见 PaintLegendHighlight）—— 否则会被缓存冻结，悬停时看不到任何反馈。
+		// ------------------------------------------------------------------
+		{
+			UiFillRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->cardBg);
+			UiDrawRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->border, 1.0f);
+			UiText(g, L"G" + std::to_wstring(laneIndex + 1), m_fonts->monoSmall, badgeRect,
+			       m_theme->text, TextAlign::CENTER);
+
+			for (const LegendItem& item : items)
+			{
+				const ResolvedSignal resolved = ResolveSignal(item.ref);
+				if (resolved.data == nullptr || resolved.style == nullptr)
+				{
+					continue;
+				}
+				const gd::RectF plate = PlateRect(item);
+				// 选中态 = 悬停态配色（`accentSoft` 底 + `accent` 描边），
+				// 与 GX 编号徽标的鼠标悬停效果完全一致。
+				UiFillRoundRect(g, plate, plateRadius,
+				                item.selected ? m_theme->accentSoft : m_theme->cardBg);
+				UiDrawRoundRect(g, plate, plateRadius,
+				                item.selected ? m_theme->accent : m_theme->border, 1.0f);
+
+				// 改名编辑态：整块托底变成输入框（与左侧列表双击改名一致）。
+				if (m_editTarget == PlotEditTarget::SIGNAL_NAME && m_editSignal == item.ref)
+				{
+					UiDrawEditField(g, plate, m_edit, m_fonts->uiTiny, m_scale);
+					continue;
+				}
+
+				UiDrawSwatch(g,
+				             gd::RectF(item.left, plateTop + (plateHeight - swatchSize) * 0.5f,
+				                       swatchSize, swatchSize),
+				             resolved.style->color, resolved.style->opacity, 1.5f * m_scale, m_scale);
+				UiText(g, item.label, m_fonts->uiTiny,
+				       gd::RectF(item.left + swatchSize + 5.0f * m_scale, plateTop,
+				                 std::max(8.0f, item.textWidth + 2.0f), plateHeight),
+				       item.selected ? m_theme->textStrong : m_theme->text, TextAlign::LEFT);
+			}
+		}
+
+		if (hasEmptyText)
+		{
+			UiText(g, L"（无可见信号）", m_fonts->uiTiny, emptyTextRect, m_theme->textMuted,
+			       TextAlign::LEFT);
+		}
+		else if (hasMoreText)
+		{
+			// 图例空间不足时提示剩余信号数量，避免误认为信号丢失。
+			const std::wstring moreText =
+			    L"+" + std::to_wstring(visibleCount - static_cast<int>(items.size()));
+			UiText(g, moreText, m_fonts->uiTiny, moreTextRect, m_theme->textMuted, TextAlign::LEFT);
+		}
+	}
+
+	bool PlotView::IsFullyVisible(const gd::RectF& rect, float visibleTop, float visibleBottom)
+	{
+		return (rect.Y >= visibleTop - 0.5f) && (rect.Y + rect.Height <= visibleBottom + 0.5f);
+	}
+
+	void PlotView::PaintTimeAxis(gd::Graphics& g, const std::vector<double>& timeTicks, double timeStep)
+	{
+		const float axisY = m_plotRect.Y + m_plotRect.Height;
+		// 时间轴的轴线与刻度线同样走 GDI 批量绘制（理由见 PaintLane 中的说明）。
+		const gd::RectF axisClip(m_area.X, m_area.Y, m_area.Width, m_area.Height);
+		const std::uint32_t axisColor = m_theme->axisLine | 0xFF000000u;
+		{
+			const float axisSegment[4] = {m_plotRect.X, axisY, m_plotRect.X + m_plotRect.Width, axisY};
+			UiDrawSolidLines(g, axisClip, axisSegment, 1, axisColor);
+		}
+
+		// 时间轴列名（取自首个可见信号所属分组的第一条时间轴），贴左侧绘制。
+		std::wstring axisName = L"时间";
+		if (m_dataSet != nullptr && m_tab != nullptr)
+		{
+			for (std::size_t groupIndex = 0; groupIndex < m_dataSet->GroupCount(); ++groupIndex)
+			{
+				if (!m_tab->GroupHasVisible(static_cast<int>(groupIndex)))
+				{
+					continue;
+				}
+				const SignalGroup* group = m_dataSet->GroupAt(static_cast<int>(groupIndex));
+				if (group != nullptr && !group->axes.empty() && !group->axes.front().name.empty())
+				{
+					axisName = group->axes.front().name;
+					// CSV 中该列通常直接叫 "time"，这里补上时间单位秒便于阅读；
+					// 若列名自带单位描述（以右括号结尾）则不重复追加。
+					if (axisName.back() != L')')
+					{
+						axisName += L" (s)";
+					}
+				}
+				break;
+			}
+		}
+
+		const float nameWidth =
+		    std::min(UiMeasureTextWidth(m_fonts->monoSmall, axisName) + 8.0f * m_scale,
+		             m_plotRect.Width * 0.4f);
+		const gd::RectF nameRect(m_plotRect.X + 2.0f * m_scale, axisY + 3.0f * m_scale, nameWidth,
+		                         std::max(0.0f, m_timeAxisRect.Height - 5.0f * m_scale));
+		UiText(g, UiEllipsize(axisName, m_fonts->monoSmall, nameWidth), m_fonts->monoSmall, nameRect,
+		       m_theme->textMuted, TextAlign::LEFT);
+
+		const float labelWidth = 96.0f * m_scale;
+
+		// 五等分子刻度线：在相邻主刻度之间插入 4 条短刻度（更长的主刻度在最前绘制，
+		// 短刻度与主刻度重合的位置跳过），便于目视读取中间时刻。
+		const double minorStep = timeStep / static_cast<double>(kMinorDivisions);
+		std::vector<double> minorTicks;
+		BuildTicks(Tab().ViewMin(), Tab().ViewMax(), minorStep, minorTicks);
+		std::vector<float> minorSegments;
+		std::vector<float> majorSegments;
+		minorSegments.reserve(minorTicks.size() * 4);
+		majorSegments.reserve(timeTicks.size() * 4);
+		for (const double tick : minorTicks)
+		{
+			const double majorIndex = tick / timeStep;
+			if (std::fabs(majorIndex - std::floor(majorIndex + 0.5)) < 1.0e-6)
+			{
+				continue;
+			}
+			const float x = TimeToX(tick);
+			if (x < m_plotRect.X - 1.0f || x > m_plotRect.X + m_plotRect.Width + 1.0f)
+			{
+				continue;
+			}
+			minorSegments.insert(minorSegments.end(), {x, axisY, x, axisY + 3.0f * m_scale});
+		}
+
+		for (const double tick : timeTicks)
+		{
+			const float x = TimeToX(tick);
+			if (x < m_plotRect.X - 1.0f || x > m_plotRect.X + m_plotRect.Width + 1.0f)
+			{
+				continue;
+			}
+			majorSegments.insert(majorSegments.end(), {x, axisY, x, axisY + 4.0f * m_scale});
+		}
+		if (!minorSegments.empty())
+		{
+			UiDrawSolidLines(g, axisClip, minorSegments.data(), minorSegments.size() / 4, axisColor);
+		}
+		if (!majorSegments.empty())
+		{
+			UiDrawSolidLines(g, axisClip, majorSegments.data(), majorSegments.size() / 4, axisColor);
+		}
+
+		for (const double tick : timeTicks)
+		{
+			const float x = TimeToX(tick);
+			if (x < m_plotRect.X - 1.0f || x > m_plotRect.X + m_plotRect.Width + 1.0f)
+			{
+				continue;
+			}
+
+			// 刻度标签夹在绘图区横向范围内，并与左侧列名互不重叠。
+			float labelX = x - labelWidth * 0.5f;
+			labelX = std::max(m_plotRect.X, std::min(labelX, m_plotRect.X + m_plotRect.Width - labelWidth));
+			const gd::RectF labelRect(labelX, axisY + 4.0f * m_scale, labelWidth,
+			                          std::max(0.0f, m_timeAxisRect.Height - 6.0f * m_scale));
+			if (labelRect.X < nameRect.X + nameRect.Width)
+			{
+				continue;
+			}
+			UiText(g, FormatTick(tick, timeStep), m_fonts->monoSmall, labelRect, m_theme->textMuted,
+			       TextAlign::CENTER);
+		}
+	}
+
+
+	void PlotView::DrawLabelOutline(gd::Graphics& g, const gd::RectF& rect, float radius,
+	                                std::uint32_t outlineColor)
+	{
+		// 描边色由 `UiContrastInk` 与文字色一起算出（恒与文字色反相、且随信号配色线性变化）。
+		// 这样胶囊压在同类色背景或信号曲线上时仍有清晰的边界。
+		UiDrawRoundRect(g, rect, radius, outlineColor, 1.0f);
+	}
+
+	void PlotView::PaintCursorOffViewTip(gd::Graphics& g, const gd::RectF& labelRect, bool offRight,
+	                                     std::uint32_t color)
+	{
+		// 三角画在读数胶囊的**外侧**（尖端朝外、指向光标实际所在的那一侧），
+		// 与胶囊之间留出 `kMarkerTriangleGap` 的空白。
+		//
+		// 旧实现把三角压在胶囊**上沿**且水平居中：既没有间隙（看起来像胶囊长了个尖角），
+		// 又与网格内"数据点越界"的画法（左右三角）不统一。现在两处共用同一套画法。
+		const float arm = kMarkerTriangleArm * m_scale;
+		const float depth = kMarkerTriangleDepth * m_scale;
+		const float gap = kMarkerTriangleGap * m_scale;
+		const float centerY = labelRect.Y + labelRect.Height * 0.5f;
+		gd::PointF outer[3];
+		if (offRight)
+		{
+			const float baseX = labelRect.X + labelRect.Width + gap;
+			outer[0] = gd::PointF(baseX, centerY - arm);
+			outer[1] = gd::PointF(baseX, centerY + arm);
+			outer[2] = gd::PointF(baseX + depth, centerY);
+		}
+		else
+		{
+			const float baseX = labelRect.X - gap;
+			outer[0] = gd::PointF(baseX, centerY - arm);
+			outer[1] = gd::PointF(baseX, centerY + arm);
+			outer[2] = gd::PointF(baseX - depth, centerY);
+		}
+		gd::SolidBrush brush(ToGdiColor(color));
+		g.FillPolygon(&brush, outer, 3);
+	}
+
+	void PlotView::PaintCursor(gd::Graphics& g, const std::vector<LaneVisual>& lanes)
+	{
+		if (!Tab().CursorEnabled() || m_tab == nullptr)
+		{
+			return;
+		}
+
+		const bool doubleMode = (Tab().CursorMode() == PlotCursorMode::DOUBLE);
+		const int cursorCount = doubleMode ? 2 : 1;
+
+		// 本次绘制重新统计已占用的取值标注矩形（用于避免多个信号/光标的内容互相覆盖）。
+		// 先把底部的时间读数/差值标签也登记进去：它们在取值标注之后绘制、会盖在上面，
+		// 因此取值标注必须主动避开它们，否则会被遮住半个字。
+		m_cursorLabelRects.clear();
+		for (int which = 1; which <= cursorCount; ++which)
+		{
+			const gd::RectF timeRect = CursorLabelRect(which);
+			if (timeRect.Width > 0.0f)
+			{
+				m_cursorLabelRects.push_back(timeRect);
+			}
+		}
+		if (doubleMode)
+		{
+			bool insideAxis = false;
+			const gd::RectF spanRect = CursorSpanRect(insideAxis);
+			if (spanRect.Width > 0.0f)
+			{
+				m_cursorLabelRects.push_back(spanRect);
+			}
+		}
+
+		// 重叠时把"最近操作过的那条光标"的内容画在上层，因此先画另一条。
+		const int iterations[2] = { (m_activeCursor == 2) ? 1 : 2, (m_activeCursor == 2) ? 2 : 1 };
+
+		// 增量差值**只**显示在"右侧光标"上。右侧 = 时间较大的那条，随拖拽实时变化：
+		// 把右光标拖到左边后，增量会自动改由新的右侧光标显示。
+		const int rightCursor = (Tab().CursorTime() <= Tab().CursorTimeAlt()) ? 2 : 1;
+
+		// ---- 光标竖线 + 顶部把手 ----
+		for (int pass = 0; pass < cursorCount; ++pass)
+		{
+			const int which = doubleMode ? iterations[pass] : 1;
+			const double time = (which == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
+			const float x = TimeToX(time);
+			if (x < m_plotRect.X - 2.0f || x > m_plotRect.X + m_plotRect.Width + 2.0f)
+			{
+				// 光标滞留在可视区外：不画竖线（其取值/时间读数会在下面贴边显示）。
+				continue;
+			}
+
+			const bool hot = (m_hoverCursor == which);
+			const std::uint32_t color = CursorColor();
+			const float lineTop = m_plotRect.Y;
+			const float lineBottom = m_timeAxisRect.Y + m_timeAxisRect.Height;
+			UiDrawLine(g, x, lineTop, x, lineBottom, color, (hot ? 2.0f : 1.4f) * m_scale);
+
+			// 顶部三角把手（两条光标样式一致，靠颜色区分）。
+			const float arm = 5.0f * m_scale;
+			gd::PointF points[3];
+			points[0] = gd::PointF(x - arm, lineTop);
+			points[1] = gd::PointF(x + arm, lineTop);
+			points[2] = gd::PointF(x, lineTop + arm * 1.4f);
+			gd::SolidBrush handle(ToGdiColor(color));
+			g.FillPolygon(&handle, points, 3);
+		}
+
+		// ---- 数据点取值标注 ----
+		for (int pass = 0; pass < cursorCount; ++pass)
+		{
+			const int which = doubleMode ? iterations[pass] : 1;
+			const double time = (which == 2) ? Tab().CursorTimeAlt() : Tab().CursorTime();
+			const double otherTime = (which == 2) ? Tab().CursorTime() : Tab().CursorTimeAlt();
+			// 只有右侧光标显示增量差值（左光标只显示自身取值）。
+			const bool showDelta = doubleMode && (which == rightCursor);
+
+			// 光标在可视区外时，把标注"钉"在对应的网格边上，保证取值仍然可见。
+			// 具体是否越界（左右/上下）由 MakeDataMarker 逐点判定。
+			const float pinX = CursorDisplayX(which);
+			const float rawX = TimeToX(time);
+
+			for (std::size_t laneIndex = 0; laneIndex < lanes.size(); ++laneIndex)
+			{
+				const LaneVisual& lane = lanes[laneIndex];
+				const float clipTop = std::max(lane.rect.Y, m_plotRect.Y);
+				const float clipBottom =
+				    std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height);
+				if (clipBottom <= clipTop)
+				{
+					continue;
+				}
+
+				for (const SignalRef& ref : m_tab->Lanes()[laneIndex].signals)
+				{
+					const ResolvedSignal resolved = ResolveSignal(ref);
+					if (resolved.data == nullptr || resolved.style == nullptr ||
+					    resolved.axis == nullptr || !resolved.visible)
+					{
+						continue;
+					}
+
+					const bool interpolate = (resolved.style->mode != DrawMode::SCATTER);
+					double value = 0.0;
+					if (!SampleDisplayedSignalAt(*resolved.axis, *resolved.data, *resolved.style, time,
+					                             interpolate, value))
+					{
+						continue;
+					}
+					// 取值读数必须与画出来的波形一致：同样套用系数/绝对值/镜像。
+					value = ApplyDrawTransform(*resolved.style, value);
+
+					const float rawY = ValueToY(value, lane);
+					// 上下越界的数据点不再被丢弃：与左右越界一致，贴边绘制指示方向的三角。
+					// 上边界额外预留光标顶部把手的高度，避免数据点三角压住光标把手。
+					// 非 const：上下越界时下面还要把方向三角与取值标注纵向居中对齐。
+					DataMarker marker =
+					    MakeDataMarker(rawX, rawY, pinX, clipTop, clipBottom, kCursorHandleReserve * m_scale);
+
+					const std::uint32_t signalColor = StyleColor(*resolved.style);
+
+					// 数据点：视界内为圆点，任一方向越界时改为贴边三角。
+					// **先算好取值标注、再画数据点**：上下越界时的方向三角需要与标注
+					// 纵向居中对齐，而标注的位置要经过避让处理才能最终确定。
+					const float radius = 3.4f * m_scale;
+
+					// 取值标注：底色用信号色，文字/描边用随信号配色线性相关的高对比度配色。
+					std::wstring text = FormatValue(value);
+					if (showDelta)
+					{
+						double otherValue = 0.0;
+						if (SampleDisplayedSignalAt(*resolved.axis, *resolved.data, *resolved.style, otherTime,
+					                               interpolate, otherValue))
+						{
+							otherValue = ApplyDrawTransform(*resolved.style, otherValue);
+							const double delta = value - otherValue;
+							// 增量 = 右侧光标取值 − 左侧光标取值，包在圆括号里并按差值显式给出正负号。
+							text += L" (";
+							text += (delta < 0.0) ? L"-" : L"+";
+							text += FormatValue(std::fabs(delta));
+							text += L")";
+						}
+					}
+
+					const float textWidth = UiMeasureTextWidth(m_fonts->monoSmall, text) + 10.0f * m_scale;
+					const float textHeight = 17.0f * m_scale;
+					// 左右越界时三角贴在视界内侧、尖端朝外；数值标注必须放在三角的**内侧**
+					// 并留出 `kMarkerTriangleGap` 的空白，否则三角会像"多出来的一个尖角"
+					// （用户报告的"三角形与数值显示部分没有间隔"）。
+					float labelLeft;
+					if (marker.offLeft)
+					{
+						labelLeft = marker.x + kMarkerTriangleGap * m_scale;
+					}
+					else if (marker.offRight)
+					{
+						labelLeft = marker.x - kMarkerTriangleGap * m_scale - textWidth;
+					}
+					else
+					{
+						labelLeft = pinX + radius + 4.0f * m_scale;
+						if (labelLeft + textWidth > m_plotRect.X + m_plotRect.Width - 2.0f * m_scale)
+						{
+							labelLeft = pinX - radius - 4.0f * m_scale - textWidth;
+						}
+					}
+					labelLeft = std::max(
+					    m_plotRect.X + 2.0f * m_scale,
+					    std::min(labelLeft, m_plotRect.X + m_plotRect.Width - textWidth - 2.0f * m_scale));
+					float labelTop = marker.y - textHeight * 0.5f;
+					labelTop = std::max(clipTop + 1.0f * m_scale,
+					                    std::min(labelTop, clipBottom - textHeight - 1.0f * m_scale));
+					gd::RectF labelRect(labelLeft, labelTop, textWidth, textHeight);
+
+					// 多个信号的取值标注可能落在同一位置（数据点重合或过近）：
+					// 依次向下（再向上）避让已占用的标注，保证不会互相覆盖。
+					PlaceCursorLabel(labelRect, labelTop, textHeight, clipTop, clipBottom);
+
+					// 越界方向三角与最终落位的取值标注纵向居中对齐
+					// （用户明确要求“超过上下视界时三角需要与显示的数值居中对齐”；
+					//   左右越界时同样对齐，避免三角与数值错行、看起来不协调）。
+					if (marker.offUp || marker.offDown || marker.offLeft || marker.offRight)
+					{
+						marker.y = labelRect.Y + labelRect.Height * 0.5f;
+					}
+					PaintDataMarker(g, marker, radius, signalColor, m_theme->cardBg);
+
+					const UiInk ink = UiContrastInk(signalColor);
+					UiFillRoundRect(g, labelRect, 3.0f * m_scale, WithAlpha(signalColor, 0xF0));
+					DrawLabelOutline(g, labelRect, 3.0f * m_scale, ink.outline);
+					UiText(g, text, m_fonts->monoSmall, labelRect, ink.text, TextAlign::CENTER);
+
+					// 「边沿计数（中心轴）」/「均值滤波」/「弱峰调整」开启时，纵向光标还要额外标注
+					// **派生曲线**在该时刻的取值（它不是信号，因此单独标注，不并入上面的取值文案）。
+					// 三条曲线只是曲线来源不同，标注规则完全一致，故共用同一段绘制逻辑。
+					// ⚠️ 曲线只取「可见区间 ∪ 两个光标时刻 ± 保护带」的窗口（与绘制共用缓存），
+					// 因此拖动光标/拖动参数滑块都不会触发整条曲线的重算。
+					const auto paintDerivedCapsule = [&](DerivedCurveKind kind, int points,
+					                                     int iterations, int amountPercent,
+					                                     const std::wstring& suffix)
+					{
+						const int sampleIndex = FindNearestSample(*resolved.axis, time);
+						if (sampleIndex < 0)
+						{
+							return;
+						}
+						const int otherIndex =
+						    showDelta ? FindNearestSample(*resolved.axis, otherTime) : -1;
+						// 本函数**只需要光标所在采样点处的派生取值**（以及双光标另一端的取值），
+						// 因此把请求窗口收窄到「需要的那几个下标」即可，均值滤波半径造成的取值
+						// 依赖由 `CurveSpanFor` 自身的保护带负责覆盖。
+						//
+						// ⚠️ 绝不能把窗口扩成「光标 ↔ 视界边缘」的并集：光标停在视界之外（例如
+						// 平移视界把光标甩到很远，或光标远离当前缩放区间）时会得到一个上千万采样的
+						// 巨大窗口，超过缓存上限后走一次性缓冲 → **每帧重算整段滤波**，
+						// 实测单帧 300ms+（用户报告的"平移/拖动光标异常卡顿"的直接原因）。
+						std::size_t begin = static_cast<std::size_t>(sampleIndex);
+						std::size_t end = begin + 1;
+						if (otherIndex >= 0)
+						{
+							const std::size_t other = static_cast<std::size_t>(otherIndex);
+							begin = std::min(begin, other);
+							end = std::max(end, other + 1);
+						}
+						std::size_t spanBegin = 0;
+						const std::vector<float>* curvePtr =
+						    CurveSpanFor(kind, *resolved.data, points, iterations, amountPercent, begin,
+						                 end, spanBegin, true);
+						if (curvePtr == nullptr)
+						{
+							return;
+						}
+						const auto curveValueAt = [curvePtr, spanBegin](int index) -> double
+						{
+							if (index < 0 || static_cast<std::size_t>(index) < spanBegin ||
+							    (static_cast<std::size_t>(index) - spanBegin) >= curvePtr->size())
+							{
+								return std::numeric_limits<double>::quiet_NaN();
+							}
+							return static_cast<double>((*curvePtr)[static_cast<std::size_t>(index) -
+							                                       spanBegin]);
+						};
+						const double derivedValue = curveValueAt(sampleIndex);
+						if (!std::isfinite(derivedValue))
+						{
+							return;
+						}
+
+						const float rawCenterY = ValueToY(derivedValue, lane);
+						DataMarker centerMarker = MakeDataMarker(
+						    rawX, rawCenterY, pinX, clipTop, clipBottom, kCursorHandleReserve * m_scale);
+						// 派生数据点的配色与原始信号一致（便于一一对应）；
+						// 但**始终按线段模式**绘制（不跟随原信号的散点模式）。
+						const std::uint32_t centerColor = StyleColor(*resolved.style);
+
+						// 取值文本：数值在前，尾缀「（中心轴）/（均值滤波）」；双光标的右侧光标
+						// 还要附上增量，形如「（+0.0008 中心轴）」（参考常规信号的增量显示）。
+						std::wstring centerText = FormatValue(derivedValue);
+						centerText += L"（";
+						if (showDelta)
+						{
+							const double otherDerived = curveValueAt(otherIndex);
+							if (std::isfinite(otherDerived))
+							{
+								const double delta = derivedValue - otherDerived;
+								centerText += (delta < 0.0) ? L"-" : L"+";
+								centerText += FormatValue(std::fabs(delta));
+								centerText += L" ";
+							}
+						}
+						centerText += suffix;
+						centerText += L"）";
+
+						const float centerTextWidth =
+						    UiMeasureTextWidth(m_fonts->monoSmall, centerText) + 10.0f * m_scale;
+						// 与常规取值标注同一规则：左右越界时标注要让开外侧的方向三角。
+						float centerLeft;
+						if (centerMarker.offLeft)
+						{
+							centerLeft = centerMarker.x + kMarkerTriangleGap * m_scale;
+						}
+						else if (centerMarker.offRight)
+						{
+							centerLeft = centerMarker.x - kMarkerTriangleGap * m_scale - centerTextWidth;
+						}
+						else
+						{
+							centerLeft = pinX + radius + 4.0f * m_scale;
+							if (centerLeft + centerTextWidth >
+							    m_plotRect.X + m_plotRect.Width - 2.0f * m_scale)
+							{
+								centerLeft = pinX - radius - 4.0f * m_scale - centerTextWidth;
+							}
+						}
+						centerLeft = std::max(
+						    m_plotRect.X + 2.0f * m_scale,
+						    std::min(centerLeft,
+						             m_plotRect.X + m_plotRect.Width - centerTextWidth - 2.0f * m_scale));
+						float centerTop = centerMarker.y - textHeight * 0.5f;
+						centerTop = std::max(clipTop + 1.0f * m_scale,
+						                     std::min(centerTop, clipBottom - textHeight - 1.0f * m_scale));
+						gd::RectF centerRect(centerLeft, centerTop, centerTextWidth, textHeight);
+						PlaceCursorLabel(centerRect, centerTop, textHeight, clipTop, clipBottom);
+						// 与原始信号同一规则：越界方向三角与取值标注纵向居中对齐。
+						if (centerMarker.offUp || centerMarker.offDown || centerMarker.offLeft ||
+						    centerMarker.offRight)
+						{
+							centerMarker.y = centerRect.Y + centerRect.Height * 0.5f;
+						}
+						PaintDataMarker(g, centerMarker, radius, centerColor, m_theme->cardBg);
+						// 颜色样式与原始信号一致（同底色/同描边/同文字配色）。
+						const UiInk centerInk = UiContrastInk(centerColor);
+						UiFillRoundRect(g, centerRect, 3.0f * m_scale, WithAlpha(centerColor, 0xE0));
+						DrawLabelOutline(g, centerRect, 3.0f * m_scale, centerInk.outline);
+						UiText(g, centerText, m_fonts->monoSmall, centerRect, centerInk.text,
+						       TextAlign::CENTER);
+					};
+
+					if (m_tab->Lanes()[laneIndex].edgeCenter)
+					{
+						// 只标注被勾选（即真正绘制了曲线）的信号。
+						const Lane::EdgeCenterItem* centerItem =
+						    m_tab->Lanes()[laneIndex].FindEdgeCenterItem(ref);
+						if (centerItem != nullptr)
+						{
+							paintDerivedCapsule(DerivedCurveKind::MEAN_FILTER, centerItem->points,
+							                    centerItem->iterations, 0, L"中心轴");
+						}
+					}
+					if (m_tab->Lanes()[laneIndex].meanFilter)
+					{
+						// 只标注被勾选（即真正绘制了预览曲线）的信号。
+						const Lane::MeanFilterItem* meanItem =
+						    m_tab->Lanes()[laneIndex].FindMeanFilterItem(ref);
+						if (meanItem != nullptr)
+						{
+							paintDerivedCapsule(DerivedCurveKind::MEAN_FILTER, meanItem->points,
+							                    meanItem->iterations, 0, L"均值滤波");
+						}
+					}
+					if (m_tab->Lanes()[laneIndex].weakPeak)
+					{
+						// 弱峰调整曲线：同样是只标注被勾选的信号，尾缀为「弱峰调整」。
+						const Lane::WeakPeakItem* boostItem =
+						    m_tab->Lanes()[laneIndex].FindWeakPeakItem(ref);
+						if (boostItem != nullptr)
+						{
+							const int amountPercent =
+							    std::max(kWeakPeakAmountMin, std::min(kWeakPeakAmountMax, boostItem->amountPercent));
+							const int iterations = std::max(
+							    kWeakPeakIterationsMin,
+							    std::min(kWeakPeakIterationsMaxLimit, boostItem->iterations));
+							paintDerivedCapsule(DerivedCurveKind::WEAK_PEAK, 0, iterations, amountPercent,
+							                    L"弱峰调整");
+						}
+					}
+				}
+			}
+		}
+
+		// ---- 底部：时间读数 + 双光标差值 ----
+		if (m_editTarget == PlotEditTarget::CURSOR_TIME ||
+		    m_editTarget == PlotEditTarget::CURSOR_SPAN)
+		{
+			PaintEditField(g);
+			return;
+		}
+
+		for (int pass = 0; pass < cursorCount; ++pass)
+		{
+			const int which = doubleMode ? iterations[pass] : 1;
+			const gd::RectF labelRect = CursorLabelRect(which);
+			if (labelRect.Width <= 0.0f)
+			{
+				continue;
+			}
+			const bool highlighted = (m_cursorHover && m_hoverCursor == which);
+			const std::uint32_t color = CursorColor();
+			bool offRight = false;
+			const bool offView = CursorOffViewSide(which, offRight);
+			if (offView)
+			{
+				PaintCursorOffViewTip(g, labelRect, offRight, color);
+			}
+			UiFillRoundRect(g, labelRect, 3.0f * m_scale,
+			                highlighted ? color : WithAlpha(color, 0xE0));
+			const UiInk ink = UiContrastInk(color);
+			DrawLabelOutline(g, labelRect, 3.0f * m_scale, ink.outline);
+			UiText(g, FormatCursorTime(which == 2 ? Tab().CursorTimeAlt() : Tab().CursorTime()),
+			       m_fonts->monoSmall, labelRect, ink.text, TextAlign::CENTER);
+		}
+
+		// 双光标差值：显示在两条时间读数中间（时间轴上方；过近时落到主时间轴上）。
+		if (doubleMode)
+		{
+			bool insideAxis = false;
+			const gd::RectF spanRect = CursorSpanRect(insideAxis);
+			m_cursorSpanRect = spanRect;
+			if (spanRect.Width > 0.0f && spanRect.Height > 0.0f)
+			{
+				// 样式与光标时间读数完全一致（同底色/同描边/同文字配色）。
+				const std::uint32_t color = CursorColor();
+				// 双光标同时越界到同一侧时，差值标签也在视界之外 → 同样画方向三角。
+				bool offRight1 = false, offRight2 = false;
+				const bool off1 = CursorOffViewSide(1, offRight1);
+				const bool off2 = CursorOffViewSide(2, offRight2);
+				if (off1 && off2 && offRight1 == offRight2)
+				{
+					PaintCursorOffViewTip(g, spanRect, offRight1, color);
+				}
+				UiFillRoundRect(g, spanRect, 3.0f * m_scale,
+				                m_spanHover ? color : WithAlpha(color, 0xE0));
+				const UiInk ink = UiContrastInk(color);
+				DrawLabelOutline(g, spanRect, 3.0f * m_scale, ink.outline);
+				UiText(g, FormatSpanText(CursorSpan()), m_fonts->monoSmall, spanRect, ink.text,
+				       TextAlign::CENTER);
+			}
+		}
+		else
+		{
+			m_cursorSpanRect = gd::RectF();
+		}
+	}
+
+	PlotView::EdgePanelLayout PlotView::EdgePanelLayoutFor(int laneIndex, EdgePanelKind kind) const
+	{
+		EdgePanelLayout layout;
+		if (m_tab == nullptr || m_fonts == nullptr || laneIndex < 0 ||
+		    laneIndex >= static_cast<int>(m_tab->Lanes().size()) ||
+		    laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return layout;
+		}
+		const Lane& lane = m_tab->Lanes()[static_cast<std::size_t>(laneIndex)];
+		const bool centerAxis = (kind == EdgePanelKind::CENTER);
+		const bool meanFilter = (kind == EdgePanelKind::MEAN);
+		const bool weakPeak = (kind == EdgePanelKind::PEAK);
+		// 「均值滤波」与「弱峰调整」共用同一套「逐条目 + 底部按钮」排布。
+		const bool itemized = (centerAxis || meanFilter || weakPeak);
+		const bool hasButton = (meanFilter || weakPeak);
+		const bool enabled = meanFilter ? lane.meanFilter
+		                                : (weakPeak ? lane.weakPeak
+		                                             : (centerAxis ? lane.edgeCenter : lane.edgeCount));
+		const bool open = meanFilter ? lane.meanFilterPanelOpen
+		                             : (weakPeak ? lane.weakPeakPanelOpen
+		                                          : (centerAxis ? lane.edgeCenterPanelOpen : lane.edgePanelOpen));
+		if (!enabled || !open)
+		{
+			return layout;
+		}
+
+		int rowCount = 0;
+		for (const SignalRef& ref : lane.signals)
+		{
+			const ResolvedSignal resolved = ResolveSignal(ref);
+			if (resolved.data != nullptr && resolved.visible)
+			{
+				++rowCount;
+			}
+		}
+		if (rowCount <= 0)
+		{
+			return layout;
+		}
+		layout.rows = rowCount;
+
+		const float width = EdgePanelWidth(laneIndex, kind);
+		const float titleHeight = kEdgePanelTitleHeight * m_scale;
+		const float rowHeight = kEdgePanelRowHeight * m_scale;
+		const float pad = kEdgePanelPad * m_scale;
+		// 「中心轴边沿计数」「均值滤波」「弱峰调整」共用同一套「逐条目」排布，
+		// 因此不再有独立的底部编辑行；只有「边沿计数」保留两行文本式排版。
+		const float buttonHeight = hasButton ? (kEdgePanelButtonHeight * m_scale) : 0.0f;
+		const float rowsPerSignal = meanFilter ? 1.0f : 2.0f;
+
+		// 逐条目面板：每个条目 = 第一排（信号名 + 复选框）
+		// + 参数部分（**只在该条目被勾选时才占位**，因此面板高度随勾选数量动态变化）：
+		//   * MEAN / CENTER：一行「均值点数 X + 迭代次数 N」输入框（中心轴再多一行统计结果）；
+		//   * PEAK：两行滑块（调整幅度 % / 迭代次数 N），每个信号各有一套自己的参数。
+		const bool itemHasParams = (centerAxis || meanFilter || weakPeak);
+		const float weakPeakSliderRow = kWeakPeakSliderRowHeight * m_scale;
+		float meanRowHeight = 0.0f;
+		float itemsHeight = 0.0f;
+		float height = 0.0f;
+		if (itemized)
+		{
+			meanRowHeight = kEdgePanelMeanRowHeight * m_scale;
+			for (const SignalRef& ref : lane.signals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				if (resolved.data == nullptr || !resolved.visible)
+				{
+					continue;
+				}
+				itemsHeight += meanRowHeight;
+				const bool checked = meanFilter ? lane.MeanFilterEnabled(ref)
+				                                : (weakPeak ? lane.WeakPeakEnabled(ref)
+				                                             : lane.EdgeCenterEnabled(ref));
+				if (checked && itemHasParams)
+				{
+					if (weakPeak)
+					{
+						itemsHeight += weakPeakSliderRow * 2.0f;
+					}
+					else
+					{
+						itemsHeight += (kEdgePanelMeanEditHeight + kEdgePanelMeanRowGap) * m_scale;
+						if (centerAxis)
+						{
+							itemsHeight += kEdgePanelMeanRowHeight * m_scale;
+						}
+					}
+				}
+			}
+			// 底部按钮行：上方与条目之间、下方与面板下边界之间各留一个 `pad`，
+			// 与面板的左右内边距完全一致（原先按钮直接贴着下边框，看起来很不协调）。
+			height = titleHeight + pad + itemsHeight + pad + buttonHeight + (hasButton ? pad : 0.0f);
+		}
+		else
+		{
+			height = titleHeight + pad + static_cast<float>(rowCount) * rowHeight * rowsPerSignal + pad;
+		}
+
+		// 首次使用（位置为负）时自动放到绘图区右侧，并各网格依次错开，避免完全重叠。
+		const double storedX = meanFilter ? lane.meanFilterPanelX
+		                                  : (weakPeak ? lane.weakPeakPanelX
+		                                               : (centerAxis ? lane.edgeCenterPanelX : lane.edgePanelX));
+		const double storedY = meanFilter ? lane.meanFilterPanelY
+		                                  : (weakPeak ? lane.weakPeakPanelY
+		                                               : (centerAxis ? lane.edgeCenterPanelY : lane.edgePanelY));
+		float left = (storedX >= 0.0)
+		                 ? static_cast<float>(storedX)
+		                 : (m_plotRect.X + m_plotRect.Width - width - 16.0f * m_scale);
+		float top = (storedY >= 0.0)
+		                ? static_cast<float>(storedY)
+		                : (m_plotRect.Y + 16.0f * m_scale +
+		                   static_cast<float>(laneIndex) * 28.0f * m_scale);
+
+		// 面板始终限制在绘图区内（用户明确要求"可以在右侧的整个绘制区域拖动"）。
+		left = std::max(m_plotRect.X + 2.0f * m_scale,
+		                std::min(left, m_plotRect.X + m_plotRect.Width - width - 2.0f * m_scale));
+		top = std::max(m_plotRect.Y + 2.0f * m_scale,
+		               std::min(top, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale));
+
+		layout.panel = gd::RectF(left, top, width, height);
+		// 只有标题栏可以拖拽；✕ 位于标题栏右端，命中时优先按“关闭按钮”处理。
+		layout.title = gd::RectF(left, top, width, titleHeight);
+		const float closeSize = titleHeight;
+		layout.close = gd::RectF(left + width - closeSize, top, closeSize, closeSize);
+		if (itemized)
+		{
+			const float buttonRowHeight = kEdgePanelButtonHeight * m_scale;
+			if (hasButton)
+			{
+				// 底部按钮与面板下边界之间留出与左右、与内容相同的 `pad` 间距
+				//（原先按钮行直接贴着下边框，视觉上与其它元素不协调）；
+				// 面板高度已含这份 pad，因此这里只上移按钮行即可。
+				layout.button = gd::RectF(left + pad, top + height - pad - buttonRowHeight,
+				                          std::max(0.0f, width - pad * 2.0f), buttonRowHeight);
+			}
+
+			// 逐信号条目：第一排 = 名称 + 复选框（复选框靠右）；
+			// 参数部分：MEAN / CENTER = 一行两个输入框（中心轴再多一行统计结果）；
+			//           PEAK = 两行滑块（每个信号各有自己的等级与迭代次数）。
+			const float checkSize = kEdgePanelMeanCheckSize * m_scale;
+			const float fieldHeight = kEdgePanelMeanEditHeight * m_scale;
+			const float halfWidth = std::max(40.0f, (width - pad * 2.0f - 8.0f * m_scale) * 0.5f);
+			// 滑块行列宽（与 `EdgePanelWidth` 使用同一组算式，避免布局与宽度计算漂移）。
+			const float weakPeakLabelWidth = WeakPeakLabelColumnWidth(m_fonts->uiSmall);
+			const float weakPeakValueWidth = WeakPeakValueColumnWidth(m_fonts->monoSmall);
+			const float weakPeakResetSize = kWeakPeakResetButtonSize * m_scale;
+			const float weakPeakResetGap = kWeakPeakResetGap * m_scale;
+			const float weakPeakTrackHeight = kWeakPeakTrackHeight * m_scale;
+			const float weakPeakTrackLeft = left + pad + weakPeakLabelWidth + 6.0f * m_scale;
+			const float weakPeakTrackWidth =
+			    std::max(10.0f * m_scale,
+			             (left + width - pad - weakPeakValueWidth - weakPeakResetGap -
+			              weakPeakResetSize - 6.0f * m_scale) -
+			                 weakPeakTrackLeft);
+			float rowY = top + titleHeight + pad;
+			for (const SignalRef& ref : lane.signals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				if (resolved.data == nullptr || !resolved.visible)
+				{
+					continue;
+				}
+
+				layout.rowRefs.push_back(ref);
+				layout.rowChecks.push_back(gd::RectF(
+				    left + width - pad - checkSize, rowY + (meanRowHeight - checkSize) * 0.5f, checkSize,
+				    checkSize));
+				const bool checked = meanFilter ? lane.MeanFilterEnabled(ref)
+				                                : (weakPeak ? lane.WeakPeakEnabled(ref)
+				                                             : lane.EdgeCenterEnabled(ref));
+				if (weakPeak)
+				{
+					// 每个被勾选的信号各有两行滑块：调整幅度（-400% – +400%）与迭代次数（1 … 上限）。
+					if (checked)
+					{
+						const float levelRowTop = rowY + meanRowHeight;
+						const float iterRowTop = levelRowTop + weakPeakSliderRow;
+						const gd::RectF levelTrack(
+						    weakPeakTrackLeft,
+						    levelRowTop + (weakPeakSliderRow - weakPeakTrackHeight) * 0.5f,
+						    weakPeakTrackWidth, weakPeakTrackHeight);
+						const gd::RectF iterTrack(
+						    weakPeakTrackLeft,
+						    iterRowTop + (weakPeakSliderRow - weakPeakTrackHeight) * 0.5f,
+						    weakPeakTrackWidth, weakPeakTrackHeight);
+						layout.rowLevelTracks.push_back(levelTrack);
+						layout.rowLevelValues.push_back(gd::RectF(
+						    levelTrack.X + levelTrack.Width + 6.0f * m_scale, levelRowTop,
+						    weakPeakValueWidth, weakPeakSliderRow));
+						layout.rowIterTracks.push_back(iterTrack);
+						layout.rowIterValues.push_back(gd::RectF(
+						    iterTrack.X + iterTrack.Width + 6.0f * m_scale, iterRowTop,
+						    weakPeakValueWidth, weakPeakSliderRow));
+						// 每行滑块右侧的**复位按钮**（与数值列同一右边界，保证两行上下对齐）。
+						const float resetX = levelTrack.X + levelTrack.Width + 6.0f * m_scale +
+						                     weakPeakValueWidth + weakPeakResetGap;
+						layout.rowLevelResets.push_back(
+						    gd::RectF(resetX, levelRowTop + (weakPeakSliderRow - weakPeakResetSize) * 0.5f,
+						              weakPeakResetSize, weakPeakResetSize));
+						layout.rowIterResets.push_back(
+						    gd::RectF(resetX, iterRowTop + (weakPeakSliderRow - weakPeakResetSize) * 0.5f,
+						              weakPeakResetSize, weakPeakResetSize));
+					}
+					else
+					{
+						layout.rowLevelTracks.push_back(gd::RectF());
+						layout.rowLevelValues.push_back(gd::RectF());
+						layout.rowLevelResets.push_back(gd::RectF());
+						layout.rowIterTracks.push_back(gd::RectF());
+						layout.rowIterValues.push_back(gd::RectF());
+						layout.rowIterResets.push_back(gd::RectF());
+					}
+					layout.rowPoints.push_back(gd::RectF());
+					layout.rowIterations.push_back(gd::RectF());
+					layout.rowStats.push_back(gd::RectF());
+
+					rowY += meanRowHeight;
+					if (checked)
+					{
+						rowY += weakPeakSliderRow * 2.0f;
+					}
+					continue;
+				}
+				if (checked && itemHasParams)
+				{
+					const float editTop = rowY + meanRowHeight;
+					layout.rowPoints.push_back(
+					    gd::RectF(left + pad, editTop, halfWidth, fieldHeight));
+					layout.rowIterations.push_back(
+					    gd::RectF(left + pad + halfWidth + 8.0f * m_scale, editTop, halfWidth, fieldHeight));
+					if (centerAxis)
+					{
+						layout.rowStats.push_back(
+						    gd::RectF(left + pad, editTop + fieldHeight, width - pad * 2.0f,
+						              kEdgePanelMeanRowHeight * m_scale));
+					}
+					else
+					{
+						layout.rowStats.push_back(gd::RectF());
+					}
+				}
+				else
+				{
+					layout.rowPoints.push_back(gd::RectF());
+					layout.rowIterations.push_back(gd::RectF());
+					layout.rowStats.push_back(gd::RectF());
+				}
+
+				rowY += meanRowHeight;
+				if (checked && itemHasParams)
+				{
+					rowY += (kEdgePanelMeanEditHeight + kEdgePanelMeanRowGap) * m_scale;
+					if (centerAxis)
+					{
+						rowY += kEdgePanelMeanRowHeight * m_scale;
+					}
+				}
+			}
+		}
+		return layout;
+	}
+
+	void PlotView::PaintDataMarker(gd::Graphics& g, const DataMarker& marker, float radius,
+	                               std::uint32_t fillColor, std::uint32_t ringColor) const
+	{
+		gd::SolidBrush ring(ToGdiColor(ringColor));
+		gd::SolidBrush fill(ToGdiColor(fillColor));
+		const float arm = kMarkerTriangleArm * m_scale;		/**< 三角“半宽/半高”（垂直于朝向的半边长）。 */
+		const float depth = kMarkerTriangleDepth * m_scale;	/**< 三角沿朝向的深度（与光标把手同比例）。 */
+
+		// 越界三角：**尖端朝外**（指向数据点所在的方向，即视界之外），底边在网格内侧；
+		// 三角外接矩形在横/纵两个方向都与锚点**居中**（上下越界时因此与取值标注纵向居中）。
+		// 旧实现方向是反的（上越界画下三角、左越界画右三角），而且内三角按“平移”而非
+		// “向质心收缩”构造，填充色会从三角尖端戳出来。
+		const auto paintTriangle = [&](const gd::PointF* outer)
+		{
+			g.FillPolygon(&ring, outer, 3);
+			const float centerX = (outer[0].X + outer[1].X + outer[2].X) / 3.0f;
+			const float centerY = (outer[0].Y + outer[1].Y + outer[2].Y) / 3.0f;
+			// 按质心等比收缩得到内三角：几何上恒在外三角内部，描边宽度也就均匀了。
+			const float shrink = 0.58f;
+			gd::PointF inner[3];
+			for (int index = 0; index < 3; ++index)
+			{
+				inner[index] = gd::PointF(centerX + (outer[index].X - centerX) * shrink,
+				                          centerY + (outer[index].Y - centerY) * shrink);
+			}
+			g.FillPolygon(&fill, inner, 3);
+		};
+
+		// 左右越界：三角指向左/右（视界之外）。
+		if (marker.offLeft || marker.offRight)
+		{
+			const bool offLeft = marker.offLeft;
+			const float tipX = offLeft ? (marker.x - depth) : (marker.x + depth);
+			const float baseX = marker.x;
+			gd::PointF outer[3];
+			outer[0] = gd::PointF(baseX, marker.y - arm);
+			outer[1] = gd::PointF(baseX, marker.y + arm);
+			outer[2] = gd::PointF(tipX, marker.y);
+			paintTriangle(outer);
+			return;
+		}
+
+		// 上下越界：三角指向上/下（视界之外），外接矩形以 marker.y 为纵向中心
+		// → 与取值标注的纵向中心对齐。
+		if (marker.offUp || marker.offDown)
+		{
+			const bool offUp = marker.offUp;
+			const float half = depth * 0.5f;
+			const float tipY = offUp ? (marker.y - half) : (marker.y + half);
+			const float baseY = offUp ? (marker.y + half) : (marker.y - half);
+			gd::PointF outer[3];
+			outer[0] = gd::PointF(marker.x - arm, baseY);
+			outer[1] = gd::PointF(marker.x + arm, baseY);
+			outer[2] = gd::PointF(marker.x, tipY);
+			paintTriangle(outer);
+			return;
+		}
+
+		// 视界内：常规圆点。
+		g.FillEllipse(&ring, marker.x - radius - 1.2f * m_scale, marker.y - radius - 1.2f * m_scale,
+		              (radius + 1.2f * m_scale) * 2.0f, (radius + 1.2f * m_scale) * 2.0f);
+		g.FillEllipse(&fill, marker.x - radius, marker.y - radius, radius * 2.0f, radius * 2.0f);
+	}
+
+	void PlotView::PaintDerivedCurve(gd::Graphics& g, const ResolvedSignal& resolved,
+	                                 const LaneVisual& lane, const std::vector<float>& curve,
+	                                 std::size_t curveBegin) const
+	{
+		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
+		{
+			return;
+		}
+
+		const std::vector<double>& time = resolved.axis->time;
+		const std::size_t count = std::min(time.size(), resolved.data->values.size());
+		if (count == 0 || m_plotRect.Width <= 1.0f || curve.empty())
+		{
+			return;
+		}
+
+		std::size_t begin = 0;
+		std::size_t end = 0;
+		VisibleIndexRange(*resolved.axis, count, begin, end, resolved.style->offsetTime);
+		if (end <= begin)
+		{
+			return;
+		}
+
+		const std::size_t visibleCount = end - begin;
+		const float limitTop = lane.rect.Y - lane.rect.Height * 4.0f;
+		const float limitBottom = lane.rect.Y + lane.rect.Height * 5.0f;
+
+		// 派生曲线的颜色：与原信号**同色相**但大幅拉开明度，使其与原始波形形成高对比
+		// （原信号改颜色时曲线随之改变，因为它是从信号色派生出来的）；透明度与原信号一致。
+		const unsigned int baseAlpha = static_cast<unsigned int>(
+		    std::max(0.0, std::min(1.0, static_cast<double>(resolved.style->opacity))) * 255.0 + 0.5);
+		const std::uint32_t derived = WithAlpha(HighContrastDerived(StyleColor(*resolved.style)),
+		                                        baseAlpha);
+
+		// 顶点预算与波形一致（每像素列两个顶点）。
+		// 交互期间进一步降到 1/2：派生曲线往往有 10 条（5 网格 × 均值滤波 + 弱峰调整），
+		// 顶点数就是绘制耗时；降低密度能让拖动参数滑块保持流畅，
+		// 松手后下一帧立刻恢复全密度（用户要求的"低分辨率 → 高分辨率"）。
+		std::size_t budget =
+		    static_cast<std::size_t>(std::max(1.0f, m_plotRect.Width)) * kPolylinePointsPerPixel;
+		budget = std::max(budget, kMinPolylinePoints);
+		budget = std::min(budget, kMaxPolylinePoints);
+		if (m_fastFrame)
+		{
+			budget = std::max<std::size_t>(kMinPolylinePoints, budget / 2);
+		}
+		const std::size_t stride = std::max<std::size_t>(1, visibleCount / std::max<std::size_t>(1, budget));
+
+		std::vector<gd::PointF> points;
+		std::vector<std::size_t> breaks;
+		points.reserve(std::min<std::size_t>(visibleCount, budget) + 1);
+		bool inSegment = false;
+		// 「陡峭段」计数：用于判断抗锯齿是否值得付出（见下）。
+		std::size_t tallSegments = 0;
+		std::size_t totalSegments = 0;
+
+		for (std::size_t index = begin; index < end; index += stride)
+		{
+			// 水平镜像 = 数据反序：遍历下标映射到源下标后再取曲线值。
+			const std::size_t sourceIndex = SourceIndexFor(*resolved.style, count, index);
+			if (sourceIndex < curveBegin || (sourceIndex - curveBegin) >= curve.size())
+			{
+				inSegment = false;
+				continue;
+			}
+			const float sampled = curve[sourceIndex - curveBegin];
+			if (!std::isfinite(sampled))
+			{
+				inSegment = false;
+				continue;
+			}
+			float y = ValueToY(ApplyDrawTransform(*resolved.style, static_cast<double>(sampled)), lane);
+			y = static_cast<float>(ClampDouble(y, limitTop, limitBottom));
+			// 时间偏移：该采样画在 `t + offsetTime` 处。
+			const float x = TimeToX(time[index] + resolved.style->offsetTime);
+			if (!inSegment)
+			{
+				breaks.push_back(points.size());
+				points.push_back(gd::PointF(x, y));
+				inSegment = true;
+			}
+			else
+			{
+				if (std::fabs(y - points.back().Y) > lane.rect.Height * 0.5f)
+				{
+					++tallSegments;
+				}
+				++totalSegments;
+				points.push_back(gd::PointF(x, y));
+			}
+		}
+
+		if (breaks.empty())
+		{
+			return;
+		}
+
+		// 派生曲线**恢复为抗锯齿折线**（与"之前"的显示效果一致）。
+		// 但抗锯齿在"陡峭段很多"的形状上代价极高（实测 2448 顶点 26~37ms，无抗锯齿仅 3.5ms），
+		// 而那种形状下抗锯齿的平滑作用几乎看不出来 —— 因此：
+		//   * ⚠️ **不再因交互（`m_fastFrame`）关闭抗锯齿**：波形基底（图层）始终是全质量抗锯齿，
+		//     若预览曲线在交互期间改成无抗锯齿，就会"比普通信号粗糙"（用户报告的观感下降）；
+		//     预览曲线只是叠加层，抗锯齿的代价与它自身的顶点数成正比（可见区间很小），可以承受。
+		//   * 陡峭段占比过高时（方波/编码器这类信号）仍关闭：那种形态下观感几乎无差别。
+		const bool spiky = (totalSegments > 0) && (tallSegments * 8 > totalSegments);
+		const int savedSmoothing = g.GetSmoothingMode();
+		if (spiky)
+		{
+			g.SetSmoothingMode(gd::SmoothingModeNone);
+		}
+		gd::Pen pen(ToGdiColor(derived), std::max(1.0f, resolved.style->lineWidth) * m_scale);
+		pen.SetLineJoin(gd::LineJoinRound);
+		pen.SetStartCap(gd::LineCapRound);
+		pen.SetEndCap(gd::LineCapRound);
+		for (std::size_t k = 0; k < breaks.size(); ++k)
+		{
+			const std::size_t start = breaks[k];
+			const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
+			if (stop <= start + 1)
+			{
+				continue;
+			}
+			g.DrawLines(&pen, points.data() + start, static_cast<INT>(stop - start));
+		}
+		g.SetSmoothingMode(static_cast<gd::SmoothingMode>(savedSmoothing));
+	}
+
+	void PlotView::PaintMeanFilterCurve(gd::Graphics& g, const ResolvedSignal& resolved,
+	                                    const LaneVisual& lane, int points, int iterations) const
+	{
+		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
+		{
+			return;
+		}
+		// 只取「可见区间 ± 保护带」的窗口（见 `CurveSpanFor`）：拖参数滑块不会重算整条曲线。
+		// 与「边沿计数（中心轴）」共用同一段绘制逻辑
+		//（同色相高对比度的派生配色 + 同透明度），只是曲线本身按多次迭代滤波计算。
+		const std::size_t count = std::min(resolved.axis->time.size(), resolved.data->values.size());
+		if (count == 0)
+		{
+			return;
+		}
+		// ⭐ 预览曲线一律按**整条信号**计算（`[0, count]`），与「构建为新信号」使用的
+		// `ComputeMovingAverageIterated(整段 values, ...)` 完全相同，因此预览与构建结果
+		// **逐位一致**（用户明确要求"预览显示效果要和构建为新信号一致"）。
+		// 整段窗口超过异步门槛时由后台线程计算，绘制线程本帧用已算好的旧曲线顶替，
+		// 因此不会阻塞交互；小信号同步计算。
+		std::size_t spanBegin = 0;
+		const std::vector<float>* curve = CurveSpanFor(DerivedCurveKind::MEAN_FILTER, *resolved.data,
+		                                              points, iterations, 0, 0, count, spanBegin, true);
+		if (curve == nullptr)
+		{
+			return;
+		}
+		PaintDerivedCurve(g, resolved, lane, *curve, spanBegin);
+	}
+
+	void PlotView::PaintWeakPeakCurve(gd::Graphics& g, const ResolvedSignal& resolved,
+	                                   const LaneVisual& lane, int amountPercent, int iterations) const
+	{
+		if (resolved.data == nullptr || resolved.axis == nullptr || resolved.style == nullptr)
+		{
+			return;
+		}
+		const std::size_t count = std::min(resolved.axis->time.size(), resolved.data->values.size());
+		if (count == 0)
+		{
+			return;
+		}
+		// 预览曲线一律按**整条信号**计算（与「构建为新信号」逐位一致），详见 `PaintMeanFilterCurve`。
+		std::size_t spanBegin = 0;
+		const std::vector<float>* curve = CurveSpanFor(DerivedCurveKind::WEAK_PEAK, *resolved.data, 0,
+		                                              iterations, amountPercent, 0, count, spanBegin,
+		                                              true);
+		if (curve == nullptr)
+		{
+			return;
+		}
+		// 派生曲线一律使用同一段绘制逻辑与配色规则（弱峰调整曲线同样如此）。
+		PaintDerivedCurve(g, resolved, lane, *curve, spanBegin);
+	}
+
+
+	bool PlotView::EnsurePanelCache()
+	{
+		// 图层只需覆盖绘图区（面板一律被夹在 m_plotRect 内），且**原点必须与客户区一致**：
+		// 面板绘制代码用的是客户区绝对坐标，而 `UiText` 走 GDI（不受 GDI+ 变换影响），
+		// 因此不能靠平移变换把坐标搬进一张小位图里。
+		const int width = static_cast<int>(std::ceil(m_area.X + m_area.Width));
+		const int height = static_cast<int>(std::ceil(m_area.Y + m_area.Height));
+		if (width <= 0 || height <= 0)
+		{
+			return false;
+		}
+		if (m_panelDc != nullptr && m_panelWidth == width && m_panelHeight == height)
+		{
+			return true;
+		}
+
+		ReleasePanelCache();
+
+		HDC screen = GetDC(nullptr);
+		if (screen == nullptr)
+		{
+			return false;
+		}
+		m_panelDc = CreateCompatibleDC(screen);
+		m_panelBitmap = CreateCompatibleBitmap(screen, width, height);
+		ReleaseDC(nullptr, screen);
+		if (m_panelDc == nullptr || m_panelBitmap == nullptr)
+		{
+			ReleasePanelCache();
+			return false;
+		}
+		m_panelOldBitmap = SelectObject(m_panelDc, m_panelBitmap);
+		m_panelWidth = width;
+		m_panelHeight = height;
+		m_panelValid = false;
+		return true;
+	}
+
+	void PlotView::ReleasePanelCache()
+	{
+		m_panelValid = false;
+		m_panelSlots.clear();
+		if (m_panelDc != nullptr)
+		{
+			if (m_panelOldBitmap != nullptr)
+			{
+				SelectObject(m_panelDc, m_panelOldBitmap);
+				m_panelOldBitmap = nullptr;
+			}
+			DeleteDC(m_panelDc);
+			m_panelDc = nullptr;
+		}
+		if (m_panelBitmap != nullptr)
+		{
+			DeleteObject(m_panelBitmap);
+			m_panelBitmap = nullptr;
+		}
+		m_panelWidth = 0;
+		m_panelHeight = 0;
+	}
+
+	bool PlotView::PanelRectInsideLayer(const gd::RectF& rect) const
+	{
+		if (m_panelDc == nullptr)
+		{
+			return false;
+		}
+		return rect.X >= 0.0f && rect.Y >= 0.0f &&
+		       rect.X + rect.Width <= static_cast<float>(m_panelWidth) &&
+		       rect.Y + rect.Height <= static_cast<float>(m_panelHeight);
+	}
+
+	std::uint64_t PlotView::PanelGlobalKey() const
+	{
+		std::uint64_t hash = 1469598103934665603ull;
+		const auto mix = [&hash](std::uint64_t value) { MixPanelKey(hash, value); };
+		const auto mixFloat = [&mix](float value)
+		{
+			std::uint32_t bits = 0;
+			std::memcpy(&bits, &value, sizeof(bits));
+			mix(bits);
+		};
+		const auto mixDouble = [&mix](double value)
+		{
+			std::uint64_t bits = 0;
+			std::memcpy(&bits, &value, sizeof(bits));
+			mix(bits);
+		};
+		const auto mixRect = [&mixFloat](const gd::RectF& rect)
+		{
+			mixFloat(rect.X);
+			mixFloat(rect.Y);
+			mixFloat(rect.Width);
+			mixFloat(rect.Height);
+		};
+		const auto mixRef = [&mix](const SignalRef& ref)
+		{
+			mix(ref.IsValid() ? 1ull : 0ull);
+			mix(static_cast<std::uint64_t>(ref.groupIndex));
+			mix(static_cast<std::uint64_t>(ref.signalIndex));
+		};
+
+		mixFloat(m_scale);
+		mix(reinterpret_cast<std::uintptr_t>(m_theme));
+		mix(reinterpret_cast<std::uintptr_t>(m_fonts));
+		mixRect(m_plotRect);
+		mixRect(m_area);
+		mix(static_cast<std::uint64_t>(m_dragMode));
+		mix(static_cast<std::uint64_t>(m_laneDragFrom + 2));
+		mix(static_cast<std::uint64_t>(m_laneDragTarget + 2));
+		mix(static_cast<std::uint64_t>(m_laneDragMouseY + 4096));
+		mix(static_cast<std::uint64_t>(m_hoverLane + 2));
+		mix(m_cursorHover ? 1ull : 0ull);
+		mix(static_cast<std::uint64_t>(m_hoverCursor + 2));
+		mix(static_cast<std::uint64_t>(m_activeCursor));
+		mix(m_dragMoved ? 1ull : 0ull);
+		mixRect(m_rubberRect);
+		mixRef(m_hoverSignal);
+		mixRef(m_hoverLegend);
+		mixRef(m_dragSignal);
+		mixRef(SelectedRef());
+		mix(static_cast<std::uint64_t>(m_edgePanelDragLane + 2));
+		mix(static_cast<std::uint64_t>(m_edgePanelDragKind));
+
+		// 时间光标与统计区间：面板标题的时间后缀、以及「中心轴」行的上升/下降沿数字都依赖它们。
+		mix(static_cast<std::uint64_t>(Tab().CursorMode()));
+		mixDouble(Tab().CursorTime());
+		mixDouble(Tab().CursorTimeAlt());
+		mix(EdgeRangeActive() ? 1ull : 0ull);
+		mixDouble(EdgeRangeMin());
+		mixDouble(EdgeRangeMax());
+
+		// 跟随鼠标的叠加层（悬停光晕 / 图例半高亮 / 信号拖拽虚影 / 提示动画）位置随时在变：
+		// 只要它存在，就把所有面板缓存作废，避免它的残影被一起缓存进面板像素。
+		const bool mouseDrivenOverlay =
+		    m_hoverSignal.IsValid() || m_hoverLegend.IsValid() ||
+		    m_dragMode == PlotDragMode::MOVE_SIGNAL || m_dragMode == PlotDragMode::RUBBER_SELECT ||
+		    HintNeedsAnimation();
+		mix(mouseDrivenOverlay ? 1ull : 0ull);
+		if (mouseDrivenOverlay)
+		{
+			mix(static_cast<std::uint64_t>(m_mouseX + 4096));
+			mix(static_cast<std::uint64_t>(m_mouseY + 4096));
+		}
+
+		for (const LaneVisual& visual : m_lanes)
+		{
+			mixRect(visual.rect);
+			// ⚠️ **幅值范围（yMin/yMax）刻意不入面板指纹**：面板内容（标题、条目、滑块、
+			// 参数与边沿统计）都不依赖网格的幅值区间；而「拖拽平移的纵向分量」会每帧小幅
+			// 改动它 —— 一旦计入，拖拽期间**全部**悬浮面板都会每帧重画一遍
+			//（实测 20 个面板：竖向拖拽 167ms/帧 vs 横向 38ms/帧，正是用户报告的
+			//  "左右流畅、上下/斜向卡顿"）。代价只是面板不透明底（95.7%）背后那 4%
+			// 透出的底层像素可能旧一帧，与既有取舍一致（实测最大色差 ≤ 29 级）。
+		}
+
+		if (m_tab != nullptr)
+		{
+			const std::vector<Lane>& lanes = m_tab->Lanes();
+			for (const Lane& lane : lanes)
+			{
+				mixFloat(static_cast<float>(lane.edgePanelX));
+				mixFloat(static_cast<float>(lane.edgePanelY));
+				mixFloat(static_cast<float>(lane.edgeCenterPanelX));
+				mixFloat(static_cast<float>(lane.edgeCenterPanelY));
+				mixFloat(static_cast<float>(lane.meanFilterPanelX));
+				mixFloat(static_cast<float>(lane.meanFilterPanelY));
+				mixFloat(static_cast<float>(lane.weakPeakPanelX));
+				mixFloat(static_cast<float>(lane.weakPeakPanelY));
+				mix(lane.edgePanelOpen ? 1ull : 0ull);
+				mix(lane.edgeCenterPanelOpen ? 1ull : 0ull);
+				mix(lane.meanFilterPanelOpen ? 1ull : 0ull);
+				mix(lane.weakPeakPanelOpen ? 1ull : 0ull);
+				mix(lane.edgeValueValid ? 1ull : 0ull);
+				mixDouble(lane.edgeValue);
+			}
+		}
+
+		// ⚠️ **面板层序也是"全局"状态**：层序变化（点击某个面板把它置顶）会让"谁盖住谁"改变，
+		// 因此必须让所有面板缓存失效、按新层序整层重画（否则贴回的旧像素仍是旧层叠关系）。
+		for (const PanelRef& ref : m_panelOrder)
+		{
+			mix(static_cast<std::uint64_t>(ref.laneIndex + 2));
+			mix(static_cast<std::uint64_t>(ref.kind + 2));
+		}
+		return hash;
+	}
+
+	std::uint64_t PlotView::PanelSlotKey(int laneIndex, EdgePanelKind kind,
+	                                     const EdgePanelLayout& layout) const
+	{
+		std::uint64_t hash = 1469598103934665603ull;
+		const auto mix = [&hash](std::uint64_t value) { MixPanelKey(hash, value); };
+		const auto mixFloat = [&mix](float value)
+		{
+			std::uint32_t bits = 0;
+			std::memcpy(&bits, &value, sizeof(bits));
+			mix(bits);
+		};
+		const auto mixRect = [&mixFloat](const gd::RectF& rect)
+		{
+			mixFloat(rect.X);
+			mixFloat(rect.Y);
+			mixFloat(rect.Width);
+			mixFloat(rect.Height);
+		};
+		mix(static_cast<std::uint64_t>(laneIndex + 2));
+		mix(static_cast<std::uint64_t>(static_cast<int>(kind) + 2));
+		mixRect(layout.panel);
+		mixRect(layout.title);
+		mixRect(layout.close);
+		mixRect(layout.edit);
+		mixRect(layout.button);
+		mix(static_cast<std::uint64_t>(layout.rows));
+		for (const gd::RectF& rect : layout.rowChecks)
+		{
+			mixRect(rect);
+		}
+		for (const gd::RectF& rect : layout.rowPoints)
+		{
+			mixRect(rect);
+		}
+		for (const gd::RectF& rect : layout.rowIterations)
+		{
+			mixRect(rect);
+		}
+		for (const gd::RectF& rect : layout.rowStats)
+		{
+			mixRect(rect);
+		}
+
+		const Lane& lane = Tab().Lanes()[static_cast<std::size_t>(laneIndex)];
+		for (const SignalRef& ref : layout.rowRefs)
+		{
+			mix(ref.IsValid() ? 1ull : 0ull);
+			mix(static_cast<std::uint64_t>(ref.groupIndex));
+			mix(static_cast<std::uint64_t>(ref.signalIndex));
+			// 勾选状态与参数直接决定行文本与行高。
+			mix(lane.MeanFilterEnabled(ref) ? 1ull : 0ull);
+			mix(lane.EdgeCenterEnabled(ref) ? 1ull : 0ull);
+			mix(lane.WeakPeakEnabled(ref) ? 1ull : 0ull);
+			const Lane::MeanFilterItem* meanItem = lane.FindMeanFilterItem(ref);
+			mix(static_cast<std::uint64_t>(meanItem != nullptr ? meanItem->points + 2 : 0));
+			mix(static_cast<std::uint64_t>(meanItem != nullptr ? meanItem->iterations + 2 : 0));
+			const Lane::EdgeCenterItem* centerItem = lane.FindEdgeCenterItem(ref);
+			mix(static_cast<std::uint64_t>(centerItem != nullptr ? centerItem->points + 2 : 0));
+			mix(static_cast<std::uint64_t>(centerItem != nullptr ? centerItem->iterations + 2 : 0));
+			// 弱峰调整的逐信号参数（调整幅度 % + 迭代次数 + 该信号的滑块上限）直接显示在面板上：
+			// 上限决定迭代次数滑块的圆钮位置，因此也必须参与缓存键。
+			const Lane::WeakPeakItem* peakItem = lane.FindWeakPeakItem(ref);
+			mix(static_cast<std::uint64_t>(peakItem != nullptr ? peakItem->amountPercent + 2 : 0));
+			mix(static_cast<std::uint64_t>(peakItem != nullptr ? peakItem->iterations + 2 : 0));
+			mix(static_cast<std::uint64_t>(peakItem != nullptr ? peakItem->maxIterations + 2 : 0));
+		}
+
+		// ⚠️⚠️ **边沿统计的数字本身就是面板内容，必须进缓存键**（用户报告的缺陷根因）：
+		// 面板像素图层按本键缓存，而界面上的「上升沿 / 下降沿」是**分帧推进**出来的中间结果 ——
+		// 若这些数字不进键，则「统计推进 → 数字变化」不会让键变化 ⇒ 面板一直贴旧像素
+		// ⇒ 用户不动鼠标时统计永远停在“统计中…”或某个中间值，**只有移动鼠标**（改变别的键）
+		// 才会显示出早已算完的正确结果。
+		// ⇒ 把该面板当前要显示的 (上升沿, 下降沿, 是否扫完) 一并 mix 进去：推进会让键变化 ⇒
+		//    面板重绘 ⇒ 显示随进度更新，直到扫完（扫完后数字不再变，重新命中缓存）。
+		if (kind == EdgePanelKind::COUNT)
+		{
+			for (const SignalRef& ref : lane.signals)
+			{
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				if (resolved.data == nullptr || resolved.style == nullptr || resolved.axis == nullptr ||
+				    !resolved.visible)
+				{
+					continue;	// 与绘制时的可见性判定保持一致
+				}
+				std::size_t rising = 0;
+				std::size_t falling = 0;
+				bool complete = true;
+				EdgeCountsFor(*resolved.axis, *resolved.data, *resolved.style, lane.edgeValue,
+				              EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(), rising, falling, complete);
+				mix(static_cast<std::uint64_t>(rising));
+				mix(static_cast<std::uint64_t>(falling));
+				mix(complete ? 1ull : 0ull);
+			}
+		}
+		else if (kind == EdgePanelKind::CENTER)
+		{
+			for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
+			{
+				if (rowIndex >= layout.rowStats.size() || layout.rowStats[rowIndex].Width <= 0.0f)
+				{
+					continue;	// 与绘制时的条件一致：只有这一排才显示统计数字
+				}
+				const SignalRef& ref = layout.rowRefs[rowIndex];
+				const ResolvedSignal resolved = ResolveSignal(ref);
+				const Lane::EdgeCenterItem* item = lane.FindEdgeCenterItem(ref);
+				if (resolved.data == nullptr || resolved.style == nullptr || resolved.axis == nullptr ||
+				    item == nullptr)
+				{
+					continue;
+				}
+				std::size_t rising = 0;
+				std::size_t falling = 0;
+				bool complete = true;
+				EdgeCenterCountsFor(*resolved.axis, *resolved.data, *resolved.style, item->points,
+				                    item->iterations, EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(),
+				                    rising, falling, complete);
+				mix(static_cast<std::uint64_t>(rising));
+				mix(static_cast<std::uint64_t>(falling));
+				mix(complete ? 1ull : 0ull);
+			}
+		}
+
+		// 弱峰调整的滑块行矩形（每信号两行）。
+		for (const gd::RectF& rect : layout.rowLevelTracks)
+		{
+			mixRect(rect);
+		}
+		for (const gd::RectF& rect : layout.rowIterTracks)
+		{
+			mixRect(rect);
+		}
+		for (const gd::RectF& rect : layout.rowIterValues)
+		{
+			mixRect(rect);
+		}
+		// 弱峰调整每行滑块右侧的复位按钮（悬停高亮依赖它的精确矩形）。
+		for (const gd::RectF& rect : layout.rowLevelResets)
+		{
+			mixRect(rect);
+		}
+		for (const gd::RectF& rect : layout.rowIterResets)
+		{
+			mixRect(rect);
+		}
+
+		// 鼠标落在面板内时，✕ / 复选框 / 滑块 / 底部按钮的悬停态都依赖精确坐标。
+		const float margin = 6.0f * m_scale;
+		const gd::RectF hot(layout.panel.X - margin, layout.panel.Y - margin,
+		                    layout.panel.Width + margin * 2.0f,
+		                    layout.panel.Height + margin * 2.0f);
+		if (UiPointInRect(hot, static_cast<float>(m_mouseX), static_cast<float>(m_mouseY)))
+		{
+			mix(static_cast<std::uint64_t>(m_mouseX + 4096));
+			mix(static_cast<std::uint64_t>(m_mouseY + 4096));
+		}
+		return hash;
+	}
+
+	void PlotView::PaintEdgeCursor(gd::Graphics& g, const std::vector<LaneVisual>& lanes)
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+
+		std::vector<Lane>& tabLanes = m_tab->Lanes();
+		const std::size_t count = std::min(lanes.size(), tabLanes.size());
+		const std::uint32_t color = CursorColor();
+		const UiInk ink = UiContrastInk(color);
+
+		// ---- 横向光标（线与两端把手 + 左侧幅值读数）----
+		for (std::size_t index = 0; index < count; ++index)
+		{
+			Lane& tabLane = tabLanes[index];
+			if (!tabLane.edgeCount)
+			{
+				continue;
+			}
+			const LaneVisual& visual = lanes[index];
+			const float clipTop = std::max(visual.rect.Y, m_plotRect.Y);
+			const float clipBottom =
+			    std::min(visual.rect.Y + visual.rect.Height, m_plotRect.Y + m_plotRect.Height);
+			if (clipBottom <= clipTop)
+			{
+				continue;
+			}
+
+			// 首次绘制时把横向光标落在可见幅值范围的中点。
+			if (!tabLane.edgeValueValid)
+			{
+				tabLane.edgeValue = (visual.yMin + visual.yMax) * 0.5;
+				tabLane.edgeValueValid = true;
+			}
+
+			const float lineY =
+			    std::max(clipTop, std::min(ValueToY(tabLane.edgeValue, visual), clipBottom));
+			const float left = visual.rect.X;
+			const float right = visual.rect.X + visual.rect.Width;
+
+			// 横线与纵向光标同色同宽；两端各画一个尖端朝内的三角把手。
+			UiDrawLine(g, left, lineY, right, lineY, color, 1.4f * m_scale);
+			const float arm = 5.0f * m_scale;
+			gd::SolidBrush handle(ToGdiColor(color));
+			gd::PointF leftHandle[3];
+			leftHandle[0] = gd::PointF(left, lineY - arm);
+			leftHandle[1] = gd::PointF(left, lineY + arm);
+			leftHandle[2] = gd::PointF(left + arm * 1.4f, lineY);
+			g.FillPolygon(&handle, leftHandle, 3);
+			gd::PointF rightHandle[3];
+			rightHandle[0] = gd::PointF(right, lineY - arm);
+			rightHandle[1] = gd::PointF(right, lineY + arm);
+			rightHandle[2] = gd::PointF(right - arm * 1.4f, lineY);
+			g.FillPolygon(&handle, rightHandle, 3);
+
+			// 幅值读数：靠网格左侧、纵向居中于横线（与纵向光标的时间读数同款胶囊）。
+			// **必须让开左端的三角把手**（把手横向占 [left, left + arm*1.4]），
+			// 否则数值胶囊会盖住把手（用户明确要求向右挪一些）。
+			const std::wstring text = FormatValue(tabLane.edgeValue);
+			const float textWidth = std::max(
+			    56.0f * m_scale, UiMeasureTextWidth(m_fonts->monoSmall, text) + 16.0f * m_scale);
+			const float textHeight = 18.0f * m_scale;
+			const float labelLeft = left + (arm * 1.4f + 4.0f * m_scale);
+			const float labelTop =
+			    std::max(clipTop + 1.0f * m_scale, std::min(lineY - textHeight * 0.5f,
+			                                                clipBottom - textHeight - 1.0f * m_scale));
+			const gd::RectF labelRect(labelLeft, labelTop, textWidth, textHeight);
+			UiFillRoundRect(g, labelRect, 3.0f * m_scale, WithAlpha(color, 0xE0));
+			DrawLabelOutline(g, labelRect, 3.0f * m_scale, ink.outline);
+			UiText(g, text, m_fonts->monoSmall, labelRect, ink.text, TextAlign::CENTER);
+
+			// 幅值超出视界时（横线被贴边显示），在数值胶囊的**上方/下方**画一个方向三角，
+			// 与常规纵向光标数据点越界的处理方式一致；三角与胶囊**水平居中对齐**。
+			const float rawLineY = ValueToY(tabLane.edgeValue, visual);
+			const bool offUp = (rawLineY < clipTop - 0.5f);
+			const bool offDown = (rawLineY > clipBottom + 0.5f);
+			if (offUp || offDown)
+			{
+				const float tipArm = 5.0f * m_scale;
+				const float depth = tipArm * 1.4f;
+				const float centerX = labelRect.X + labelRect.Width * 0.5f;
+				// 三角整体贴在胶囊外侧（上方越界 → 胶囊上方的向上三角）。
+				const float anchorY = offUp ? (labelRect.Y - depth * 0.5f - 1.0f * m_scale)
+				                            : (labelRect.Y + labelRect.Height + depth * 0.5f + 1.0f * m_scale);
+				gd::PointF outer[3];
+				if (offUp)
+				{
+					outer[0] = gd::PointF(centerX - tipArm, anchorY + depth * 0.5f);
+					outer[1] = gd::PointF(centerX + tipArm, anchorY + depth * 0.5f);
+					outer[2] = gd::PointF(centerX, anchorY - depth * 0.5f);
+				}
+				else
+				{
+					outer[0] = gd::PointF(centerX - tipArm, anchorY - depth * 0.5f);
+					outer[1] = gd::PointF(centerX + tipArm, anchorY - depth * 0.5f);
+					outer[2] = gd::PointF(centerX, anchorY + depth * 0.5f);
+				}
+				gd::SolidBrush tipBrush(ToGdiColor(color));
+				g.FillPolygon(&tipBrush, outer, 3);
+			}
+		}
+
+		// ---- 统计浮动面板（最后绘制，覆盖在波形之上）----
+		// 「边沿计数」「边沿计数（中心轴）」「均值滤波」「弱峰调整」共用同一套样式，
+		// 仅标题、内容行与底部按钮不同。
+		//
+		// 面板是**静态**内容：只有被拖动 / 悬停 / 参数变化的那一个真正重画，
+		// 其余直接贴上一帧缓存好的像素（15 个面板全画一遍实测约 33ms，
+		// 而贴图 <1ms —— 拖动弱峰调整滑块时的主要卡顿就来自这一层）。
+		// 「上升沿 / 下降沿」两列排版（列起点固定 ⇒ 多条信号的文字严格垂直对齐）。
+		// ⚠️ 未完成时**两个数字后面都带 `…`**（旧实现只在整行末尾追加一次，
+		//    视觉上只跟在“下降沿”的数字后面；用户明确要求为“上升沿”也补上这个尾缀）。
+		const auto paintCounts = [this, &g](const gd::RectF& rect, std::size_t rising,
+		                                    std::size_t falling, bool complete)
+		{
+			if (EdgeCountsPending(rising, falling, complete))
+			{
+				UiText(g, L"统计中…", m_fonts->monoSmall, rect, m_theme->textMuted, TextAlign::LEFT);
+				return;
+			}
+			const float gap = kEdgePanelStatColumnGap * m_scale;
+			const float columnWidth = std::max(10.0f, (rect.Width - gap) * 0.5f);
+			UiText(g, EdgeRisingText(rising, complete), m_fonts->monoSmall,
+			       gd::RectF(rect.X, rect.Y, columnWidth, rect.Height), m_theme->textMuted,
+			       TextAlign::LEFT);
+			UiText(g, EdgeFallingText(falling, complete), m_fonts->monoSmall,
+			       gd::RectF(rect.X + columnWidth + gap, rect.Y, columnWidth, rect.Height),
+			       m_theme->textMuted, TextAlign::LEFT);
+		};
+
+		std::vector<PanelSlot> nextSlots;
+		std::vector<gd::RectF> dirtyRects;
+		const std::uint64_t panelGlobalKey = PanelGlobalKey();
+		// 编辑态（输入框 + 插入符）逐个面板变化太细碎，直接整体不缓存。
+		const bool panelCacheReady =
+		    (m_editTarget == PlotEditTarget::NONE) && EnsurePanelCache();
+		const bool panelGlobalSame =
+		    panelCacheReady && m_panelValid && panelGlobalKey == m_panelGlobalKey;
+		// ⚠️ **按层序从下往上绘制**（与命中测试、像素缓存的层叠顺序完全一致）：
+		// `m_panelOrder` 队尾 = 最上层 = 最后绘制。
+		SyncPanelOrder();
+		for (const PanelRef& panelRef : m_panelOrder)
+		{
+			const EdgePanelKind kind = static_cast<EdgePanelKind>(panelRef.kind);
+			const std::size_t index = static_cast<std::size_t>(panelRef.laneIndex);
+			const bool centerAxis = (kind == EdgePanelKind::CENTER);
+			const bool meanFilter = (kind == EdgePanelKind::MEAN);
+			const bool weakPeak = (kind == EdgePanelKind::PEAK);
+			// 「均值滤波」与「弱峰调整」共用「逐条目 + 底部按钮」排布。
+			const bool itemized = (centerAxis || meanFilter || weakPeak);
+			const bool hasButton = (meanFilter || weakPeak);
+			{
+				if (index >= count)
+				{
+					continue;
+				}
+				const Lane& tabLane = tabLanes[index];
+				const EdgePanelLayout layout = EdgePanelLayoutFor(static_cast<int>(index), kind);
+				const gd::RectF& panel = layout.panel;
+				if (panel.Width <= 0.0f || panel.Height <= 0.0f)
+				{
+					continue;
+				}
+
+				// 面板自身的内容指纹；命中缓存时直接贴图，本帧不再重画这个面板。
+				// ⚠️ 缓存像素里含**它与它下面的一切**（面板背后的波形、被它遮住的其他面板），
+				// 因此只要有一个面板重画，所有「在它之后绘制、且与它重叠」的面板也必须重画，
+				// 否则后画者会把旧像素重新盖回去（面板默认位置本来就常常叠在一起）。
+				const float cacheMargin = 4.0f * m_scale;
+				const gd::RectF cachedRect(panel.X - cacheMargin, panel.Y - cacheMargin,
+				                           panel.Width + cacheMargin * 2.0f,
+				                           panel.Height + cacheMargin * 2.0f);
+				bool forcedDirty = false;
+				for (const gd::RectF& dirtyRect : dirtyRects)
+				{
+					if (dirtyRect.IntersectsWith(cachedRect))
+					{
+						forcedDirty = true;
+						break;
+					}
+				}
+
+				std::uint64_t slotKey = 0;
+				const std::size_t slotIndex = nextSlots.size();
+				if (panelCacheReady)
+				{
+					slotKey = PanelSlotKey(static_cast<int>(index), kind, layout);
+					if (panelGlobalSame && !forcedDirty)
+					{
+						const PanelSlot* hit = nullptr;
+						for (const PanelSlot& slot : m_panelSlots)
+						{
+							if (slot.laneIndex == static_cast<int>(index) &&
+							    slot.kind == static_cast<int>(kind))
+							{
+								hit = &slot;
+								break;
+							}
+						}
+						if (hit != nullptr && hit->key != 0 && hit->key == slotKey)
+						{
+							HDC target = g.GetHDC();
+							if (target != nullptr)
+							{
+								BitBlt(target, hit->x0, hit->y0, hit->x1 - hit->x0, hit->y1 - hit->y0,
+								       m_panelDc, hit->x0, hit->y0, SRCCOPY);
+								g.ReleaseHDC(target);
+							}
+							nextSlots.push_back(*hit);
+							continue;
+						}
+					}
+				}
+				nextSlots.push_back(PanelSlot());
+				dirtyRects.push_back(cachedRect);
+
+				const float titleHeight = kEdgePanelTitleHeight * m_scale;
+				const float rowHeight = kEdgePanelRowHeight * m_scale;
+				const float pad = kEdgePanelPad * m_scale;
+
+				// 面板主体 + 标题栏。
+				// 投影响用两张大面积的半透明圆角矩形模拟，代价不低；交互期间（快速帧）省略它，
+				// 让拖动参数滑块时面板重绘不再被投影拖累（松手后的全质量帧会补回投影）。
+				if (!m_fastFrame)
+				{
+					UiFillRoundRect(g, gd::RectF(panel.X + 1.0f * m_scale, panel.Y + 2.0f * m_scale,
+					                             panel.Width, panel.Height),
+					                5.0f * m_scale, 0x14000000u);
+				}
+				UiFillRoundRect(g, panel, 5.0f * m_scale, WithAlpha(m_theme->cardBg, 0xF4));
+				UiDrawRoundRect(g, panel, 5.0f * m_scale, m_theme->borderStrong, 1.0f);
+				UiFillRoundRect(g, gd::RectF(panel.X, panel.Y, panel.Width, titleHeight), 5.0f * m_scale,
+				                WithAlpha(m_theme->accent, 0x2A));
+
+				// 标题：与左侧信号面板一致的 “GX” 徽标。
+				const float badgeWidth = kLaneBadgeWidth * m_scale;
+				const float badgeHeight = kLaneBadgeHeight * m_scale;
+				const gd::RectF badgeRect(panel.X + pad, panel.Y + (titleHeight - badgeHeight) * 0.5f,
+				                          badgeWidth, badgeHeight);
+				UiFillRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->cardBg);
+				UiDrawRoundRect(g, badgeRect, badgeHeight * 0.5f, m_theme->border, 1.0f);
+				UiText(g, L"G" + std::to_wstring(index + 1), m_fonts->monoSmall, badgeRect,
+				       m_theme->text, TextAlign::CENTER);
+				const std::wstring title =
+				    meanFilter ? std::wstring(L"均值滤波")
+				               : (weakPeak ? std::wstring(kWeakPeakTitle)
+				                            : ((centerAxis ? L"中心轴边沿计数" : L"边沿计数") +
+				                               EdgeRangeSuffix()));
+				UiText(g, title, m_fonts->uiSmall,
+				       gd::RectF(badgeRect.X + badgeRect.Width + 8.0f * m_scale, panel.Y,
+				                 panel.Width - badgeRect.Width - 8.0f * m_scale - titleHeight,
+				                 titleHeight),
+				       m_theme->textStrong, TextAlign::LEFT);
+
+				// 关闭按钮 ✕：悬停时高亮提示（鼠标光标本身不改变样式）。
+				const gd::RectF& closeRect = layout.close;
+				const bool closeHot =
+				    (m_dragMode != PlotDragMode::EDGE_PANEL_MOVE) &&
+				    UiPointInRect(closeRect, static_cast<float>(m_mouseX), static_cast<float>(m_mouseY));
+				if (closeHot)
+				{
+					UiFillRoundRect(g, gd::RectF(closeRect.X + 3.0f * m_scale, closeRect.Y + 3.0f * m_scale,
+					                             closeRect.Width - 6.0f * m_scale,
+					                             closeRect.Height - 6.0f * m_scale),
+					                3.0f * m_scale, WithAlpha(m_theme->danger, 0x33));
+				}
+				const float crossPad = 8.0f * m_scale;
+				const std::uint32_t crossColor = closeHot ? m_theme->danger : m_theme->textMuted;
+				UiDrawLine(g, closeRect.X + crossPad, closeRect.Y + crossPad,
+				           closeRect.X + closeRect.Width - crossPad,
+				           closeRect.Y + closeRect.Height - crossPad, crossColor, 1.6f * m_scale);
+				UiDrawLine(g, closeRect.X + closeRect.Width - crossPad, closeRect.Y + crossPad,
+				           closeRect.X + crossPad, closeRect.Y + closeRect.Height - crossPad, crossColor,
+				           1.6f * m_scale);
+
+				// 「中心轴边沿计数」/「均值滤波」/「弱峰调整」面板都采用「逐条目」排布：
+				// 第一排 = 名称 + 复选框，第二排 = 两个参数输入框（仅勾选的条目，
+				// 弱峰调整没有参数输入框），中心轴再多第三排 = 对应的统计结果。
+				if (itemized)
+				{
+					for (std::size_t rowIndex = 0; rowIndex < layout.rowRefs.size(); ++rowIndex)
+					{
+						const SignalRef& ref = layout.rowRefs[rowIndex];
+						const ResolvedSignal resolved = ResolveSignal(ref);
+						if (resolved.data == nullptr || resolved.style == nullptr)
+						{
+							continue;
+						}
+						const std::uint32_t signalColor = StyleColor(*resolved.style);
+						const gd::RectF& checkRect = layout.rowChecks[rowIndex];
+						const bool checked = meanFilter ? tabLane.MeanFilterEnabled(ref)
+						                                : (weakPeak ? tabLane.WeakPeakEnabled(ref)
+						                                             : tabLane.EdgeCenterEnabled(ref));
+
+						// 名称：第一排左侧，避开右侧复选框（超长时省略）。
+						const float nameWidth =
+						    std::min(std::max(20.0f, checkRect.X - (panel.X + pad) - 6.0f * m_scale),
+						             kEdgePanelNameMaxWidth * m_scale);
+						UiText(g, UiEllipsize(resolved.data->name, m_fonts->uiSmall, nameWidth),
+						       m_fonts->uiSmall,
+						       gd::RectF(panel.X + pad, checkRect.Y - 3.0f * m_scale, nameWidth,
+						                 checkRect.Height + 6.0f * m_scale),
+						       signalColor, TextAlign::LEFT);
+						UiDrawCheckBox(g, checkRect, checked ? 1 : 0, 3.0f * m_scale);
+
+						if (!checked)
+						{
+							continue;
+						}
+
+						// MEAN / CENTER 的平滑参数条目（弱峰调整用自己的 `WeakPeakItem`）。
+						const Lane::MeanFilterItem* item =
+						    (meanFilter || centerAxis)
+						        ? (meanFilter ? tabLane.FindMeanFilterItem(ref)
+						                      : tabLane.FindEdgeCenterItem(ref))
+						        : nullptr;
+
+						// 「弱峰调整」：每个被勾选的信号各有两行**滑块**
+						//（调整幅度 -200% – +200% / 迭代次数 1 … 该信号自定义上限）。
+						// 迭代次数行的右侧数值可点击 → 整行变为输入框以修改滑块上限。
+						if (weakPeak)
+						{
+							const Lane::WeakPeakItem* peakItem = tabLane.FindWeakPeakItem(ref);
+							if (peakItem != nullptr && rowIndex < layout.rowLevelTracks.size() &&
+							    layout.rowLevelTracks[rowIndex].Width > 0.0f)
+							{
+								// 两行滑块的「标签」始终绘制（编辑上限时也要能看出在改哪一项）；
+								// 「轨道 + 数值」在编辑上限时改由 `PaintEditField` 画成输入框。
+								const auto paintSliderLabel = [&](const gd::RectF& track,
+								                                  const wchar_t* label)
+								{
+									const float labelColumn =
+									    WeakPeakLabelColumnWidth(m_fonts->uiSmall);
+									const float labelLeft =
+									    track.X - 6.0f * m_scale - labelColumn;
+									UiText(g, label, m_fonts->uiSmall,
+									       gd::RectF(labelLeft, track.Y - 8.0f * m_scale,
+									                 labelColumn, track.Height + 16.0f * m_scale),
+									       m_theme->textMuted, TextAlign::LEFT);
+								};
+								const auto paintSliderBody = [&](const gd::RectF& track, double ratio,
+								                                 const std::wstring& valueText,
+								                                 bool active)
+								{
+									UiDrawSlider(g, track, ratio, m_theme->accent, active, m_scale);
+									UiText(g, valueText, m_fonts->monoSmall,
+									       gd::RectF(track.X + track.Width + 6.0f * m_scale,
+									                 track.Y - 8.0f * m_scale,
+									                 WeakPeakValueColumnWidth(m_fonts->monoSmall),
+									                 track.Height + 16.0f * m_scale),
+									       m_theme->textStrong, TextAlign::LEFT);
+								};
+								// 每行滑块右侧的**复位控件**（与「系数/偏移」二级面板里的还原图标同一套绘制）：
+								// 悬停时高亮 + 手型光标，点击把该行参数恢复为默认值（幅度 0 / 迭代 1 且上限回初始值）。
+								const auto paintSliderReset = [&](const gd::RectF& rect)
+								{
+									if (rect.Width <= 0.0f)
+									{
+										return;
+									}
+									const bool hot =
+									    (m_dragMode != PlotDragMode::EDGE_PANEL_MOVE) &&
+									    UiPointInRect(rect, static_cast<float>(m_mouseX),
+									                  static_cast<float>(m_mouseY));
+									if (hot)
+									{
+										UiFillRoundRect(
+										    g, gd::RectF(rect.X - 1.0f * m_scale, rect.Y - 1.0f * m_scale,
+										                 rect.Width + 2.0f * m_scale,
+										                 rect.Height + 2.0f * m_scale),
+										    3.0f * m_scale, WithAlpha(m_theme->accent, 0x33));
+									}
+									PaintPanelResetIcon(g, rect,
+									                    hot ? m_theme->accent : m_theme->textMuted, m_scale);
+								};
+
+								const gd::RectF& levelTrack = layout.rowLevelTracks[rowIndex];
+								const gd::RectF& iterTrack = layout.rowIterTracks[rowIndex];
+								paintSliderLabel(levelTrack, kWeakPeakLevelLabel);
+								paintSliderLabel(iterTrack, kWeakPeakIterationsSliderLabel);
+
+								const bool levelActive = (m_dragMode == PlotDragMode::PEAK_LEVEL) &&
+								                         (m_peakDragLane == static_cast<int>(index)) &&
+								                         (m_peakDragRef == ref);
+								const double levelRatio =
+								    (static_cast<double>(std::max(kWeakPeakAmountMin,
+								                                 std::min(kWeakPeakAmountMax,
+								                                          peakItem->amountPercent))) /
+								         (100.0 * kWeakPeakSliderScale) +
+								     1.0) *
+								    0.5;
+								paintSliderBody(levelTrack, levelRatio,
+								                (peakItem->amountPercent > 0 ? L"+" : L"") +
+								                    std::to_wstring(peakItem->amountPercent) + L"%",
+								                levelActive);
+								paintSliderReset(layout.rowLevelResets[rowIndex]);
+
+								// 迭代次数滑块：量程 = 1 … 该信号自己的上限。
+								const int peakMax = std::max(kWeakPeakIterationsMin,
+								                             std::min(kWeakPeakIterationsMaxLimit,
+								                                      peakItem->maxIterations));
+								const int peakIter = std::max(
+								    kWeakPeakIterationsMin, std::min(peakMax, peakItem->iterations));
+								const double iterRatio =
+								    (peakMax > kWeakPeakIterationsMin)
+								        ? (static_cast<double>(peakIter - kWeakPeakIterationsMin) /
+								           static_cast<double>(peakMax - kWeakPeakIterationsMin))
+								        : 0.0;
+								const bool iterActive = (m_dragMode == PlotDragMode::PEAK_ITERATIONS) &&
+								                        (m_peakDragLane == static_cast<int>(index)) &&
+								                        (m_peakDragRef == ref);
+								const bool editingMax =
+								    (m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX) &&
+								    (m_editLane == static_cast<int>(index)) && (m_editMeanRef == ref);
+								if (!editingMax)
+								{
+									paintSliderBody(iterTrack, iterRatio, std::to_wstring(peakIter),
+									                iterActive);
+									paintSliderReset(layout.rowIterResets[rowIndex]);
+								}
+							}
+						}
+
+						// MEAN / CENTER：第二排的两个参数输入框。
+						if (!weakPeak)
+						{
+						const int shownPoints = (item != nullptr) ? item->points : 5;
+						const int shownOrder = (item != nullptr) ? item->iterations : 1;
+						const PlotEditTarget pointsTarget =
+						    meanFilter ? PlotEditTarget::MEAN_FILTER_POINTS
+						               : PlotEditTarget::EDGE_CENTER_POINTS;
+						const PlotEditTarget orderTarget =
+						    meanFilter ? PlotEditTarget::MEAN_FILTER_ITERATIONS
+						               : PlotEditTarget::EDGE_CENTER_ITERATIONS;
+						const auto paintField = [&](const gd::RectF& rect, const wchar_t* label,
+						                            int value, PlotEditTarget target)
+						{
+							if (rect.Width <= 0.0f)
+							{
+								return;
+							}
+							const float labelWidth = UiMeasureTextWidth(m_fonts->uiSmall, label);
+							UiText(g, label, m_fonts->uiSmall,
+							       gd::RectF(rect.X, rect.Y, labelWidth, rect.Height), m_theme->textMuted,
+							       TextAlign::LEFT);
+
+							const float fieldWidth =
+							    std::max(kEdgePanelEditFieldWidth * m_scale * 0.75f,
+							             UiMeasureTextWidth(m_fonts->monoSmall, std::to_wstring(value)) +
+							                 18.0f * m_scale);
+							const float fieldLeft = rect.X + rect.Width - fieldWidth;
+							const float fieldHeight = rect.Height - 4.0f * m_scale;
+							const gd::RectF fieldRect(fieldLeft, rect.Y + 2.0f * m_scale, fieldWidth,
+							                          fieldHeight);
+
+							const bool editingThis = (m_editTarget == target) &&
+							                         (m_editLane == static_cast<int>(index)) &&
+							                         (m_editMeanRef == ref);
+							if (editingThis)
+							{
+								UiDrawEditField(g, fieldRect, m_edit, m_fonts->monoSmall, m_scale);
+							}
+							else
+							{
+								UiFillRoundRect(g, fieldRect, 3.0f * m_scale, m_theme->pressed);
+								UiDrawRoundRect(g, fieldRect, 3.0f * m_scale, m_theme->border, 1.0f);
+								UiText(g, std::to_wstring(value), m_fonts->monoSmall, fieldRect,
+								       m_theme->textStrong, TextAlign::CENTER);
+							}
+						};
+						paintField(layout.rowPoints[rowIndex], L"均值点数 X", shownPoints, pointsTarget);
+						paintField(layout.rowIterations[rowIndex], kWeakPeakIterationsLabel, shownOrder,
+						           orderTarget);
+						}
+
+						// 第三排（中心轴）：该信号在当前参数下的上升沿/下降沿统计结果。
+						if (centerAxis && rowIndex < layout.rowStats.size() &&
+						    layout.rowStats[rowIndex].Width > 0.0f)
+						{
+							const gd::RectF& statsRect = layout.rowStats[rowIndex];
+							const int statsPoints = (item != nullptr) ? item->points : 5;
+							const int statsOrder = (item != nullptr) ? item->iterations : 1;
+							std::size_t rising = 0;
+							std::size_t falling = 0;
+							bool statsComplete = false;
+							EdgeCenterCountsFor(*resolved.axis, *resolved.data, *resolved.style,
+							                    statsPoints, statsOrder, EdgeRangeActive(),
+							                    EdgeRangeMin(), EdgeRangeMax(), rising, falling,
+							                    statsComplete);
+							// 两列排版（列起点固定）⇒ 多条信号的“上升沿 / 下降沿”垂直对齐。
+							paintCounts(statsRect, rising, falling, statsComplete);
+						}
+					}
+				}
+
+				float rowY = panel.Y + titleHeight + pad;
+				for (const SignalRef& ref : tabLane.signals)
+				{
+					const ResolvedSignal resolved = ResolveSignal(ref);
+					if (resolved.data == nullptr || resolved.style == nullptr || !resolved.visible)
+					{
+						continue;
+					}
+					if (itemized)
+					{
+						// 逐条目绘制已在上面完成。
+						continue;
+					}
+					const std::uint32_t signalColor = StyleColor(*resolved.style);
+					const float textWidth = panel.Width - pad * 2.0f;
+					// 名称：超长时省略（面板宽度被 `kEdgePanelNameMaxWidth` 限制，不会把面板顶得很长）。
+					UiText(g,
+					       UiEllipsize(resolved.data->name, m_fonts->uiSmall,
+					                   std::min(textWidth, kEdgePanelNameMaxWidth * m_scale)),
+					       m_fonts->uiSmall, gd::RectF(panel.X + pad, rowY, textWidth, rowHeight),
+					       signalColor, TextAlign::LEFT);
+
+					std::size_t rising = 0;
+					std::size_t falling = 0;
+					bool complete = true;
+					EdgeCountsFor(*resolved.axis, *resolved.data, *resolved.style, tabLane.edgeValue,
+					              EdgeRangeActive(), EdgeRangeMin(), EdgeRangeMax(), rising, falling,
+					              complete);
+					paintCounts(gd::RectF(panel.X + pad, rowY + rowHeight, textWidth, rowHeight), rising,
+					            falling, complete);
+					rowY += rowHeight * 2.0f;
+				}
+
+				// 逐条目面板底部按钮行：「构建为新信号」（悬停高亮）。
+				if (hasButton)
+				{
+					const gd::RectF& buttonRect = layout.button;
+					if (buttonRect.Width > 0.0f)
+					{
+						const gd::RectF inner(buttonRect.X, buttonRect.Y + 2.0f * m_scale,
+						                      buttonRect.Width, buttonRect.Height - 4.0f * m_scale);
+						const bool hot =
+						    (m_dragMode != PlotDragMode::EDGE_PANEL_MOVE) &&
+						    UiPointInRect(inner, static_cast<float>(m_mouseX),
+						                  static_cast<float>(m_mouseY));
+						UiFillRoundRect(g, inner, 4.0f * m_scale,
+						                hot ? WithAlpha(m_theme->accent, 0x3A) : m_theme->cardBg);
+						UiDrawRoundRect(g, inner, 4.0f * m_scale, m_theme->accent, 1.2f);
+						UiText(g, kBuildSignalLabel, m_fonts->uiSmall, inner, m_theme->accent,
+						       TextAlign::CENTER);
+					}
+				}
+
+				// 面板画完了：把它刚画进后备缓冲区的像素（连同缓存键）存进面板图层，
+				// 下一帧只要键不变就直接贴图。矩形外的 4 逻辑像素边距用于容纳投影。
+				PanelSlot& stored = nextSlots[slotIndex];
+				stored.laneIndex = static_cast<int>(index);
+				stored.kind = static_cast<int>(kind);
+				stored.key = 0;
+				if (panelCacheReady && slotKey != 0)
+				{
+					const int x0 = std::max(0, static_cast<int>(std::floor(cachedRect.X)));
+					const int y0 = std::max(0, static_cast<int>(std::floor(cachedRect.Y)));
+					const int x1 = std::max(x0, static_cast<int>(std::ceil(cachedRect.X + cachedRect.Width)));
+					const int y1 = std::max(y0, static_cast<int>(std::ceil(cachedRect.Y + cachedRect.Height)));
+					const gd::RectF layerRect(static_cast<float>(x0), static_cast<float>(y0),
+					                          static_cast<float>(x1 - x0), static_cast<float>(y1 - y0));
+					if (x1 > x0 && y1 > y0 && PanelRectInsideLayer(layerRect))
+					{
+						HDC source = g.GetHDC();
+						if (source != nullptr)
+						{
+							const BOOL ok = BitBlt(m_panelDc, x0, y0, x1 - x0, y1 - y0, source, x0, y0,
+							                       SRCCOPY);
+							g.ReleaseHDC(source);
+							if (ok != FALSE)
+							{
+								stored.key = slotKey;
+								stored.x0 = x0;
+								stored.y0 = y0;
+								stored.x1 = x1;
+								stored.y1 = y1;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		m_panelSlots = std::move(nextSlots);
+		m_panelGlobalKey = panelGlobalKey;
+		m_panelValid = panelCacheReady;
+	}
+
+	void PlotView::PaintEditField(gd::Graphics& g)
+	{
+		const gd::RectF fieldRect = EditFieldRect();
+		if (fieldRect.Width <= 0.0f || fieldRect.Height <= 0.0f)
+		{
+			return;
+		}
+
+		// 编辑态：强调色外框 + 选区高亮 + 插入符，首次键入即整体替换（与常规输入框一致）。
+		UiDrawEditField(g, fieldRect, m_edit, m_fonts->monoSmall, m_scale);
+
+		// 「迭代次数 N 上限」：输入框**以空内容开始**，未输入任何内容时以灰色提示当前上限值。
+		// 提示文案 = “输入上限（当前N）”（用户明确要求：旧实现只显示一个孤立的数字，缺少说明）。
+		if (m_editTarget == PlotEditTarget::PEAK_ITERATIONS_MAX && m_edit.Text().empty())
+		{
+			const int currentMax = m_peakEditCurrentMax > 0 ? m_peakEditCurrentMax
+			                                                : kWeakPeakIterationsDefaultMax;
+			const std::wstring hint = L"输入上限（当前" + std::to_wstring(currentMax) + L"）";
+			const float hintLeft = fieldRect.X + 11.0f * m_scale;
+			UiTextAtClipped(g, hint, m_fonts->monoSmall, hintLeft,
+			                gd::RectF(hintLeft, fieldRect.Y,
+			                          std::max(0.0f, fieldRect.X + fieldRect.Width -
+			                                             hintLeft - 4.0f * m_scale),
+			                          fieldRect.Height),
+			                m_theme->textMuted, fieldRect);
+		}
+	}
+
+	void PlotView::PaintSignalInteraction(gd::Graphics& g)
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr || m_lanes.empty())
+		{
+			return;
+		}
+
+		// 拖拽中：虚影跟随鼠标纵向位移，同时在目标网格内高亮落点。
+		if (m_dragMode == PlotDragMode::MOVE_SIGNAL && m_dragSignal.IsValid())
+		{
+			const ResolvedSignal resolved = ResolveSignal(m_dragSignal);
+			const int sourceLane = m_tab->LaneOfSignal(m_dragSignal);
+			if (resolved.data == nullptr || resolved.style == nullptr || sourceLane < 0 ||
+			    sourceLane >= static_cast<int>(m_lanes.size()))
+			{
+				return;
+			}
+
+			// 虚影：以源网格的幅值映射构建波形，再按鼠标位移整体平移。
+			// 第一帧位移为 0，因此虚影必然精确落在鼠标下方（曲线形态与抓住时完全一致）；
+			// 之后纵向与横向均自由跟随，形成“拖着曲线走”的观感。
+			const LaneVisual& sourceVisual = m_lanes[static_cast<std::size_t>(sourceLane)];
+			const float offsetX = static_cast<float>(m_dragMouseX - m_dragStartX);
+			const float offsetY = static_cast<float>(m_dragMouseY - m_dragStartY);
+
+			{
+				const int saveState = g.Save();
+				g.SetClip(gd::RectF(m_plotRect.X, m_plotRect.Y, m_plotRect.Width, m_plotRect.Height),
+				          gd::CombineModeIntersect);
+
+				// 虚影的几何与源网格里的信号完全一致，直接复用折线顶点缓存，
+				// 再用平移变换让整体跟随鼠标：避免每帧重新构建并逐点搬运上万顶点。
+				const PolylineCacheEntry* ghostSource = AcquirePolyline(m_dragSignal, resolved, sourceVisual);
+				if (ghostSource == nullptr)
+				{
+					g.Restore(saveState);
+					return;
+				}
+				const std::vector<gd::PointF>& points = ghostSource->points;
+				const std::vector<std::size_t>& breaks = ghostSource->breaks;
+
+				g.TranslateTransform(offsetX, offsetY);
+
+				const DrawMode mode = resolved.style->mode;
+				const bool drawLine = (mode != DrawMode::SCATTER);
+				const bool drawScatter = (mode == DrawMode::SCATTER || mode == DrawMode::LINE_SCATTER);
+
+				// 虚影保持原信号的颜色与样式（不再是虚线），仅以轻微透明区分“尚未落地”。
+				const std::uint32_t ghostColor = WithAlpha(resolved.style->color,
+				                                           static_cast<unsigned int>(
+				                                               std::max(0.35, static_cast<double>(resolved.style->opacity)) *
+				                                               255.0 + 0.5));
+
+				if (drawLine && !breaks.empty())
+				{
+					if (ghostSource->bandMode && !ghostSource->bandBreaks.empty())
+					{
+						// 稠密包络虚影同样用一次 FillPath（见 PaintLane 的说明）。
+						gd::GraphicsPath bandPath;
+						bandPath.SetFillMode(gd::FillModeWinding);
+						for (std::size_t k = 0; k < ghostSource->bandBreaks.size(); ++k)
+						{
+							const std::size_t start = ghostSource->bandBreaks[k];
+							const std::size_t stop = (k + 1 < ghostSource->bandBreaks.size())
+							                             ? ghostSource->bandBreaks[k + 1]
+							                             : ghostSource->band.size();
+							const std::size_t total = stop - start;
+							if (total < 4 || (total % 2) != 0)
+							{
+								continue;
+							}
+							const std::size_t half = total / 2;
+							bandPath.StartFigure();
+							bandPath.AddLines(ghostSource->band.data() + start, static_cast<INT>(half));
+							bandPath.AddLines(ghostSource->band.data() + start + half,
+							                  static_cast<INT>(half));
+							bandPath.CloseFigure();
+						}
+						if (bandPath.GetPointCount() > 0)
+						{
+							gd::SolidBrush brush(ToGdiColor(ghostColor));
+							g.FillPath(&brush, &bandPath);
+						}
+					}
+					else
+					{
+						gd::Pen ghost(ToGdiColor(ghostColor),
+						              std::max(1.0f, resolved.style->lineWidth) * m_scale);
+						ghost.SetLineJoin(gd::LineJoinRound);
+						ghost.SetStartCap(gd::LineCapRound);
+						ghost.SetEndCap(gd::LineCapRound);
+						for (std::size_t k = 0; k < breaks.size(); ++k)
+						{
+							const std::size_t start = breaks[k];
+							const std::size_t stop = (k + 1 < breaks.size()) ? breaks[k + 1] : points.size();
+							if (stop <= start + 1)
+							{
+								continue;
+							}
+							g.DrawLines(&ghost, points.data() + start, static_cast<INT>(stop - start));
+						}
+					}
+				}
+
+				if (drawScatter && !points.empty())
+				{
+					const float radius = static_cast<float>(
+					    ClampDouble(static_cast<double>(resolved.style->lineWidth) * kScatterRadiusScale,
+					                kMinScatterRadius, kMaxScatterRadius) *
+					    m_scale);
+					const std::size_t scatterStride =
+					    std::max<std::size_t>(1, points.size() / kMaxScatterPoints);
+					// 与主绘制一致：合并成一条路径一次填充，并显式使用缠绕规则避免重叠处出现空洞。
+					gd::GraphicsPath ghostPath;
+					ghostPath.SetFillMode(gd::FillModeWinding);
+					for (std::size_t k = 0; k < points.size(); k += scatterStride)
+					{
+						ghostPath.AddEllipse(points[k].X - radius, points[k].Y - radius, radius * 2.0f,
+						                     radius * 2.0f);
+					}
+					gd::SolidBrush brush(ToGdiColor(ghostColor));
+					if (ghostPath.GetPointCount() > 0)
+					{
+						g.FillPath(&brush, &ghostPath);
+					}
+				}
+				else if (drawScatter && resolved.data->finiteCount == 1)
+				{
+					// ⚠️ **只有单个有效数据点**的信号：折线缓存给不出顶点（`points` 可能为空），
+					// 因此直接按数据点的屏幕坐标画那个圆点，否则拖动时虚影会**整个消失**
+					//（用户 2026-10-15 要求单点信号也能拖拽换网格）。
+					gd::PointF dot;
+					if (SinglePointScreenPos(resolved, sourceVisual, dot))
+					{
+						const float radius = SinglePointDotRadius(resolved);
+						gd::SolidBrush brush(ToGdiColor(ghostColor));
+						g.FillEllipse(&brush, dot.X - radius, dot.Y - radius, radius * 2.0f, radius * 2.0f);
+					}
+				}
+
+				g.Restore(saveState);
+			}
+
+			// 落点提示：高亮鼠标所在网格并给出文字说明。
+			const int target = (m_dragTargetLane >= 0) ? m_dragTargetLane : sourceLane;
+			if (target >= 0 && target < static_cast<int>(m_lanes.size()))
+			{
+				const gd::RectF& targetRect = m_lanes[static_cast<std::size_t>(target)].rect;
+				const float visibleTop = std::max(targetRect.Y, m_plotRect.Y);
+				const float visibleBottom = std::min(targetRect.Y + targetRect.Height,
+				                                     m_plotRect.Y + m_plotRect.Height);
+				if (visibleBottom > visibleTop)
+				{
+					gd::Pen frame(ToGdiColor(m_theme->accent), 2.0f);
+					g.DrawRectangle(&frame, targetRect.X, visibleTop, targetRect.Width,
+					                visibleBottom - visibleTop);
+
+					const std::wstring hint = (target == sourceLane)
+					                              ? std::wstring(L"松开左键放回本网格")
+					                              : (L"移动到网格 " + std::to_wstring(target + 1) +
+					                                 L"：松开左键确认");
+					const float textWidth = UiMeasureTextWidth(m_fonts->uiSmall, hint) + 16.0f * m_scale;
+					const float height = 20.0f * m_scale;
+					float left = targetRect.X + (targetRect.Width - textWidth) * 0.5f;
+					left = std::max(m_plotRect.X, std::min(left, m_plotRect.X + m_plotRect.Width - textWidth));
+					const gd::RectF pill(left, visibleTop + 4.0f * m_scale, textWidth, height);
+					UiFillRoundRect(g, pill, 3.0f * m_scale, m_theme->accent);
+					UiText(g, hint, m_fonts->uiSmall, pill, m_theme->textOnAccent, TextAlign::CENTER);
+				}
+			}
+			return;
+		}
+
+		// 其它拖拽（光标/平移/中键/横向光标/面板）期间不显示信号悬停提示：
+		// 这些操作不会更新 m_hoverSignal，按下前的值会残留，表现为提示气泡"挂在原地"。
+		if (m_dragMode != PlotDragMode::NONE)
+		{
+			return;
+		}
+
+		// 悬停提示：光标贴近曲线时给出可拖拽说明（与时间光标的提示方式一致）。
+		if (!m_hoverSignal.IsValid())
+		{
+			return;
+		}
+		const int laneIndex = m_tab->LaneOfSignal(m_hoverSignal);
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return;
+		}
+		const ResolvedSignal resolved = ResolveSignal(m_hoverSignal);
+		if (resolved.data == nullptr)
+		{
+			return;
+		}
+
+		const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
+		const std::wstring text = resolved.data->name + L" · 按住拖拽可移入其它网格";
+
+		// 提示跟随鼠标：在可拖拽区域内持续移动时，提示条也要跟着走。
+		const float textWidth = UiMeasureTextWidth(m_fonts->uiSmall, text) + 16.0f * m_scale;
+		const float height = 20.0f * m_scale;
+		float left = static_cast<float>(m_mouseX) + 12.0f * m_scale;
+		if (left + textWidth > m_plotRect.X + m_plotRect.Width)
+		{
+			left = m_plotRect.X + m_plotRect.Width - textWidth;
+		}
+		left = std::max(m_plotRect.X, left);
+
+		float top = static_cast<float>(m_mouseY) + 14.0f * m_scale;
+		top = std::min(top, m_plotRect.Y + m_plotRect.Height - height - 2.0f * m_scale);
+		top = std::max(top, lane.rect.Y + 2.0f * m_scale);
+
+		const gd::RectF pill(left, top, textWidth, height);
+		UiFillRoundRect(g, pill, 3.0f * m_scale, WithAlpha(m_theme->readoutBg, 0xF2));
+		UiDrawRoundRect(g, pill, 3.0f * m_scale, m_theme->accent, 1.0f);
+		UiText(g, text, m_fonts->uiSmall, pill, m_theme->textStrong, TextAlign::CENTER);
+	}
+
+	void PlotView::PaintScrollBar(gd::Graphics& g)
+	{
+		if (!m_scrollBarVisible || m_laneContentHeight <= m_plotRect.Height)
+		{
+			return;
+		}
+
+		UiFillRoundRect(g, m_scrollBarRect, kScrollBarThickness * m_scale * 0.5f, m_theme->gridWeak);
+
+		const float ratio = std::min(1.0f, m_plotRect.Height / m_laneContentHeight);
+		const float thumbHeight = std::max(24.0f * m_scale, m_scrollBarRect.Height * ratio);
+		const float maxScroll = m_laneContentHeight - m_plotRect.Height;
+		const float progress = (maxScroll > 0.0f) ? (Tab().LaneScroll() / maxScroll) : 0.0f;
+		const float thumbY = m_scrollBarRect.Y + progress * (m_scrollBarRect.Height - thumbHeight);
+
+		const gd::RectF thumb(m_scrollBarRect.X, thumbY, m_scrollBarRect.Width, thumbHeight);
+		UiFillRoundRect(g, thumb, kScrollBarThickness * m_scale * 0.5f, m_theme->borderStrong);
+	}
+
+} // namespace jdi
+
diff --git a/Components/SignalPanel/Src/SignalPanel.cpp b/Components/SignalPanel/Src/SignalPanel.cpp
index b95c370..48575c6 100644
--- a/Components/SignalPanel/Src/SignalPanel.cpp
+++ b/Components/SignalPanel/Src/SignalPanel.cpp
@@ -1,287 +1,12 @@
-#include "SignalPanel.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-
-#include "UiControls.hpp"
-#include "Utf8Util.hpp"
+// SignalPanel 实现分片 —— 本文件只包含 SignalPanel 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 SignalPanelInternal.hpp（命名空间 `spdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "SignalPanelInternal.hpp"
 
 namespace jdi
 {
 
-	namespace
-	{
-		const float kHeaderHeight = 38.0f;		/**< 标题区高度（逻辑像素）。 */
-		const float kGroupRowHeight = 30.0f;		/**< 分组行高。 */
-		const float kSignalRowHeight = 27.0f;	/**< 信号行高。 */
-		const float kPadding = 12.0f;			/**< 通用内边距。 */
-		const float kCheckSize = 15.0f;			/**< 复选框尺寸。 */
-		const float kSwatchSize = 12.0f;		/**< 信号行颜色小方块尺寸。 */
-		const float kBadgeWidth = 30.0f;		/**< 网格徽标宽度。 */
-		const float kBadgeHeight = 17.0f;		/**< 网格徽标高度。 */
-		const float kCorner = 4.0f;				/**< 通用圆角半径。 */
-		const float kDisclosureWidth = 16.0f;	/**< 折叠三角占位宽度。 */
-		const float kIndent = 14.0f;			/**< 信号行相对分组行的缩进。 */
-		const float kScrollBarThickness = 8.0f;	/**< 滚动条宽度。 */
-		const float kCloseButtonSize = 18.0f;	/**< 行尾关闭（✕）按钮尺寸（分组行与信号行共用）。 */
-		const float kGroupSeparatorGap = 7.0f;	/**< 分组标签与分隔线/名称的间距。 */
-		const float kGroupSeparatorWidth = 1.0f;	/**< 分组标签右侧分隔线宽度。 */
-		const float kFilterHeight = 26.0f;		/**< 「筛选信号」输入框高度。 */
-		const float kFilterPadV = 5.0f;			/**< 筛选框上下留白。 */
-		const float kFilterTextPad = 4.0f;		/**< 筛选框内文字/输入框相对外框的内缩（四边一致）。 */
-		const float kRowTailGap = 6.0f;			/**< 网格徽标与行尾 ✕ 之间的间距。 */
-
-		/**
-		 * @brief 大小写无关的通配符匹配（`*` 匹配任意长度的任意字符序列）。
-		 * @param [IN] text 待匹配文本。
-		 * @param [IN] pattern 模式（可含多个 `*`）。
-		 * @return 匹配返回 true。
-		 */
-		bool WildcardMatchNoCase(const std::wstring& text, const std::wstring& pattern)
-		{
-			const auto fold = [](wchar_t character) -> wchar_t
-			{
-				// 仅对基本拉丁字母做大小写折叠（中文等其它字符原样比较）。
-				if (character >= L'A' && character <= L'Z')
-				{
-					return static_cast<wchar_t>(character - L'A' + L'a');
-				}
-				return character;
-			};
-
-			// 经典双指针回溯：`star` 记录最近一个 `*` 的位置，`resume` 记录当时尝试的文本位置。
-			std::size_t t = 0;
-			std::size_t p = 0;
-			std::size_t star = std::wstring::npos;
-			std::size_t resume = 0;
-
-			while (t < text.size())
-			{
-				if (p < pattern.size() && pattern[p] == L'*')
-				{
-					star = p;
-					resume = t;
-					++p;
-				}
-				else if (p < pattern.size() && fold(pattern[p]) == fold(text[t]))
-				{
-					++p;
-					++t;
-				}
-				else if (star != std::wstring::npos)
-				{
-					p = star + 1;
-					++resume;
-					t = resume;
-				}
-				else
-				{
-					return false;
-				}
-			}
-
-			// 文本已耗尽：模式剩余部分必须全是 `*`。
-			while (p < pattern.size() && pattern[p] == L'*')
-			{
-				++p;
-			}
-			return p == pattern.size();
-		}
-
-		// 样式编辑区：固定五行网格（颜色 / 样式 / 调整 / 线宽 / 透明度），
-		// 行高、间距与内容列宽度统一，保证面板宽度变化时各行控件始终对齐，且不会被无限制拉伸。
-		const float kStylePadH = 12.0f;			/**< 样式区左右内边距。 */
-		const float kStylePadV = 12.0f;			/**< 样式区上下内边距。 */
-		const float kStyleRowHeight = 26.0f;	/**< 样式区单行高度。 */
-		const float kStyleRowGap = 10.0f;		/**< 样式区行间距。 */
-		const float kStyleLabelWidth = 44.0f;	/**< 样式行标签列宽度。 */
-		const float kStyleLabelGap = 8.0f;		/**< 标签列与内容列间距。 */
-		const float kStyleRowCount = 5.0f;		/**< 样式区固定行数（不含顶部「目标」行）。 */
-		const float kStyleTargetRowHeight = 26.0f;	/**< 样式区顶部「目标」行高度（与其它行一致）。 */
-		/**
-		 * @brief GX 网格标签与信号名之间的间距（逻辑像素）。
-		 *
-		 * 用户要求：目标信号已绘制到网格时，在信号名**后方**显示它所在的 GX 标签。
-		 */
-		const float kTargetBadgeGap = 8.0f;
-		/**
-		 * @brief 平滑滚动的动画时长（毫秒）。
-		 *
-		 * 距离越远时长越长（但不会无限增长），靠近时由 ease-out 自动变慢 —— 用户要求
-		 * “越远时越快、靠近时变慢”且“整个动画过程不要太久”。
-		 */
-		const float kScrollAnimMinMs = 130.0f;		/**< 最短时长（短距离）。 */
-		const float kScrollAnimMaxMs = 300.0f;		/**< 最长时长（长距离）。 */
-		const float kScrollAnimMsPerPixel = 0.35f;	/**< 每像素距离增加的时长。 */
-
-		// ---- 分组折起/展开动画（用户 2026-10-16 要求）----
-		// 整组信号作为一个**刚性整体**向上平移（收起）/ 向下平移（展开），
-		// 越过组名下边界的部分被裁掉 —— 即“抽拉卷尺”观感：元素相对位置不变。
-		// 总时长 = clamp(基础 + 行数×每行, 下限, 上限)，保证“整个动画过程不会太久”。
-		const float kGroupAnimBaseMs = 115.0f;		/**< 动画基础时长。 */
-		const float kGroupAnimPerRowMs = 6.0f;		/**< 每多一行增加的时长。 */
-		const float kGroupAnimMinMs = 150.0f;		/**< 最短时长。 */
-		const float kGroupAnimMaxMs = 320.0f;		/**< 最长时长。 */
-		const float kStyleContentMax = 260.0f;	/**< 内容列最大宽度（再拉宽面板也不再延伸）。 */
-		const float kSwatchEdge = 18.0f;		/**< 颜色色块边长上限（含自定义颜色入口）。 */
-		const float kSwatchMin = 11.0f;			/**< 颜色色块边长下限。 */
-		const float kSwatchGap = 4.0f;			/**< 颜色色块最小间距。 */
-		const float kSwatchMaxGap = 10.0f;		/**< 颜色色块最大间距（用于铺满内容列）。 */
-		const float kSliderValueWidth = 52.0f;	/**< 滑块行数值文本宽度（透明度与线宽一致）。 */
-		const float kSliderValueGap = 8.0f;		/**< 滑块轨道与数值文本间距。 */
-		const float kTrackHeight = 6.0f;		/**< 滑块轨道高度。 */
-		const float kAdjustGap = 6.0f;			/**< 「调整」行三个按钮之间的间距。 */
-		const float kAdjustMenuGap = 4.0f;		/**< 「系数/偏移」「镜像」二级面板与按钮左上角的额外间距。 */
-
-		/** 「调整」行的按钮下标（与 `m_adjustRects` 同序）。 */
-		const int kAdjustGain = 0;		/**< 系数（点击展开系数二级面板）。 */
-		const int kAdjustMirror = 1;	/**< 镜像（点击展开镜像二级面板）。 */
-		const int kAdjustAbsolute = 2;	/**< 绝对值。 */
-		const int kAdjustCount = 3;		/**< 按钮数量。 */
-
-		// 线宽范围与「稀疏信号默认线宽」共用 `DataModel.hpp` 的常量，避免两处漂移
-		//（稀疏信号初始化时用的最大线宽必须与这里滑块的上限完全一致）。
-		const float kWidthMin = kSignalLineWidthMin;	/**< 允许的最小线宽（px）。 */
-		const float kWidthMax = kSignalLineWidthMax;	/**< 允许的最大线宽（px）。 */
-
-		/** @brief 系数调整允许的绝对值上限（防止输入极端值把波形完全挤出可视区）。 */
-		const double kGainLimit = 10000.0;
-
-		/** @brief 系数为默认值 1（不做任何缩放）时按钮显示为未启用样式。 */
-		bool GainIsDefault(float gain)
-		{
-			return std::fabs(gain - 1.0f) < 1.0e-6f;
-		}
-
-		/** @brief 可选绘制样式顺序（不含阶梯方式）。 */
-		const DrawMode kModeOptions[] = {DrawMode::LINE, DrawMode::SCATTER, DrawMode::LINE_SCATTER};
-		const int kModeOptionCount = static_cast<int>(sizeof(kModeOptions) / sizeof(kModeOptions[0]));
-
-		/**
-		 * @brief 计算滑块的便捷命中矩形（比轨道略大，便于拖拽）。
-		 * @param [IN] track 轨道矩形。
-		 * @param [IN] scale 缩放比例。
-		 * @return 命中矩形。
-		 */
-		gd::RectF SliderHitRect(const gd::RectF& track, float scale)
-		{
-			return gd::RectF(track.X - 6.0f * scale, track.Y - 9.0f * scale, track.Width + 12.0f * scale,
-			                 track.Height + 18.0f * scale);
-		}
-
-		/**
-		 * @brief 判断颜色是否偏暗（用于在色块之上选择可读的图标颜色）。
-		 * @param [IN] color 0xAARRGGBB 颜色值。
-		 * @return 相对亮度低于阈值返回 true。
-		 */
-		bool IsDarkColor(std::uint32_t color)
-		{
-			const double r = static_cast<double>((color >> 16) & 0xFFu);
-			const double g = static_cast<double>((color >> 8) & 0xFFu);
-			const double b = static_cast<double>(color & 0xFFu);
-			return (0.299 * r + 0.587 * g + 0.114 * b) < 140.0;
-		}
-
-		/**
-		 * @brief 将数值限制到合法区间。
-		 * @param [IN] value 输入值。
-		 * @param [IN] low 下限。
-		 * @param [IN] high 上限。
-		 * @return 限制后的数值。
-		 */
-		float ClampFloat(float value, float low, float high)
-		{
-			return (value < low) ? low : ((value > high) ? high : value);
-		}
-
-		/**
-		 * @brief 数值文本：**至少两位小数**，精度更高时按实际精度显示。
-		 *
-		 * 例：`1` → `1.00`、`2.5` → `2.50`、`0.125` → `0.125`、`1.2345678` → `1.2345678`。
-		 * 实现：从 2 位小数开始递增位数，直到文本能精确表示该数值
-		 *（容差 1e-7 相对量，与 float 精度匹配）。
-		 *
-		 * @param [IN] value 数值。
-		 * @return 显示文本。
-		 */
-		std::wstring FormatNumberText(double value)
-		{
-			const double tolerance = std::max(1.0e-12, std::fabs(value) * 1.0e-7);
-			for (int decimals = 2; decimals <= 9; ++decimals)
-			{
-				const std::wstring text = jdi::FormatNumber(value, decimals);
-				const double parsed = std::wcstod(text.c_str(), nullptr);
-				if (std::fabs(parsed - value) <= tolerance)
-				{
-					return text;
-				}
-			}
-			return jdi::FormatNumber(value, 9);
-		}
-
-		/**
-		 * @brief 带正负符号的数值文本（非编辑态显示偏移量时使用）。
-		 *
-		 * 规则（用户明确要求）：**正数带 `+`、负数带 `-`、0 不带任何符号**。
-		 * （旧实现 0 也会显示 `+0.00`，用户报告“偏移调整的 Y 轴输入框默认值为 0 时也显示了正号，这不正确”。）
-		 * @param [IN] value 数值。
-		 * @return 形如 `+1.50` / `-0.25` / `0.00` 的文本。
-		 */
-		std::wstring FormatSignedNumber(double value)
-		{
-			const std::wstring text = FormatNumberText(std::fabs(value));
-			if (value > 0.0)
-			{
-				return L"+" + text;
-			}
-			if (value < 0.0)
-			{
-				return L"-" + text;
-			}
-			return text;	// 0：不带符号
-		}
-
-		/**
-		 * @brief 把系数格式化为界面文本（与偏移量同一套两位小数规则 + 显式正号）。
-		 *
-		 * 规则（用户明确要求）：“系数调整”输入框**非编辑态**显示时，非 0 正值前面加 `+`，
-		 * 负值按原样显示负号，0 不带符号。编辑态仍用不带符号的纯数值（见 `FormatNumberText`）。
-		 * @param [IN] gain 系数。
-		 * @return 显示文本。
-		 */
-		std::wstring FormatGainText(float gain)
-		{
-			const double value = static_cast<double>(gain);
-			if (value > 0.0)
-			{
-				return L"+" + FormatNumberText(value);
-			}
-			return FormatNumberText(value);
-		}
-
-		/**
-		 * @brief 「时间轴」偏移的非编辑态显示文本（`Δt：` + 带正负号的复合单位间隔）。
-		 *
-		 * 规则（用户明确要求）：在 `Δt：` 冒号后的时间显示值**前面加上正负号**，
-		 * 只有值为 0 时不显示符号。示例：`Δt：+1h 1min 2s` / `Δt：-5s 60ms` / `Δt：0s`。
-		 *（`FormatDurationCompound` 内部取绝对值，因此符号由这里补上。）
-		 * @param [IN] seconds 时间偏移（秒，可为负）。
-		 * @return 显示文本。
-		 */
-		std::wstring FormatOffsetTimeText(double seconds)
-		{
-			if (seconds > 0.0)
-			{
-				return L"Δt：+" + FormatDurationCompound(seconds);
-			}
-			if (seconds < 0.0)
-			{
-				return L"Δt：-" + FormatDurationCompound(seconds);
-			}
-			return L"Δt：" + FormatDurationCompound(0.0);
-		}
-	}
 
 	SignalPanel::SignalPanel()
 	{
@@ -359,96 +84,6 @@ namespace jdi
 		return dirty;
 	}
 
-	bool SignalPanel::IsOnFilterBox(int x, int y) const
-	{
-		return UiPointInRect(m_filterRect, static_cast<float>(x), static_cast<float>(y));
-	}
-
-	void SignalPanel::ClearFilter()
-	{
-		if (m_filterText.empty() && !m_filterEditing)
-		{
-			return;
-		}
-		m_filterText.clear();
-		if (m_filterEditing)
-		{
-			// 编辑态下一并重置输入模型，避免残留旧文本（Begin 会整段选中/清空）。
-			m_filterEdit.Begin(std::wstring(), false, EditFilter::ANY, 0u);
-		}
-		// 退出筛选：筛选模式下临时折起的状态与动画一并作废（行集合会整体重建）。
-		m_filterCollapsed.clear();
-		m_groupAnims.clear();
-		m_rowShift.clear();
-		// 清空后回到完整列表：重建行集合、回到顶部。
-		m_rowsDirty = true;
-		m_scrollOffset = 0.0f;
-		m_layoutDirty = true;
-	}
-
-	HCURSOR SignalPanel::QueryCursor(int x, int y)
-	{
-		// 清空按钮 ✕ 是独立可点击控件，用手型光标给出除高亮之外的额外交互提示。
-		const gd::RectF clearRect = FilterClearRect();
-		if (clearRect.Width > 0.0f &&
-		    UiPointInRect(clearRect, static_cast<float>(x), static_cast<float>(y)))
-		{
-			return LoadCursorW(nullptr, IDC_HAND);
-		}
-
-		// 信号行左侧的「移除该信号」✕ 同理。
-		RowPart part = RowPart::NONE;
-		if (HitRow(x, y, part) >= 0 && part == RowPart::REMOVE_SIGNAL)
-		{
-			return LoadCursorW(nullptr, IDC_HAND);
-		}
-
-		// 样式区的可点击控件（「调整」行三个按钮、线宽/透明度数值框）也用手型光标。
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-		// 样式区顶部「目标」行的信号名与 GX 标签：与信号列表行一致，用手型光标提示可交互。
-		UpdateTargetRowGeometry();
-		if ((m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy)) ||
-		    (m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy)))
-		{
-			return LoadCursorW(nullptr, IDC_HAND);
-		}
-		if (UiPointInRect(m_adjustRects[kAdjustGain], fx, fy) ||
-		    UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy) ||
-		    UiPointInRect(m_adjustRects[kAdjustAbsolute], fx, fy) || UiPointInRect(m_widthValueRect, fx, fy) ||
-		    UiPointInRect(m_opacityValueRect, fx, fy))
-		{
-			return LoadCursorW(nullptr, IDC_HAND);
-		}
-		return nullptr;
-	}
-
-	void SignalPanel::BeginFilterEdit()
-	{
-		if (m_filterEditing)
-		{
-			return;
-		}
-		m_filterEditing = true;
-		// 单击进入编辑：光标落在末尾，不做全选（用户可以继续追加筛选词）。
-		m_filterEdit.Begin(m_filterText, false, EditFilter::ANY, 0u);
-	}
-
-	bool SignalPanel::EndFilterEdit()
-	{
-		if (!m_filterEditing)
-		{
-			return false;
-		}
-		// **必须**在 `End()` 之前取出文本：`TextEdit::End()` 会清空内部缓冲区。
-		const std::wstring finalText = Trim(m_filterEdit.Text());
-		m_filterEditing = false;
-		m_filterEdit.End();
-		// 文本在编辑过程中已实时生效，这里只需把最终值再同步一次并收起插入符。
-		m_filterText = finalText;
-		return true;
-	}
-
 	void SignalPanel::ApplyFilterText(const std::wstring& text)
 	{
 		if (m_filterText == text)
@@ -708,92 +343,6 @@ namespace jdi
 		return true;
 	}
 
-	bool SignalPanel::AdvanceGroupAnimations()
-	{
-		if (m_groupAnims.empty())
-		{
-			return false;
-		}
-
-		const std::uint64_t now = GetTickCount64();
-		bool rowsBecameStale = false;
-		for (std::size_t index = 0; index < m_groupAnims.size();)
-		{
-			const GroupAnim& anim = m_groupAnims[index];
-			const std::uint64_t elapsed = (now >= anim.startMs) ? (now - anim.startMs) : 0;
-			if (anim.durationMs == 0u || elapsed >= anim.durationMs)
-			{
-				// 完成：把同步滚动精确落到终点（最后一帧的 eased 进度未必正好是 1）。
-				if (anim.scrollSynced)
-				{
-					m_scrollOffset = anim.scrollTo;
-				}
-				// 折起完成后该组的信号行要**真正移除** ⇒ 行集合需重建
-				//（展开完成后行集合本来就是展开态，无需重建；平移量归零即可）。
-				if (anim.collapsing)
-				{
-					rowsBecameStale = true;
-				}
-				m_groupAnims.erase(m_groupAnims.begin() + static_cast<std::ptrdiff_t>(index));
-			}
-			else
-			{
-				++index;
-			}
-		}
-
-		// ⚠️ **不设置 `m_rowsDirty`**：行高不随动画变化，只需重算逐行位移与内容高度 ——
-		// 这正是本动画方案比“逐行缩放”流畅得多的原因（无需每帧重建行集合）。
-		UpdateAnimGeometry();
-		if (rowsBecameStale)
-		{
-			m_rowsDirty = true;
-		}
-		return !m_groupAnims.empty();
-	}
-
-	void SignalPanel::ToggleGroupFromRow(int groupIndex, int row)
-	{
-		EnsureRows();
-		if (m_tab == nullptr || groupIndex < 0)
-		{
-			return;
-		}
-
-		const int headerRow =
-		    (row >= 0 && row < static_cast<int>(m_rows.size()) &&
-		     m_rows[static_cast<std::size_t>(row)].kind == RowKind::GROUP &&
-		     m_rows[static_cast<std::size_t>(row)].groupIndex == groupIndex)
-		        ? row
-		        : GroupRowIndex(groupIndex);
-
-		const bool collapse = !IsGroupCollapsed(groupIndex);
-		SetGroupCollapsed(groupIndex, collapse);
-
-		// 悬浮（组名的自然位置已在列表上边界之上）且要折起时：**一边向上滚动一边收起**，
-		// 保证悬浮组名始终留在列表最上方，动画结束时滚动偏移恰好落在“组名正好在最上方”。
-		//（用户 2026-10-16 第二轮明确要求：不再“先滚动到位、再播放收起动画”。）
-		float scrollFrom = m_scrollOffset;
-		float scrollTo = m_scrollOffset;
-		bool syncScroll = false;
-		if (collapse && headerRow >= 0)
-		{
-			const float alignOffset = ContentOffsetBeforeRow(headerRow);
-			if (m_scrollOffset > alignOffset + 0.5f)
-			{
-				// 目标滚动量受“折起后的最终内容高度”限制：若内容比列表还短，
-				// 就无法把组名顶到最上方（此时取可达的最大滚动量，避免结束时被强行夹取）。
-				const float finalContent =
-				    std::max(0.0f, NaturalContentHeight() - ShownBlockHeight(groupIndex));
-				const float maxOffset = std::max(0.0f, finalContent - m_listRect.Height);
-				scrollTo = std::max(0.0f, std::min(alignOffset, maxOffset));
-				syncScroll = true;
-			}
-		}
-
-		StartGroupToggle(groupIndex, collapse, scrollFrom, scrollTo, syncScroll);
-	}
-
 	float SignalPanel::AnimationHideTopForRow(int row, int stickyRow) const
 	{
 		if (m_groupAnims.empty() || row < 0 || row >= static_cast<int>(m_rows.size()))
@@ -1026,40 +575,6 @@ namespace jdi
 		return std::min(m_listRect.Y, lastBottom - m_rows[static_cast<std::size_t>(row)].height);
 	}
 
-	void SignalPanel::PaintStickyGroupRow(gd::Graphics& g, int row)
-	{
-		if (row < 0 || row >= static_cast<int>(m_rows.size()) ||
-		    m_rows[static_cast<std::size_t>(row)].kind != RowKind::GROUP)
-		{
-			return;
-		}
-
-		const int rowCount = static_cast<int>(m_rows.size());
-		const float height = m_rows[static_cast<std::size_t>(row)].height;
-		const float naturalY = RowRect(row).Y;
-		const float stickyY = StickyGroupRowTop(row, rowCount);
-		if (stickyY + height <= m_listRect.Y + 0.5f)
-		{
-			return;		// 已经整块滑出列表上边界
-		}
-
-		m_rowYOverrideActive = true;
-		m_rowYOverrideY = stickyY;
-		// 悬浮行必须是不透明的，否则下面的信号行会与组名叠在一起看不清；
-		// `FillRowRect` 会把矩形夹到列表矩形（GDI 填充不受 GDI+ 裁剪约束）。
-		SetRowClip(gd::RectF(m_listRect.X, stickyY, m_listRect.Width, height));
-		FillRowRect(g, gd::RectF(m_listRect.X, stickyY, m_listRect.Width, height), m_theme->panelBg);
-		PaintGroupRow(g, row);
-		ClearRowClip();
-		// 只有真正“浮”在其它行之上时才补一条底部边界线（否则会与正常绘制有差异）。
-		if (stickyY > naturalY + 0.5f)
-		{
-			UiDrawLine(g, m_listRect.X, stickyY + height - 0.5f, m_listRect.X + m_listRect.Width,
-			           stickyY + height - 0.5f, m_theme->border, 1.0f);
-		}
-		m_rowYOverrideActive = false;
-	}
-
 	gd::RectF SignalPanel::GroupCloseRect(int row) const
 	{
 		const gd::RectF rect = RowRect(row);
@@ -1156,81 +671,6 @@ namespace jdi
 		return RowPart::BODY;
 	}
 
-	int SignalPanel::HitRow(int x, int y, RowPart& part)
-	{
-		part = RowPart::NONE;
-		EnsureRows();
-
-		if (m_listRect.Height <= 0.0f)
-		{
-			return -1;
-		}
-
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-		if (fy < m_listRect.Y || fy > m_listRect.Y + m_listRect.Height)
-		{
-			return -1;
-		}
-		if (fx < m_listRect.X || fx > m_listRect.X + m_listRect.Width)
-		{
-			return -1;
-		}
-
-		// 「悬浮组名」绘制在最上层，因此命中判定也必须最优先 —— 否则点击会**穿透到
-		// 它下面的那一行**（用户 2026-10-16 报告：组名悬浮时它上面的折叠三角、复选框、
-		// 关闭 ✕、名称区域全都点不动，点击被下层信号行吃掉）。
-		const int rowCount = static_cast<int>(m_rows.size());
-		const int stickyRow = StickyGroupRowIndex(rowCount);
-		if (stickyRow >= 0)
-		{
-			const float stickyTop = StickyGroupRowTop(stickyRow, rowCount);
-			const float stickyHeight = m_rows[static_cast<std::size_t>(stickyRow)].height;
-			if (fy >= stickyTop && fy < stickyTop + stickyHeight)
-			{
-				// 用覆盖几何计算行内区域（`RowRect` 是行内所有派生的唯一几何来源）。
-				m_rowYOverrideActive = true;
-				m_rowYOverrideY = stickyTop;
-				part = RowHitPart(stickyRow, fx, fy);
-				m_rowYOverrideActive = false;
-				return stickyRow;
-			}
-		}
-
-		const float local = fy - m_listRect.Y + m_scrollOffset;
-		if (local < 0.0f)
-		{
-			return -1;
-		}
-
-		// 逐行比较“实际绘制位置”（含折起/展开动画的刚性平移），不能只看滚动偏移：
-		// 动画中信号行的位置与“自然内容坐标”不再一一对应，用后者会点错行。
-		float rowTop = m_listRect.Y - m_scrollOffset;
-		for (std::size_t index = 0; index < m_rows.size(); ++index)
-		{
-			const float shift = (index < m_rowShift.size()) ? m_rowShift[index] : 0.0f;
-			const float previousShift =
-			    (index > 0 && (index - 1) < m_rowShift.size()) ? m_rowShift[index - 1] : 0.0f;
-			rowTop -= (shift - previousShift);
-
-			const ListRow& row = m_rows[index];
-			const float rowBottom = rowTop + row.height;
-			if (row.height > 0.0f && fy >= rowTop && fy < rowBottom)
-			{
-				const int rowIndex = static_cast<int>(index);
-				// 折起/展开动画中已“藏进组名栏”的行不再参与命中（否则它会白白吸走一次点击）。
-				if (rowBottom > AnimationHideTopForRow(rowIndex, stickyRow) + 0.5f)
-				{
-					part = RowHitPart(rowIndex, fx, fy);
-					return rowIndex;
-				}
-				return -1;
-			}
-			rowTop = rowBottom;
-		}
-		return -1;
-	}
-
 	float SignalPanel::ContentOffsetBeforeRow(int row) const
 	{
 		float top = 0.0f;
@@ -1242,62 +682,6 @@ namespace jdi
 		return top;
 	}
 
-	void SignalPanel::StartScrollAnimationTo(float desired)
-	{
-		const float maxOffset = std::max(0.0f, m_contentHeight - m_listRect.Height);
-		desired = std::max(0.0f, std::min(desired, maxOffset));
-		const float distance = std::fabs(desired - m_scrollOffset);
-
-		if (distance < 1.0f)
-		{
-			// 已经到位：不需要动画（但仍然要把残余的亚像素差抹平）。
-			m_scrollOffset = desired;
-			ClampScroll();
-			m_scrollAnimActive = false;
-			return;
-		}
-
-		// 时长随距离增长（越远越快 = 同样时间内走更多距离），到上限后不再增长，
-		// 因此"整个动画过程不会太久"（最长 300ms）。
-		const float durationMs =
-		    std::max(kScrollAnimMinMs, std::min(kScrollAnimMaxMs, distance * kScrollAnimMsPerPixel));
-		m_scrollAnimFrom = m_scrollOffset;
-		m_scrollAnimTo = desired;
-		m_scrollAnimStartMs = GetTickCount64();
-		m_scrollAnimDurationMs = static_cast<std::uint32_t>(durationMs + 0.5f);
-		m_scrollAnimActive = true;
-	}
-
-	void SignalPanel::ScrollToSignal(const SignalRef& ref)
-	{
-		EnsureRows();
-		if (!ref.IsValid())
-		{
-			return;
-		}
-
-		float top = 0.0f;
-		for (std::size_t index = 0; index < m_rows.size(); ++index)
-		{
-			const ListRow& row = m_rows[index];
-			if (row.kind == RowKind::SIGNAL && row.groupIndex == ref.groupIndex &&
-			    row.signalIndex == ref.signalIndex)
-			{
-				if (top < m_scrollOffset)
-				{
-					m_scrollOffset = top;
-				}
-				else if (top + row.height > m_scrollOffset + m_listRect.Height)
-				{
-					m_scrollOffset = top + row.height - m_listRect.Height;
-				}
-				ClampScroll();
-				return;
-			}
-			top += row.height;
-		}
-	}
-
 	void SignalPanel::LayoutStyleControls()
 	{
 		const float padH = kStylePadH * m_scale;
@@ -1523,397 +907,6 @@ namespace jdi
 		LayoutStyleControls();
 	}
 
-	void SignalPanel::Paint(gd::Graphics& g)
-	{
-		if (m_theme == nullptr || m_fonts == nullptr)
-		{
-			return;
-		}
-
-		EnsureRows();
-		UiFillRect(g, m_area, m_theme->panelBg);
-
-		// 标题区。
-		{
-			std::wstring title = L"信号";
-			if (m_dataSet != nullptr && m_tab != nullptr)
-			{
-				title += L" · " + std::to_wstring(m_tab->VisibleCount()) + L"/" +
-				         std::to_wstring(TotalSignalCount()) + L" 已选";
-			}
-
-			gd::RectF titleRect(m_headerRect.X + kPadding * m_scale, m_headerRect.Y,
-			                    std::max(20.0f, m_headerRect.Width - kPadding * 2.0f * m_scale -
-			                                        m_toggleAllRect.Width - 8.0f * m_scale),
-			                    m_headerRect.Height);
-			UiText(g, UiEllipsize(title, m_fonts->uiBold, titleRect.Width), m_fonts->uiBold, titleRect,
-			       m_theme->textStrong, TextAlign::LEFT);
-
-			const bool allVisible = AreAllSignalsVisible();
-			const std::wstring toggleLabel = allVisible ? L"全部隐藏" : L"全部显示";
-			const bool toggleHover = (m_hoverStyle == StyleHit::TOGGLE_ALL);
-			if (toggleHover)
-			{
-				UiFillRoundRect(g, m_toggleAllRect, kCorner * m_scale, m_theme->hover);
-			}
-			UiDrawRoundRect(g, m_toggleAllRect, kCorner * m_scale, m_theme->border, 1.0f);
-			const bool enabled = (m_dataSet != nullptr && !m_dataSet->Empty());
-			UiText(g, toggleLabel, m_fonts->uiSmall, m_toggleAllRect,
-			       enabled ? m_theme->text : m_theme->textMuted, TextAlign::CENTER);
-		}
-
-		// 「筛选信号」输入框：未输入内容时显示占位提示，单击进入编辑，输入实时过滤下方列表。
-		{
-			UiFillRoundRect(g, m_filterRect, kCorner * m_scale, m_theme->cardBg);
-			UiDrawRoundRect(g, m_filterRect, kCorner * m_scale,
-			                m_filterEditing ? m_theme->accent : m_theme->border,
-			                m_filterEditing ? 1.6f : 1.0f);
-
-			const float pad = kFilterTextPad * m_scale;
-			const gd::RectF clearRect = FilterClearRect();
-			// 有输入内容时在右侧留出 ✕ 的位置，文本不会压到按钮上。
-			const float textRight = (clearRect.Width > 0.0f) ? clearRect.X : (m_filterRect.X + m_filterRect.Width);
-			const float textWidth = std::max(8.0f, textRight - pad - (m_filterRect.X + pad));
-			const gd::RectF textRect(m_filterRect.X + pad, m_filterRect.Y, textWidth,
-			                         m_filterRect.Height);
-
-			if (m_filterEditing)
-			{
-				// 外框（m_filterRect）已经画好了底板与强调色边框，这里只叠加文本内容。
-				// 若改用 UiDrawEditField，会在外框内部再套一个带边框的圆角框，
-				// 空内容时只剩一圈内框十分突兀（用户明确要求去掉这层"内圈"）。
-				gd::RectF fieldRect = FilterFieldRect();
-				fieldRect.Width = std::max(8.0f, textWidth + pad);
-				UiDrawEditFieldContent(g, fieldRect, m_filterEdit, m_fonts->uiSmall, m_scale);
-			}
-			else if (m_filterText.empty())
-			{
-				UiText(g, L"筛选信号", m_fonts->uiSmall, textRect, m_theme->textMuted, TextAlign::LEFT);
-			}
-			else
-			{
-				UiText(g, UiEllipsize(m_filterText, m_fonts->uiSmall, textWidth), m_fonts->uiSmall,
-				       textRect, m_theme->text, TextAlign::LEFT);
-			}
-
-			// 清空按钮 ✕：仅在筛选框有内容时出现，悬停高亮（鼠标光标保持箭头）。
-			if (clearRect.Width > 0.0f)
-			{
-				const bool clearHot = (m_hoverStyle == StyleHit::FILTER_CLEAR);
-				if (clearHot)
-				{
-					UiFillRoundRect(g, clearRect, 3.0f * m_scale, WithAlpha(m_theme->danger, 0x33));
-				}
-				const std::uint32_t crossColor = clearHot ? m_theme->danger : m_theme->textMuted;
-				const float crossPad = clearRect.Width * 0.28f;
-				UiDrawLine(g, clearRect.X + crossPad, clearRect.Y + crossPad,
-				           clearRect.X + clearRect.Width - crossPad,
-				           clearRect.Y + clearRect.Height - crossPad, crossColor, 1.5f * m_scale);
-				UiDrawLine(g, clearRect.X + clearRect.Width - crossPad, clearRect.Y + crossPad,
-				           clearRect.X + crossPad, clearRect.Y + clearRect.Height - crossPad, crossColor,
-				           1.5f * m_scale);
-			}
-		}
-
-		// 列表区。
-		{
-			const int saveState = g.Save();
-			g.SetClip(gd::RectF(m_listRect.X, m_listRect.Y, m_listRect.Width, m_listRect.Height));
-
-			if (m_dataSet == nullptr || m_dataSet->Empty())
-			{
-				UiText(g, L"尚未加载数据，请打开数据文件", m_fonts->uiSmall, m_listRect, m_theme->textMuted,
-				       TextAlign::CENTER);
-			}
-			else if (m_rows.empty() && !m_filterText.empty())
-			{
-				// 筛选结果为空：明确提示"无匹配"，而不是让人误以为数据丢失。
-				UiText(g, L"无匹配的筛选信号", m_fonts->uiSmall, m_listRect, m_theme->textMuted,
-				       TextAlign::CENTER);
-			}
-			else
-			{
-				const int rowCount = static_cast<int>(m_rows.size());
-				// 先定出要「悬浮」的分组行（若有）：常规循环跳过它，最后统一钉在列表顶部绘制，
-				// 否则它会先被画一次在滚动位置上、又被画一次在顶部（视觉上重叠两份）。
-				const int stickyRow = StickyGroupRowIndex(rowCount);
-				for (int row = 0; row < rowCount; ++row)
-				{
-					if (row == stickyRow)
-					{
-						continue;
-					}
-					const gd::RectF rect = RowRect(row);
-					if (rect.Y + rect.Height < m_listRect.Y || rect.Y > m_listRect.Y + m_listRect.Height)
-					{
-						continue;
-					}
-
-					// 折起/展开动画：信号行整组向上平移，越过组名下边界的部分要“消失（藏进组名栏）”。
-					// 已经完全越过的行整行跳过（省一次绘制），部分越过的行把裁剪上边界抬到组名下边界；
-					// ⚠️ 此时还必须把 **GDI+ 裁剪**也收紧到同一条线 —— 行内的色块 / 复选框 / 网格徽标
-					// 走的是 GDI+ 绘制（只受 `SetClip` 约束），不收紧就会画到组名栏上面去。
-					const int rowSave = g.Save();
-					SetRowClip(rect);
-					const float hideTop = AnimationHideTopForRow(row, stickyRow);
-					if (hideTop > rect.Y + 0.5f)
-					{
-						if (rect.Y + rect.Height <= hideTop + 0.5f)
-						{
-							g.Restore(rowSave);
-							ClearRowClip();
-							continue;
-						}
-						ClampRowClipTop(hideTop);
-						g.SetClip(m_rowClipRect, gd::CombineModeIntersect);
-					}
-
-					if (m_rows[static_cast<std::size_t>(row)].kind == RowKind::GROUP)
-					{
-						PaintGroupRow(g, row);
-					}
-					else
-					{
-						PaintSignalRow(g, row);
-					}
-					g.Restore(rowSave);
-					ClearRowClip();
-				}
-
-				PaintStickyGroupRow(g, stickyRow);
-			}
-
-			g.Restore(saveState);
-		}
-
-		PaintScrollBar(g);
-		PaintStyleSection(g);
-
-		// 分隔线。
-		UiDrawLine(g, m_area.X + m_area.Width - 1.0f, m_area.Y, m_area.X + m_area.Width - 1.0f,
-		           m_area.Y + m_area.Height, m_theme->border, 1.0f);
-		UiDrawLine(g, m_headerRect.X, m_headerRect.Y + m_headerRect.Height - 1.0f,
-		           m_headerRect.X + m_headerRect.Width, m_headerRect.Y + m_headerRect.Height - 1.0f,
-		           m_theme->border, 1.0f);
-		if (m_styleRect.Height > 0.0f)
-		{
-			UiDrawLine(g, m_styleRect.X, m_styleRect.Y, m_styleRect.X + m_styleRect.Width, m_styleRect.Y,
-			           m_theme->border, 1.0f);
-		}
-	}
-
-	void SignalPanel::PaintRowText(gd::Graphics& g, const std::wstring& text, HFONT font,
-	                               const gd::RectF& rect, std::uint32_t argb, TextAlign align)
-	{
-		// 行内文本必须显式裁剪：GDI 文本不遵循 GDI+ 的 `SetClip`，
-		// 否则列表滚动时顶部那些“部分可见”的行会把组名/信号名画到筛选框上。
-		// 另外，分组折起动画期间行高会连续缩小 —— 此时必须裁到**本行矩形**内，
-		// 否则垂直居中的文字会溢出到相邻行上。
-		UiTextClipped(g, text, font, rect, argb, align, m_rowClipActive ? m_rowClipRect : m_listRect);
-	}
-
-	void SignalPanel::FillRowRect(gd::Graphics& g, const gd::RectF& rect, std::uint32_t argb)
-	{
-		// 夹取而不是裁剪：纯色填充下两者等价，而夹取对 `UiFillRect` 的 GDI 快路径同样有效
-		//（大面积不透明矩形会改走 GDI `FillRect`，它同样不受 GDI+ 裁剪约束）。
-		gd::RectF clipped = rect;
-		clipped.Intersect(m_rowClipActive ? m_rowClipRect : m_listRect);
-		if (clipped.Width <= 0.0f || clipped.Height <= 0.0f)
-		{
-			return;
-		}
-		UiFillRect(g, clipped, argb);
-	}
-
-	void SignalPanel::PaintGroupRow(gd::Graphics& g, int row)
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr || row < 0 || row >= static_cast<int>(m_rows.size()))
-		{
-			return;
-		}
-
-		const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-		const SignalGroup* group = m_dataSet->GroupAt(item.groupIndex);
-		if (group == nullptr)
-		{
-			return;
-		}
-
-		const gd::RectF rect = RowRect(row);
-		const bool hovered = (m_hoverRow == row);
-		if (hovered)
-		{
-			FillRowRect(g, rect, m_theme->hover);
-		}
-		FillRowRect(g, gd::RectF(rect.X, rect.Y, 2.0f * m_scale, rect.Height),
-		            WithAlpha(m_theme->borderStrong, 0x90));
-
-		const float baseX = rect.X + kPadding * m_scale;
-		const float centerY = rect.Y + rect.Height * 0.5f;
-		const bool collapsed = IsGroupCollapsed(item.groupIndex);
-
-		// 折叠三角。
-		{
-			const float cx = baseX + kDisclosureWidth * m_scale * 0.5f;
-			const std::uint32_t color =
-			    (hovered && m_hoverPart == RowPart::DISCLOSURE) ? m_theme->accent : m_theme->text;
-			UiDrawTriangleIcon(g, gd::RectF(cx - 6.0f * m_scale, centerY - 6.0f * m_scale, 12.0f * m_scale,
-			                                12.0f * m_scale),
-			                   color, collapsed ? IconDirection::RIGHT : IconDirection::DOWN);
-		}
-
-		// 分组复选框（三态：全选 / 部分 / 未选）。
-		const gd::RectF checkRect(baseX + kDisclosureWidth * m_scale, centerY - kCheckSize * m_scale * 0.5f,
-		                          kCheckSize * m_scale, kCheckSize * m_scale);
-		const bool allVisible = m_tab->GroupAllVisible(item.groupIndex);
-		const bool anyVisible = m_tab->GroupHasVisible(item.groupIndex);
-		UiDrawCheckBox(g, checkRect, allVisible ? 1 : (anyVisible ? 2 : 0), 3.0f * m_scale);
-
-		const gd::RectF closeRect = GroupCloseRect(row);
-
-		// 分组标题：左侧为“组X”标签，右侧以绘制的竖线分隔分组名（不使用字符），再显示可重命名的名称。
-		const std::wstring groupLabel = GroupLabelText(item.groupIndex);
-		// 项数文本与 `RowNameRect`（组名编辑框）共用同一来源，保证名称宽度与绘制不漂移。
-		const std::wstring stats = GroupStatsText(row);
-		const float groupWidth = GroupLabelWidth(row);
-		const float statsWidth = UiMeasureTextWidth(m_fonts->uiSmall, stats);
-		const float statsRight = closeRect.X - 6.0f * m_scale;
-		const float nameLeft = checkRect.X + checkRect.Width + 8.0f * m_scale;
-		const float nameAreaLeft =
-		    nameLeft + groupWidth + kGroupSeparatorGap * 2.0f * m_scale + kGroupSeparatorWidth * m_scale;
-		const float nameWidth =
-		    std::max(20.0f, statsRight - statsWidth - 6.0f * m_scale - nameAreaLeft);
-
-		// 序号以强调色突出，便于在多组之间快速定位。
-		PaintRowText(g, groupLabel, m_fonts->uiBold, gd::RectF(nameLeft, rect.Y, groupWidth, rect.Height),
-		             m_theme->accent, TextAlign::LEFT);
-
-		// 竖线分隔符：以绘制方式实现，与文字基线无关，排版更稳。
-		FillRowRect(g, gd::RectF(nameLeft + groupWidth + kGroupSeparatorGap * m_scale,
-		                         rect.Y + 7.0f * m_scale, kGroupSeparatorWidth * m_scale,
-		                         rect.Height - 14.0f * m_scale),
-		            WithAlpha(m_theme->borderStrong, 0xB0));
-
-		if (m_editField == StyleEditField::GROUP_TITLE && m_editRow == row)
-		{
-			UiDrawEditField(g, RowNameRect(row), m_edit, m_fonts->uiSmall, m_scale);
-		}
-		else
-		{
-			PaintRowText(g, UiEllipsize(group->name, m_fonts->uiBold, nameWidth), m_fonts->uiBold,
-			             gd::RectF(nameAreaLeft, rect.Y, nameWidth, rect.Height), m_theme->textStrong,
-			             TextAlign::LEFT);
-		}
-
-		PaintRowText(g, stats, m_fonts->uiSmall, gd::RectF(statsRight - statsWidth, rect.Y, statsWidth, rect.Height),
-		             m_theme->textMuted, TextAlign::RIGHT);
-
-		// 关闭按钮（从工作区移除该分组）。
-		const bool closeHot = hovered && (m_hoverPart == RowPart::CLOSE);
-		if (closeHot)
-		{
-			UiFillRoundRect(g, closeRect, 3.0f * m_scale, m_theme->pressed);
-		}
-		UiDrawCrossIcon(g, closeRect, closeHot ? m_theme->danger : m_theme->textMuted, 1.5f * m_scale);
-	}
-
-	void SignalPanel::PaintSignalRow(gd::Graphics& g, int row)
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr || row < 0 || row >= static_cast<int>(m_rows.size()))
-		{
-			return;
-		}
-
-		const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-		const SignalRef ref{item.groupIndex, item.signalIndex};
-		const SignalData* signal = m_dataSet->Resolve(ref);
-		const SignalStyle* style = StyleOf(ref);
-		if (signal == nullptr || style == nullptr)
-		{
-			return;
-		}
-
-		const gd::RectF rect = RowRect(row);
-		const bool selected = (SelectedRef() == ref);
-		const bool hovered = (m_hoverRow == row);
-
-		if (selected)
-		{
-			FillRowRect(g, rect, m_theme->selection);
-			FillRowRect(g, gd::RectF(rect.X, rect.Y, 2.0f * m_scale, rect.Height), m_theme->accent);
-		}
-		else if (hovered)
-		{
-			FillRowRect(g, rect, m_theme->hover);
-		}
-
-		const float baseX = rect.X + kPadding * m_scale + kIndent * m_scale;
-		const float centerY = rect.Y + rect.Height * 0.5f;
-
-		// 复选框。
-		const gd::RectF checkRect(baseX + kDisclosureWidth * m_scale, centerY - kCheckSize * m_scale * 0.5f,
-		                          kCheckSize * m_scale, kCheckSize * m_scale);
-		// 可见性属于当前标签页，与全局共享的显示外观分开读取。
-		const bool visible = m_tab->IsVisible(ref);
-		UiDrawCheckBox(g, checkRect, visible ? 1 : 0, 3.0f * m_scale);
-
-		// 颜色块：叠加不透明度，透明度过低时自动补描边（与样式区色块规则一致）。
-		const gd::RectF swatchRect(checkRect.X + checkRect.Width + 6.0f * m_scale,
-		                           centerY - kSwatchSize * m_scale * 0.5f, kSwatchSize * m_scale,
-		                           kSwatchSize * m_scale);
-		UiDrawSwatch(g, swatchRect, style->color, visible ? style->opacity : 0.3f, 2.5f * m_scale,
-		             m_scale);
-
-		// 网格徽标（可点击，用于调整所属网格）。行尾 ✕ 恒在最右侧，徽标整体前移让位。
-		const int laneIndex = m_tab->LaneOfSignal(ref);
-		const bool badgeVisible = (laneIndex >= 0) && visible;
-		const gd::RectF badgeRect = SignalBadgeRect(row);
-		const gd::RectF removeRect = SignalRemoveRect(row);
-
-		float nameRightLimit = removeRect.X - 6.0f * m_scale;
-		if (badgeVisible)
-		{
-			nameRightLimit = badgeRect.X - 6.0f * m_scale;
-		}
-
-		// 名称：完全保留文件内的列名（含 "[n]" 序号与括号描述），双击可重命名。
-		const float nameLeft = swatchRect.X + swatchRect.Width + 6.0f * m_scale;
-		if (m_editField == StyleEditField::SIGNAL_NAME && m_editRow == row)
-		{
-			UiDrawEditField(g, RowNameRect(row), m_edit, m_fonts->ui, m_scale);
-		}
-		else
-		{
-			const float nameWidth = std::max(16.0f, nameRightLimit - nameLeft);
-			const std::uint32_t nameColor = visible ? m_theme->text : m_theme->textMuted;
-			PaintRowText(g, UiEllipsize(signal->name, m_fonts->ui, nameWidth), m_fonts->ui,
-			             gd::RectF(nameLeft, rect.Y, nameWidth, rect.Height), nameColor, TextAlign::LEFT);
-		}
-
-		if (badgeVisible)
-		{
-			const bool badgeHot = hovered && (m_hoverPart == RowPart::LANE_BADGE);
-			UiFillRoundRect(g, badgeRect, kBadgeHeight * m_scale * 0.5f,
-			                badgeHot ? m_theme->accentSoft : m_theme->cardBg);
-			UiDrawRoundRect(g, badgeRect, kBadgeHeight * m_scale * 0.5f,
-			                badgeHot ? m_theme->accent : m_theme->border, 1.0f);
-			PaintRowText(g, L"G" + std::to_wstring(laneIndex + 1), m_fonts->monoSmall, badgeRect,
-			             badgeHot ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
-		}
-
-		// 「移除该信号」✕：位于信号条目最右端，尺寸/样式/右边距与分组行的关闭 ✕ 完全一致。
-		// 最后绘制，确保它永远压在最上层（与分组行 ✕ 的绘制顺序保持一致）。
-		{
-			const bool removeHot = hovered && (m_hoverPart == RowPart::REMOVE_SIGNAL);
-			if (removeHot)
-			{
-				UiFillRoundRect(g, removeRect, 3.0f * m_scale, m_theme->pressed);
-			}
-			UiDrawCrossIcon(g, removeRect, removeHot ? m_theme->danger : m_theme->textMuted,
-			                1.5f * m_scale);
-		}
-	}
-
 	gd::RectF SignalPanel::ScrollThumbRect() const
 	{
 		if (!m_scrollBarVisible || m_contentHeight <= m_listRect.Height || m_listRect.Height <= 0.0f)
@@ -1930,266 +923,6 @@ namespace jdi
 		return gd::RectF(m_scrollBarRect.X, thumbY, m_scrollBarRect.Width, thumbHeight);
 	}
 
-	void SignalPanel::PaintScrollBar(gd::Graphics& g)
-	{
-		if (!m_scrollBarVisible || m_contentHeight <= m_listRect.Height)
-		{
-			return;
-		}
-
-		UiFillRoundRect(g, m_scrollBarRect, kScrollBarThickness * m_scale * 0.5f, m_theme->gridWeak);
-		UiFillRoundRect(g, ScrollThumbRect(), kScrollBarThickness * m_scale * 0.5f, m_theme->borderStrong);
-	}
-
-	void SignalPanel::PaintStyleSection(gd::Graphics& g)
-	{
-		if (m_styleRect.Height <= 0.0f)
-		{
-			return;
-		}
-
-		UiFillRect(g, m_styleRect, m_theme->panelBg);
-
-		// ---- 顶部「目标」行（无论是否已选中信号都要绘制：未选中时显示占位文本）----
-		PaintTargetRow(g);
-
-		const SignalStyle* style = (m_tab == nullptr) ? nullptr : StyleOf(SelectedRef());
-		if (style == nullptr || SelectedRef().IsValid() == false)
-		{
-			// 提示文本只占「目标」行以下的区域，避免与目标行重叠。
-			const float top = m_targetRowRect.Y + m_targetRowRect.Height;
-			UiText(g, L"请选择信号以编辑样式", m_fonts->uiSmall,
-			       gd::RectF(m_styleRect.X, top, m_styleRect.Width,
-			                 std::max(0.0f, m_styleRect.Y + m_styleRect.Height - top)),
-			       m_theme->textMuted, TextAlign::CENTER);
-			return;
-		}
-
-		const float labelWidth = kStyleLabelWidth * m_scale;
-
-		// 行标签统一以整行为基准垂直居中，确保与同行控件纵向对齐。
-		auto paintRowLabel = [&](int rowIndex, const wchar_t* text)
-		{
-			const gd::RectF& row = m_styleRowRects[static_cast<std::size_t>(rowIndex)];
-			UiText(g, text, m_fonts->uiSmall, gd::RectF(row.X, row.Y, labelWidth, row.Height),
-			       m_theme->textMuted, TextAlign::LEFT);
-		};
-
-		// ---- 第一行：颜色（预设色块 + 自定义颜色入口）----
-		{
-			paintRowLabel(0, L"颜色");
-
-			int paletteCount = 0;
-			const std::uint32_t* palette = SignalPalette(paletteCount);
-
-			// 判定“当前是否在用自定义色”：必须同时满足
-			//   1) 显示颜色等于记忆的自定义色；
-			//   2) 该颜色不是任何一个可见的预设色。
-			// 否则一旦自定义色与某个预设色相同时，点击那个预设色块会把高亮错误地
-			// 挪到自定义色块上（用户报告的“点预设色直接跳到自定义色块”）。
-			bool presetMatches = false;
-			for (int index = 0; index < m_colorCount; ++index)
-			{
-				if (style->color == palette[index % paletteCount])
-				{
-					presetMatches = true;
-					break;
-				}
-			}
-			const bool customActive = (style->color == style->customColor) && !presetMatches;
-			for (int index = 0; index < m_colorCount; ++index)
-			{
-				const gd::RectF& rect = m_colorRects[static_cast<std::size_t>(index)];
-				const std::uint32_t color = palette[index % paletteCount];
-				const bool hovered = (m_hoverStyle == StyleHit::COLOR && m_hoverStyleIndex == index);
-				const bool active = !customActive && (style->color == color);
-
-				// 预设色块同样叠加不透明度；透明度过低时自动补描边以保证可辨识（与自定义色块一致）。
-				UiDrawSwatch(g, rect, color, style->opacity, kCorner * m_scale, m_scale);
-				if (active || hovered)
-				{
-					const gd::RectF ring(rect.X - 2.0f * m_scale, rect.Y - 2.0f * m_scale,
-					                     rect.Width + 4.0f * m_scale, rect.Height + 4.0f * m_scale);
-					UiDrawRoundRect(g, ring, 5.0f * m_scale,
-					                active ? m_theme->textStrong : m_theme->borderStrong,
-					                active ? 1.6f : 1.0f);
-				}
-			}
-
-			// 自定义颜色入口：与预设色块完全同尺寸、同外框规则的小方格，仅多一个加号图标。
-			// 方格始终显示记忆的自定义颜色，因此从任意预设色再次点击它都能立即回到上次的自定义色。
-			const bool chipHot = (m_hoverStyle == StyleHit::CUSTOM_CHIP);
-			const std::uint32_t chipColor =
-			    UiDrawSwatch(g, m_customChipRect, style->customColor, style->opacity, kCorner * m_scale, m_scale);
-			const std::uint32_t iconColor = IsDarkColor(chipColor) ? 0xFFFDF6E3u : 0xFF073642u;
-			UiDrawPlusIcon(g, m_customChipRect, iconColor, 1.6f * m_scale);
-
-			// 当前正在使用自定义颜色、或鼠标悬停时，显示与预设色块一致的外框。
-			if (customActive || chipHot)
-			{
-				const gd::RectF& chip = m_customChipRect;
-				const gd::RectF ring(chip.X - 2.0f * m_scale, chip.Y - 2.0f * m_scale,
-				                     chip.Width + 4.0f * m_scale, chip.Height + 4.0f * m_scale);
-				UiDrawRoundRect(g, ring, 5.0f * m_scale,
-				                customActive ? m_theme->textStrong : m_theme->borderStrong,
-				                customActive ? 1.6f : 1.0f);
-			}
-		}
-
-		// ---- 第二行：样式（线段 / 散点 / 点线）----
-		{
-			paintRowLabel(1, L"样式");
-
-			for (int index = 0; index < kModeOptionCount; ++index)
-			{
-				const gd::RectF& rect = m_modeRects[static_cast<std::size_t>(index)];
-				const bool active = (style->mode == kModeOptions[index]);
-				const bool hovered = (m_hoverStyle == StyleHit::MODE && m_hoverStyleIndex == index);
-
-				UiFillRoundRect(g, rect, kCorner * m_scale,
-				                active ? m_theme->accentSoft : (hovered ? m_theme->hover : m_theme->cardBg));
-				UiDrawRoundRect(g, rect, kCorner * m_scale, active ? m_theme->accent : m_theme->border, 1.0f);
-				UiText(g, DrawModeName(kModeOptions[index]), m_fonts->uiSmall, rect,
-				       active ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
-			}
-		}
-
-		// ---- 第三行：调整（系数 / 镜像 / 绝对值，三个切换类按钮）----
-		// 结算顺序固定为「系数 → 绝对值 → 镜像」；「系数」「镜像」点击后展开二级面板。
-		{
-			paintRowLabel(2, L"调整");
-
-			const auto paintToggle = [&](int index, const wchar_t* label, bool checked, StyleHit target)
-			{
-				const gd::RectF& rect = m_adjustRects[static_cast<std::size_t>(index)];
-				const bool hot = (m_hoverStyle == target);
-				UiFillRoundRect(g, rect, kCorner * m_scale,
-				                checked ? m_theme->accentSoft : (hot ? m_theme->hover : m_theme->cardBg));
-				UiDrawRoundRect(g, rect, kCorner * m_scale,
-				                checked ? m_theme->accent : m_theme->border, 1.0f);
-				UiText(g, label, m_fonts->uiSmall, rect,
-				       checked ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
-			};
-			// 系数/偏移：系数不等于默认值 1、或任一偏移不为 0 时显示为"已启用"。
-			paintToggle(kAdjustGain, L"系数/偏移",
-			            !GainIsDefault(style->gain) || style->Offset(), StyleHit::GAIN_ADJUST);
-			// 镜像：水平或垂直任一被勾选即显示为激活态。
-			paintToggle(kAdjustMirror, L"镜像", style->Mirrored(), StyleHit::MIRROR_ADJUST);
-			paintToggle(kAdjustAbsolute, L"绝对值", style->absolute, StyleHit::ABSOLUTE_TOGGLE);
-		}
-
-		// ---- 第四行：线宽（数值可点击输入）----
-		{
-			paintRowLabel(3, L"线宽");
-
-			const double ratio =
-			    (static_cast<double>(style->lineWidth) - kWidthMin) / (kWidthMax - kWidthMin);
-			const bool active = m_draggingWidth || (m_hoverStyle == StyleHit::WIDTH_SLIDER);
-			UiDrawSlider(g, m_widthTrackRect, ratio, m_theme->accent, active, m_scale);
-
-			if (m_editField == StyleEditField::WIDTH)
-			{
-				UiDrawEditField(g, m_widthValueRect, m_edit, m_fonts->monoSmall, m_scale);
-			}
-			else
-			{
-				const std::wstring numberText = FormatNumber(style->lineWidth, 1);
-				const std::wstring fullText = numberText + L" px";
-				// 空间不足时省略单位，保证数值本身完整可读。
-				const std::wstring shown =
-				    (UiMeasureTextWidth(m_fonts->monoSmall, fullText) >
-				     m_widthValueRect.Width - 6.0f * m_scale)
-				        ? numberText
-				        : fullText;
-				UiText(g, shown, m_fonts->monoSmall, m_widthValueRect, m_theme->textStrong, TextAlign::RIGHT);
-			}
-		}
-
-		// ---- 第五行：透明度（数值可点击输入）----
-		{
-			paintRowLabel(4, L"透明度");
-
-			const bool active = m_draggingOpacity || (m_hoverStyle == StyleHit::OPACITY_SLIDER);
-			UiDrawSlider(g, m_opacityTrackRect, static_cast<double>(style->opacity), m_theme->accent, active,
-			             m_scale);
-
-			if (m_editField == StyleEditField::OPACITY)
-			{
-				UiDrawEditField(g, m_opacityValueRect, m_edit, m_fonts->monoSmall, m_scale);
-			}
-			else
-			{
-				const int percent = static_cast<int>(style->opacity * 100.0f + 0.5f);
-				UiText(g, std::to_wstring(percent) + L"%", m_fonts->monoSmall, m_opacityValueRect,
-				       m_theme->textStrong, TextAlign::RIGHT);
-			}
-		}
-	}
-
-	void SignalPanel::PaintTargetRow(gd::Graphics& g)
-	{
-		if (m_fonts == nullptr || m_theme == nullptr || m_targetRowRect.Width <= 0.0f)
-		{
-			return;
-		}
-		UpdateTargetRowGeometry();
-
-		const float labelWidth = kStyleLabelWidth * m_scale;
-		// 行标签与前五行一致（同一标签列宽度、同一纵向居中基准）。
-		UiText(g, L"目标", m_fonts->uiSmall,
-		       gd::RectF(m_targetRowRect.X, m_targetRowRect.Y, labelWidth, m_targetRowRect.Height),
-		       m_theme->textMuted, TextAlign::LEFT);
-
-		const SignalRef& target = SelectedRef();
-		const SignalData* signal =
-		    (m_dataSet != nullptr && target.IsValid()) ? m_dataSet->Resolve(target) : nullptr;
-
-		// 没有可编辑的目标信号：只显示占位提示（与样式区其余行的"请选择信号"提示一致）。
-		if (signal == nullptr)
-		{
-			const float contentLeft = m_targetRowRect.X + labelWidth + kStyleLabelGap * m_scale;
-			UiText(g, L"未选择信号", m_fonts->uiSmall,
-			       gd::RectF(contentLeft, m_targetRowRect.Y,
-			                 std::max(0.0f, m_targetRowRect.X + m_targetRowRect.Width - contentLeft),
-			                 m_targetRowRect.Height),
-			       m_theme->textMuted, TextAlign::LEFT);
-			return;
-		}
-
-		// 名称：悬停时给一层与信号列表行一致的背景高亮（用户要求"显示与交互效果相同"）。
-		if (m_hoverStyle == StyleHit::TARGET_NAME && m_targetNameRect.Width > 0.0f)
-		{
-			UiFillRoundRect(g, m_targetNameRect, kCorner * m_scale, m_theme->hover);
-		}
-
-		if (m_editField == StyleEditField::SIGNAL_NAME && m_editRow < 0)
-		{
-			UiDrawEditField(g, EditFieldRect(), m_edit, m_fonts->ui, m_scale);
-		}
-		else
-		{
-			// 颜色与信号列表行一致：已绘制到网格用常态色，未绘制用弱色。
-			const std::uint32_t nameColor = (m_targetGeomLane >= 0) ? m_theme->text : m_theme->textMuted;
-			// ⚠️ 这里**不能**用 `PaintRowText`（它把文本裁到 `m_listRect`，而「目标」行在样式区、
-			//    列表矩形之外 ⇒ 文本会被完全裁掉，用户报告“信号名与 GX 标签都没正确绘制”）。
-			UiText(g, UiEllipsize(signal->name, m_fonts->ui, m_targetNameRect.Width), m_fonts->ui,
-			       m_targetNameRect, nameColor, TextAlign::LEFT);
-		}
-
-		// GX 网格标签：信号已绘制到某个网格时显示在名称**后方**（用户 2026-10-15 要求），
-		// 并与其它控件一样**右对齐到内容列右边缘**。
-		if (m_targetBadgeRect.Width > 0.0f)
-		{
-			const bool badgeHot = (m_hoverStyle == StyleHit::TARGET_BADGE);
-			UiFillRoundRect(g, m_targetBadgeRect, kBadgeHeight * m_scale * 0.5f,
-			                badgeHot ? m_theme->accentSoft : m_theme->cardBg);
-			UiDrawRoundRect(g, m_targetBadgeRect, kBadgeHeight * m_scale * 0.5f,
-			                badgeHot ? m_theme->accent : m_theme->border, 1.0f);
-			UiText(g, L"G" + std::to_wstring(m_targetGeomLane + 1), m_fonts->monoSmall,
-			       m_targetBadgeRect, badgeHot ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
-		}
-	}
-
 	bool SignalPanel::SignalScrollTarget(const SignalRef& ref, float& desired) const
 	{
 		desired = m_scrollOffset;
@@ -2252,49 +985,6 @@ namespace jdi
 		return true;
 	}
 
-	void SignalPanel::ScrollToSignalAnimated(const SignalRef& ref)
-	{
-		EnsureRows();
-		float desired = m_scrollOffset;
-		if (!SignalScrollTarget(ref, desired))
-		{
-			return;
-		}
-		// 把列表平滑滚动到目标信号完整可见。
-		StartScrollAnimationTo(desired);
-	}
-
-	bool SignalPanel::AdvanceScrollAnimation()
-	{
-		if (!m_scrollAnimActive)
-		{
-			return false;
-		}
-
-		const std::uint64_t now = GetTickCount64();
-		const std::uint64_t elapsed = (now >= m_scrollAnimStartMs) ? (now - m_scrollAnimStartMs) : 0;
-		float progress = (m_scrollAnimDurationMs > 0u)
-		                     ? static_cast<float>(elapsed) / static_cast<float>(m_scrollAnimDurationMs)
-		                     : 1.0f;
-		if (progress > 1.0f)
-		{
-			progress = 1.0f;
-		}
-
-		// ease-out cubic：起步快、靠近目标时变慢（用户要求"越远时越快，靠近时变慢"）。
-		const float eased = 1.0f - std::pow(1.0f - progress, 3.0f);
-		m_scrollOffset = m_scrollAnimFrom + (m_scrollAnimTo - m_scrollAnimFrom) * eased;
-
-		if (progress >= 1.0f)
-		{
-			m_scrollOffset = m_scrollAnimTo;
-			m_scrollAnimActive = false;
-			ClampScroll();
-			return false;
-		}
-		return true;
-	}
-
 	bool SignalPanel::AreAllSignalsVisible() const
 	{
 		if (m_dataSet == nullptr || m_tab == nullptr || m_dataSet->Empty())
@@ -2304,30 +994,6 @@ namespace jdi
 		return m_tab->VisibleCount() == TotalSignalCount();
 	}
 
-	bool SignalPanel::ApplyWidthFromX(float x)
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		SignalStyle* style = StyleOf(SelectedRef());
-		if (style == nullptr)
-		{
-			return false;
-		}
-
-		const double ratio = UiSliderRatioFromX(m_widthTrackRect, x);
-		float value = static_cast<float>(kWidthMin + ratio * (kWidthMax - kWidthMin));
-		value = std::round(value * 10.0f) / 10.0f;
-		value = ClampFloat(value, kWidthMin, kWidthMax);
-		if (std::fabs(value - style->lineWidth) < 0.001f)
-		{
-			return false;
-		}
-		style->lineWidth = value;
-		return true;
-	}
-
 	gd::RectF SignalPanel::RowNameRect(int row) const
 	{
 		if (m_dataSet == nullptr || m_tab == nullptr || row < 0 || row >= static_cast<int>(m_rows.size()))
@@ -2397,202 +1063,6 @@ namespace jdi
 		return std::to_wstring(m_rows[static_cast<std::size_t>(row)].displayCount) + L" 项";
 	}
 
-	bool SignalPanel::BeginEdit(StyleEditField field, int row)
-	{
-		if (m_tab == nullptr || field == StyleEditField::NONE)
-		{
-			return false;
-		}
-		if (m_editField == field && m_editRow == row)
-		{
-			return false;
-		}
-
-		std::wstring initial;
-		switch (field)
-		{
-		case StyleEditField::WIDTH:
-		{
-			const SignalStyle* style = StyleOf(SelectedRef());
-			if (style == nullptr)
-			{
-				return false;
-			}
-			initial = FormatNumber(style->lineWidth, 1);
-			break;
-		}
-		case StyleEditField::OPACITY:
-		{
-			const SignalStyle* style = StyleOf(SelectedRef());
-			if (style == nullptr)
-			{
-				return false;
-			}
-			initial = std::to_wstring(static_cast<int>(style->opacity * 100.0f + 0.5f));
-			break;
-		}
-		case StyleEditField::SIGNAL_NAME:
-		{
-			// `row < 0`：样式区顶部「目标」行 —— 编辑对象就是当前选中的（目标）信号。
-			if (row < 0)
-			{
-				const SignalData* signal = SelectedRef().IsValid() ? m_dataSet->Resolve(SelectedRef()) : nullptr;
-				if (signal == nullptr)
-				{
-					return false;
-				}
-				initial = signal->name;
-				break;
-			}
-			if (row >= static_cast<int>(m_rows.size()))
-			{
-				return false;
-			}
-			const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-			const SignalData* signal = m_dataSet->Resolve(SignalRef{item.groupIndex, item.signalIndex});
-			if (signal == nullptr)
-			{
-				return false;
-			}
-			initial = signal->name;
-			break;
-		}
-		case StyleEditField::GROUP_TITLE:
-		{
-			if (row < 0 || row >= static_cast<int>(m_rows.size()))
-			{
-				return false;
-			}
-			const SignalGroup* group = m_dataSet->GroupAt(m_rows[static_cast<std::size_t>(row)].groupIndex);
-			if (group == nullptr)
-			{
-				return false;
-			}
-			initial = group->name;
-			break;
-		}
-		default:
-			return false;
-		}
-
-		m_editField = field;
-		m_editRow = row;
-
-		if (field == StyleEditField::SIGNAL_NAME && row < 0)
-		{
-			// 「目标」行的输入框与行内名称矩形同源，必须先按当前目标算好几何。
-			UpdateTargetRowGeometry();
-		}
-
-		// 名称类字段可输入任意字符，数值类字段限制为数字与小数点。
-		const bool nameField =
-		    (field == StyleEditField::SIGNAL_NAME) || (field == StyleEditField::GROUP_TITLE);
-		// 不限长度：名称与数值都由各自的提交逻辑处理超长内容。
-		m_edit.Begin(std::move(initial), true, nameField ? EditFilter::ANY : EditFilter::NUMBER, 0u);
-		return true;
-	}
-
-	bool SignalPanel::EndEdit(bool commit)
-	{
-		if (m_editField == StyleEditField::NONE)
-		{
-			return false;
-		}
-
-		const StyleEditField field = m_editField;
-		const int row = m_editRow;
-		const std::wstring text = m_edit.Text();
-
-		m_editField = StyleEditField::NONE;
-		m_editRow = -1;
-		m_edit.End();
-
-		if (!commit || m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return true;
-		}
-
-		const std::wstring trimmed = Trim(text);
-		switch (field)
-		{
-		case StyleEditField::WIDTH:
-		{
-			if (trimmed.empty())
-			{
-				break;
-			}
-			wchar_t* stop = nullptr;
-			const double parsed = std::wcstod(trimmed.c_str(), &stop);
-			if (stop == trimmed.c_str() || parsed != parsed)
-			{
-				break;
-			}
-			if (SignalStyle* style = StyleOf(SelectedRef()))
-			{
-				const float value = ClampFloat(static_cast<float>(parsed), kWidthMin, kWidthMax);
-				style->lineWidth = std::round(value * 10.0f) / 10.0f;
-			}
-			break;
-		}
-		case StyleEditField::OPACITY:
-		{
-			if (trimmed.empty())
-			{
-				break;
-			}
-			wchar_t* stop = nullptr;
-			const double parsed = std::wcstod(trimmed.c_str(), &stop);
-			if (stop == trimmed.c_str() || parsed != parsed)
-			{
-				break;
-			}
-			if (SignalStyle* style = StyleOf(SelectedRef()))
-			{
-				style->opacity = ClampFloat(static_cast<float>(parsed) / 100.0f, 0.0f, 1.0f);
-			}
-			break;
-		}
-		case StyleEditField::SIGNAL_NAME:
-		{
-			if (m_dataSetWritable == nullptr)
-			{
-				break;
-			}
-			if (row < 0)
-			{
-				// 样式区「目标」行：重命名当前选中的（目标）信号。
-				const SignalRef& target = SelectedRef();
-				if (target.IsValid())
-				{
-					m_dataSetWritable->RenameSignal(target.groupIndex, target.signalIndex, trimmed);
-				}
-				// 名称变化会改变「目标」行的文本宽度 ⇒ 几何缓存作废。
-				m_targetGeomValid = false;
-				break;
-			}
-			if (row >= static_cast<int>(m_rows.size()))
-			{
-				break;
-			}
-			const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-			m_dataSetWritable->RenameSignal(item.groupIndex, item.signalIndex, trimmed);
-			break;
-		}
-		case StyleEditField::GROUP_TITLE:
-		{
-			if (row < 0 || row >= static_cast<int>(m_rows.size()) || m_dataSetWritable == nullptr)
-			{
-				break;
-			}
-			m_dataSetWritable->RenameGroup(m_rows[static_cast<std::size_t>(row)].groupIndex, trimmed);
-			break;
-		}
-		default:
-			break;
-		}
-		return true;
-	}
-
 	gd::RectF SignalPanel::FilterFieldRect() const
 	{
 		// 输入框内容区：左右与上下使用**同一内缩**，避免编辑态出现"左右空隙明显更大"的观感；
@@ -2638,264 +1108,6 @@ namespace jdi
 		}
 	}
 
-	bool SignalPanel::OnEditChar(wchar_t character)
-	{
-		// 「筛选信号」输入框：字符实时进入筛选（无需回车即可看到结果变化）。
-		if (m_filterEditing)
-		{
-			switch (character)
-			{
-			case 0x03: // Ctrl+C
-				m_filterEdit.CopyToClipboard(m_host);
-				return false;
-			case 0x18: // Ctrl+X
-				m_filterEdit.CutToClipboard(m_host);
-				ApplyFilterText(m_filterEdit.Text());
-				return true;
-			case 0x16: // Ctrl+V
-				m_filterEdit.PasteFromClipboard(m_host);
-				ApplyFilterText(m_filterEdit.Text());
-				return true;
-			case 0x01: // Ctrl+A
-				m_filterEdit.SelectAll();
-				return true;
-			default:
-				break;
-			}
-			if (character == L'\r' || character == L'\n')
-			{
-				return EndFilterEdit();
-			}
-			// 退格/删除已由 WM_KEYDOWN 的 OnEditKey 处理，运里忽略控制字符避免重复删除。
-			if (character < 0x20 || character == 0x7F)
-			{
-				return false;
-			}
-			if (!m_filterEdit.Insert(character))
-			{
-				return false;
-			}
-			ApplyFilterText(m_filterEdit.Text());
-			return true;
-		}
-
-		if (m_editField == StyleEditField::NONE)
-		{
-			return false;
-		}
-
-		// 剪贴板与全选快捷键经 WM_CHAR 送达（Ctrl+C/X/V/A 分别对应 3/24/22/1）。
-		switch (character)
-		{
-		case 0x03: // Ctrl+C
-			m_edit.CopyToClipboard(m_host);
-			return false;
-		case 0x18: // Ctrl+X
-			return m_edit.CutToClipboard(m_host);
-		case 0x16: // Ctrl+V
-			return m_edit.PasteFromClipboard(m_host);
-		case 0x01: // Ctrl+A
-			m_edit.SelectAll();
-			return true;
-		default:
-			break;
-		}
-
-		if (character == L'\r' || character == L'\n')
-		{
-			return EndEdit(true);
-		}
-		// 退格/删除已由 WM_KEYDOWN 的 OnEditKey 处理：这里必须忽略控制字符，
-		// 否则同一次按键会被处理两次（一次删除两个字符）。
-		if (character < 0x20 || character == 0x7F)
-		{
-			return false;
-		}
-		// 百分比字段允许直接输入 % 但会被忽略，其余控制字符一律丢弃。
-		if (m_editField == StyleEditField::OPACITY && character == L'%')
-		{
-			return false;
-		}
-		return m_edit.Insert(character);
-	}
-
-	bool SignalPanel::OnEditKey(WPARAM key)
-	{
-		// 「筛选信号」输入框的键盘处理（回车结束编辑，Esc 清空并结束）。
-		if (m_filterEditing)
-		{
-			const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
-			const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
-			switch (key)
-			{
-			case VK_RETURN:
-				return EndFilterEdit();
-			case VK_ESCAPE:
-			{
-				const bool changed = m_filterEdit.Text() != m_filterText;
-				EndFilterEdit();
-				return changed;
-			}
-			case VK_BACK:
-			{
-				if (!m_filterEdit.Backspace())
-				{
-					return false;
-				}
-				ApplyFilterText(m_filterEdit.Text());
-				return true;
-			}
-			case VK_DELETE:
-			{
-				if (!m_filterEdit.DeleteForward())
-				{
-					return false;
-				}
-				ApplyFilterText(m_filterEdit.Text());
-				return true;
-			}
-			case VK_LEFT:
-				return m_filterEdit.MoveCaret(-1, shift);
-			case VK_RIGHT:
-				return m_filterEdit.MoveCaret(1, shift);
-			case VK_HOME:
-				return m_filterEdit.MoveHome(shift);
-			case VK_END:
-				return m_filterEdit.MoveEnd(shift);
-			case 'A':
-				if (control)
-				{
-					m_filterEdit.SelectAll();
-					return true;
-				}
-				break;
-			default:
-				break;
-			}
-			return true;
-		}
-
-		if (m_editField == StyleEditField::NONE)
-		{
-			return false;
-		}
-
-		const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
-		const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
-
-		switch (key)
-		{
-		case VK_RETURN:
-			return EndEdit(true);
-		case VK_ESCAPE:
-			return EndEdit(false);
-		case VK_BACK:
-			return m_edit.Backspace();
-		case VK_DELETE:
-			return m_edit.DeleteForward();
-		case VK_LEFT:
-			return m_edit.MoveCaret(-1, shift);
-		case VK_RIGHT:
-			return m_edit.MoveCaret(1, shift);
-		case VK_HOME:
-			return m_edit.MoveHome(shift);
-		case VK_END:
-			return m_edit.MoveEnd(shift);
-		case 'A':
-			if (control)
-			{
-				m_edit.SelectAll();
-				return true;
-			}
-			break;
-		default:
-			break;
-		}
-		return true;
-	}
-
-	bool SignalPanel::CollapseEditSelectionToEnd()
-	{
-		if (m_filterEditing)
-		{
-			return m_filterEdit.DeselectToEnd();
-		}
-		if (m_editField == StyleEditField::NONE)
-		{
-			return false;
-		}
-		return m_edit.DeselectToEnd();
-	}
-
-	bool SignalPanel::OnEditMouseDown(int x, int y)
-	{
-		if (m_filterEditing)
-		{
-			// 编辑态下 ✕ 位于输入框内容区之内，必须优先于插入符定位处理，
-			// 否则点击会被当成"把光标移到此处"而清空不了内容。
-			// 与其它 ✕ 一致：按下只记录目标，抬起时仍在 ✕ 上才真正清空。
-			const gd::RectF clearRect = FilterClearRect();
-			if (clearRect.Width > 0.0f &&
-			    UiPointInRect(clearRect, static_cast<float>(x), static_cast<float>(y)))
-			{
-				m_pendingFilterClear = true;
-				return true;
-			}
-			return UiEditFieldMouseDown(m_fonts->uiSmall, FilterFieldRect(), m_filterEdit, m_scale, x, y);
-		}
-		if (m_editField == StyleEditField::NONE)
-		{
-			return false;
-		}
-		return UiEditFieldMouseDown(m_fonts->ui, EditFieldRect(), m_edit, m_scale, x, y);
-	}
-
-	bool SignalPanel::OnEditMouseMove(int x)
-	{
-		if (m_filterEditing)
-		{
-			return UiEditFieldMouseMove(m_fonts->uiSmall, FilterFieldRect(), m_filterEdit, m_scale, x);
-		}
-		if (m_editField == StyleEditField::NONE)
-		{
-			return false;
-		}
-		return UiEditFieldMouseMove(m_fonts->ui, EditFieldRect(), m_edit, m_scale, x);
-	}
-
-	bool SignalPanel::OnEditMouseUp(int x, int y)
-	{
-		if (m_filterEditing)
-		{
-			// 筛选框右端的清空 ✕ 在编辑态下的**按下**走 OnEditMouseDown（优先于插入符定位），
-			// 抬起同样由宿主送进 EDIT_FIELD 分支，因此确认逻辑要在这里结算：
-			// 只有抬起时指针仍在 ✕ 上才真正清空，移开后松开视为放弃。
-			if (m_pendingFilterClear)
-			{
-				m_pendingFilterClear = false;
-				const gd::RectF clearRect = FilterClearRect();
-				if (clearRect.Width > 0.0f &&
-				    UiPointInRect(clearRect, static_cast<float>(x), static_cast<float>(y)))
-				{
-					ClearFilter();
-					return true;
-				}
-			}
-			if (!m_filterEdit.Dragging())
-			{
-				return false;
-			}
-			m_filterEdit.EndDrag();
-			return true;
-		}
-		if (!m_edit.Dragging())
-		{
-			return false;
-		}
-		m_edit.EndDrag();
-		return true;
-	}
-
 	const SignalStyle* SignalPanel::StyleOf(const SignalRef& ref) const
 	{
 		return (m_dataSet != nullptr) ? m_dataSet->Style(ref) : nullptr;
@@ -2912,54 +1124,6 @@ namespace jdi
 		return (m_dataSet != nullptr) ? m_dataSet->Selected() : fallback;
 	}
 
-	void SignalPanel::SelectSignal(const SignalRef& ref)
-	{
-		if (m_dataSetWritable != nullptr)
-		{
-			m_dataSetWritable->SetSelected(ref);
-		}
-	}
-
-	bool SignalPanel::ApplyColor(std::uint32_t color)
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		SignalStyle* style = StyleOf(SelectedRef());
-		if (style == nullptr)
-		{
-			return false;
-		}
-
-		// 同时记住最后一次自定义取值，便于切换到预设色后一键回到该颜色。
-		const bool changed = (style->color != color) || (style->customColor != color);
-		style->color = color;
-		style->customColor = color;
-		return changed;
-	}
-
-	bool SignalPanel::ApplyOpacityFromX(float x)
-	{
-		if (m_tab == nullptr)
-		{
-			return false;
-		}
-		SignalStyle* style = StyleOf(SelectedRef());
-		if (style == nullptr)
-		{
-			return false;
-		}
-
-		const float value = static_cast<float>(UiSliderRatioFromX(m_opacityTrackRect, x));
-		if (std::fabs(value - style->opacity) < 0.005f)
-		{
-			return false;
-		}
-		style->opacity = value;
-		return true;
-	}
-
 	bool SignalPanel::OpenColorPickerPopup(const SignalStyle& style)
 	{
 		if (m_colorPicker == nullptr)
@@ -2973,1212 +1137,6 @@ namespace jdi
 		return true;
 	}
 
-	bool SignalPanel::OpenGainMenu()
-	{
-		if (m_menu == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-		const SignalStyle* style = StyleOf(SelectedRef());
-		if (style == nullptr)
-		{
-			return false;
-		}
-
-		// 二级面板：两张“标题（带还原图标）+ 输入框”的组合：
-		//   1. 「系数调整」：一整行系数输入框；
-		//   2. 「偏移调整」：下方两行分别为「Y轴」与「时间轴」的偏移输入框。
-		//（与网格 Y 轴上下限的菜单内联编辑同一套做法：提交后面板保持打开，可连续微调。）
-		std::vector<MenuItem> items;
-
-		MenuItem gainHeader;
-		gainHeader.kind = MenuItemKind::HEADER_ACTION;
-		gainHeader.label = L"系数调整";
-		gainHeader.id = CMD_GAIN_RESET;	// 点击标题栏右侧的还原图标 → 系数重置为 1
-		items.push_back(gainHeader);
-
-		// 非编辑态带正号（用户明确要求）；进入编辑后的初始文本用不带符号的纯数值。
-		const std::wstring gainText = FormatGainText(style->gain);
-		const std::wstring gainEditText = FormatNumberText(static_cast<double>(style->gain));
-		MenuItem gainEdit;
-		gainEdit.kind = MenuItemKind::EDIT;
-		gainEdit.label.clear();		// 不显示说明文字：输入框独占整行
-		gainEdit.id = CMD_GAIN_EDIT;
-		gainEdit.value = gainText;
-		gainEdit.editValue = gainEditText;
-		gainEdit.filter = EditFilter::NUMBER;
-		items.push_back(gainEdit);
-
-		MenuItem offsetHeader;
-		offsetHeader.kind = MenuItemKind::HEADER_ACTION;
-		offsetHeader.label = L"偏移调整";
-		offsetHeader.id = CMD_OFFSET_RESET;	// 点击还原图标 → 两个偏移都恢复默认值
-		items.push_back(offsetHeader);
-
-		// 「Y轴」：对绘制值加上一个常数偏移（波形上下移动），非编辑态带正负号。
-		MenuItem offsetY;
-		offsetY.kind = MenuItemKind::EDIT;
-		offsetY.label = L"Y轴";
-		offsetY.id = CMD_OFFSET_Y;
-		offsetY.value = FormatSignedNumber(static_cast<double>(style->offsetY));
-		offsetY.editValue = FormatNumberText(static_cast<double>(style->offsetY));
-		offsetY.filter = EditFilter::NUMBER;
-		items.push_back(offsetY);
-
-		// 「时间轴」：把采样沿时间轴平移（画在 t + offsetTime）。
-		// 非编辑态显示与双光标差值同一套复合单位文本，并**带正负号**（用户明确要求）；
-		// 编辑态显示以秒为单位的数值，并在输入框最右侧提示单位 `s`。
-		MenuItem offsetTime;
-		offsetTime.kind = MenuItemKind::EDIT;
-		offsetTime.label = L"时间轴";
-		offsetTime.id = CMD_OFFSET_TIME;
-		offsetTime.value = FormatOffsetTimeText(style->offsetTime);
-		offsetTime.editValue = FormatNumberText(style->offsetTime);
-		offsetTime.editSuffix = L"s";
-		offsetTime.filter = EditFilter::NUMBER;
-		items.push_back(offsetTime);
-
-		// 锚定在按钮**左上角的上方一点**：二级面板**向上展开**，其左下角对准按钮左上角，
-		// 并再往上让出 `kAdjustMenuGap`（用户明确要求）。
-		//（旧实现在按钮下沿向右下展开，面板会盖住下方内容。）
-		const gd::RectF& button = m_adjustRects[kAdjustGain];
-		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
-		const int anchorY =
-		    static_cast<int>(std::lround(button.Y - kAdjustMenuGap * m_scale));
-		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, static_cast<int>(button.X), anchorY, items,
-		             true);
-		// ⚠️ 菜单一旦打开就会接管鼠标事件，样式区不会再收到 WM_MOUSEMOVE →
-		// 必须在这里主动清掉按钮的悬停态，否则按钮会"像鼠标一直按着"一样持续高亮。
-		ClearStyleHover();
-		return true;
-	}
-
-	bool SignalPanel::OpenMirrorMenu()
-	{
-		if (m_menu == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-		const SignalStyle* style = StyleOf(SelectedRef());
-		if (style == nullptr)
-		{
-			return false;
-		}
-
-		// 两行带复选框的选项：点击即切换、且**保持菜单打开**（可连续勾选两项）。
-		std::vector<MenuItem> items;
-
-		MenuItem horizontal;
-		horizontal.kind = MenuItemKind::NORMAL;
-		horizontal.label = L"水平镜像";
-		horizontal.id = CMD_MIRROR_HORIZONTAL;
-		horizontal.checked = style->mirrorHorizontal;
-		horizontal.keepOpen = true;
-		items.push_back(horizontal);
-
-		MenuItem vertical;
-		vertical.kind = MenuItemKind::NORMAL;
-		vertical.label = L"垂直镜像";
-		vertical.id = CMD_MIRROR_VERTICAL;
-		vertical.checked = style->mirrorVertical;
-		vertical.keepOpen = true;
-		items.push_back(vertical);
-
-		const gd::RectF& button = m_adjustRects[kAdjustMirror];
-		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
-		// 与「系数/偏移」面板同一套锛定：向上展开，左下角 = 按钮左上角再上移一点。
-		const int anchorY =
-		    static_cast<int>(std::lround(button.Y - kAdjustMenuGap * m_scale));
-		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, static_cast<int>(button.X), anchorY, items,
-		             true);
-		ClearStyleHover();
-		return true;
-	}
-
-	void SignalPanel::ClearStyleHover()
-	{
-		if (m_hoverStyle == StyleHit::NONE && m_hoverStyleIndex < 0)
-		{
-			return;
-		}
-		m_hoverStyle = StyleHit::NONE;
-		m_hoverStyleIndex = -1;
-	}
-
-	bool SignalPanel::CloseTransientUi()
-	{
-		bool changed = false;
-		if (m_editField != StyleEditField::NONE)
-		{
-			changed = EndEdit(true) || changed;
-		}
-		// 点击面板之外也要结束「筛选信号」的编辑状态。
-		if (m_filterEditing)
-		{
-			changed = EndFilterEdit() || changed;
-		}
-		if (m_colorPicker != nullptr && m_colorPicker->IsOpen())
-		{
-			m_colorPicker->Close();
-			changed = true;
-		}
-		// 面板外点击：取消尚未抬起确认的关闭操作。
-		m_pendingClosePart = RowPart::NONE;
-		m_pendingCloseRow = -1;
-		m_pendingFilterClear = false;
-		m_pendingGainMenu = false;
-		m_pendingMirrorMenu = false;
-		return changed;
-	}
-
-	bool SignalPanel::OnMouseMove(int x, int y)
-	{
-		// 拖拽优先级最高。
-		if (m_draggingOpacity)
-		{
-			return ApplyOpacityFromX(static_cast<float>(x));
-		}
-		if (m_draggingWidth)
-		{
-			return ApplyWidthFromX(static_cast<float>(x));
-		}
-		if (m_draggingScrollBar)
-		{
-			const gd::RectF thumb = ScrollThumbRect();
-			// ⚠️ 拖拽期间滑块高度不会变（内容高度与列表高度都没变），因此 `thumb.Height` 可安全
-			// 用于本次换算；但 `m_scrollBarRect.Y` 必须取**按下时**记录的值（局部刷新/重排可能
-			// 改掉它）。坐标一律用**客户区** y，因此鼠标移到面板外（如绘图区）也能继续跟随。
-			const float travel = static_cast<float>(y - m_scrollGrabOffset) - m_scrollBarRect.Y;
-			const float usable = m_scrollBarRect.Height - thumb.Height;
-			if (usable > 0.0f)
-			{
-				const float progress = std::max(0.0f, std::min(1.0f, travel / usable));
-				m_scrollOffset = progress * (m_contentHeight - m_listRect.Height);
-				ClampScroll();
-			}
-			return true;
-		}
-
-		RowPart part = RowPart::NONE;
-		const int hoverRow = HitRow(x, y, part);
-
-		StyleHit hoverStyle = StyleHit::NONE;
-		int hoverStyleIndex = -1;
-
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-
-		if (UiPointInRect(m_toggleAllRect, fx, fy))
-		{
-			hoverStyle = StyleHit::TOGGLE_ALL;
-		}
-		else if (UiPointInRect(FilterClearRect(), fx, fy))
-		{
-			// 筛选框右侧的清空 ✕（仅在筛选框有内容时存在）。
-			hoverStyle = StyleHit::FILTER_CLEAR;
-		}
-		else if (m_tab != nullptr && StyleOf(SelectedRef()) != nullptr)
-		{
-			// 「目标」行的信号名 / GX 标签（优先于其余样式控件：它们几何不重叠，
-			// 但显式放在最前更易读）。
-			UpdateTargetRowGeometry();
-			if (UiPointInRect(m_targetRowRect, fx, fy))
-			{
-				if (m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy))
-				{
-					hoverStyle = StyleHit::TARGET_BADGE;
-				}
-				else if (m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy))
-				{
-					hoverStyle = StyleHit::TARGET_NAME;
-				}
-			}
-			for (int index = 0; hoverStyle == StyleHit::NONE && index < m_colorCount; ++index)
-			{
-				if (UiPointInRect(m_colorRects[static_cast<std::size_t>(index)], fx, fy))
-				{
-					hoverStyle = StyleHit::COLOR;
-					hoverStyleIndex = index;
-					break;
-				}
-			}
-			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_customChipRect, fx, fy))
-			{
-				hoverStyle = StyleHit::CUSTOM_CHIP;
-			}
-			if (hoverStyle == StyleHit::NONE)
-			{
-				for (int index = 0; index < kModeOptionCount; ++index)
-				{
-					if (UiPointInRect(m_modeRects[static_cast<std::size_t>(index)], fx, fy))
-					{
-						hoverStyle = StyleHit::MODE;
-						hoverStyleIndex = index;
-						break;
-					}
-				}
-			}
-			if (hoverStyle == StyleHit::NONE &&
-			    UiPointInRect(SliderHitRect(m_opacityTrackRect, m_scale), fx, fy))
-			{
-				hoverStyle = StyleHit::OPACITY_SLIDER;
-			}
-			if (hoverStyle == StyleHit::NONE &&
-			    UiPointInRect(SliderHitRect(m_widthTrackRect, m_scale), fx, fy))
-			{
-				hoverStyle = StyleHit::WIDTH_SLIDER;
-			}
-			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_opacityValueRect, fx, fy))
-			{
-				hoverStyle = StyleHit::OPACITY_VALUE;
-			}
-			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_widthValueRect, fx, fy))
-			{
-				hoverStyle = StyleHit::WIDTH_VALUE;
-			}
-			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_adjustRects[kAdjustGain], fx, fy))
-			{
-				hoverStyle = StyleHit::GAIN_ADJUST;
-			}
-			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy))
-			{
-				hoverStyle = StyleHit::MIRROR_ADJUST;
-			}
-			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_adjustRects[kAdjustAbsolute], fx, fy))
-			{
-				hoverStyle = StyleHit::ABSOLUTE_TOGGLE;
-			}
-		}
-
-		if (hoverRow == m_hoverRow && hoverStyle == m_hoverStyle && hoverStyleIndex == m_hoverStyleIndex &&
-		    part == m_hoverPart)
-		{
-			return false;
-		}
-
-		m_hoverRow = hoverRow;
-		m_hoverPart = part;
-		m_hoverStyle = hoverStyle;
-		m_hoverStyleIndex = hoverStyleIndex;
-
-		// 供绘图区联动高亮的悬停信号（用户 2026-10-15 要求）：
-		//  * 列表里悬停某条信号行 → 高亮它所在的网格 + 该信号的曲线；
-		//  * 样式区「目标」行的信号名 / GX 标签上悬停 → 同样联动高亮。
-		// ⚠️ ✕（移除该信号）不算"悬停到该信号"：它是一条即将被删除的信号，
-		//    高亮它会让人误以为要保留它。
-		SignalRef hovered;
-		if (hoverRow >= 0 && hoverRow < static_cast<int>(m_rows.size()) &&
-		    m_rows[static_cast<std::size_t>(hoverRow)].kind == RowKind::SIGNAL &&
-		    part != RowPart::REMOVE_SIGNAL)
-		{
-			hovered = SignalRef{m_rows[static_cast<std::size_t>(hoverRow)].groupIndex,
-			                    m_rows[static_cast<std::size_t>(hoverRow)].signalIndex};
-		}
-		else if (hoverStyle == StyleHit::TARGET_NAME || hoverStyle == StyleHit::TARGET_BADGE)
-		{
-			hovered = SelectedRef();
-		}
-		m_hoveredSignal = hovered;
-		return true;
-	}
-
-	bool SignalPanel::OnLButtonDown(int x, int y)
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-
-		// 新的按下开始：上一轮留下的"待确认关闭"一律作废。
-		m_pendingClosePart = RowPart::NONE;
-		m_pendingCloseRow = -1;
-		m_pendingFilterClear = false;
-
-		// 「筛选信号」输入框：单击进入编辑；点击其它位置则先结束筛选编辑（文本已实时生效）。
-		if (IsOnFilterBox(x, y))
-		{
-			// 右侧 ✕：**抬起**时才清空（不退出编辑态，便于继续输入）；
-			// 按下后移开再松开视为放弃。
-			if (UiPointInRect(FilterClearRect(), fx, fy))
-			{
-				m_pendingFilterClear = true;
-				return true;
-			}
-			BeginFilterEdit();
-			return true;
-		}
-		if (m_filterEditing)
-		{
-			// 文本已实时生效，这里只需收起编辑态，随后继续处理本次点击。
-			EndFilterEdit();
-		}
-
-		// 滚动条拖拽优先于其它命中测试。
-		if (m_scrollBarVisible && UiPointInRect(m_scrollBarRect, fx, fy))
-		{
-			CancelScrollAnimation();
-			const gd::RectF thumb = ScrollThumbRect();
-			m_draggingScrollBar = true;
-			if (UiPointInRect(thumb, fx, fy))
-			{
-				m_scrollGrabOffset = y - static_cast<int>(thumb.Y);
-			}
-			else
-			{
-				m_scrollGrabOffset = static_cast<int>(thumb.Height * 0.5f);
-				const float travel = fy - m_scrollBarRect.Y - static_cast<float>(m_scrollGrabOffset);
-				const float usable = m_scrollBarRect.Height - thumb.Height;
-				if (usable > 0.0f)
-				{
-					const float progress = std::max(0.0f, std::min(1.0f, travel / usable));
-					m_scrollOffset = progress * (m_contentHeight - m_listRect.Height);
-					ClampScroll();
-				}
-			}
-			return true;
-		}
-
-		m_pendingLaneMenu = false;
-		m_pendingColorPicker = false;
-		m_pendingGainMenu = false;
-		m_pendingMirrorMenu = false;
-
-		// 点击当前输入框以外的位置时提交输入。
-		if (m_editField != StyleEditField::NONE &&
-		    !UiPointInRect(EditFieldRect(), fx, fy))
-		{
-			EndEdit(true);
-		}
-
-		// 全部显示/隐藏。
-		if (UiPointInRect(m_toggleAllRect, fx, fy))
-		{
-			m_tab->SetAllVisible(!AreAllSignalsVisible());
-			m_rowsDirty = true;
-			return true;
-		}
-
-		// 样式编辑区。
-		if (SignalStyle* style = StyleOf(SelectedRef()))
-		{
-			// ---- 顶层「目标」行：单击**不进入编辑**（用户明确要求），只做联动滚动 ----
-			// 双击改名由 `OnDoubleClick` 处理；这里单击即把列表滚动到目标信号，
-			// 便于在长列表（上百条信号的 MF4）里定位正在编辑的那条信号。
-			{
-				UpdateTargetRowGeometry();
-				const bool onName =
-				    m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy);
-				const bool onBadge =
-				    m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy);
-				if (onName || onBadge)
-				{
-					ScrollToSignalAnimated(SelectedRef());
-					return true;
-				}
-			}
-
-			int paletteCount = 0;
-			const std::uint32_t* palette = SignalPalette(paletteCount);
-			for (int index = 0; index < m_colorCount; ++index)
-			{
-				if (UiPointInRect(m_colorRects[static_cast<std::size_t>(index)], fx, fy))
-				{
-					style->color = palette[index % paletteCount];
-					// 联动：样式自定义区的任何交互都把列表滚动到正在编辑的目标信号。
-					ScrollToSignalAnimated(SelectedRef());
-					return true;
-				}
-			}
-			if (UiPointInRect(m_customChipRect, fx, fy))
-			{
-				// 先恢复到记忆的自定义颜色（即便随后收起浮窗也会生效），再在抬起时展开浮窗。
-				style->color = style->customColor;
-				m_pendingColorPicker = true;
-				ScrollToSignalAnimated(SelectedRef());
-				return true;
-			}
-			for (int index = 0; index < kModeOptionCount; ++index)
-			{
-				if (UiPointInRect(m_modeRects[static_cast<std::size_t>(index)], fx, fy))
-				{
-					style->mode = kModeOptions[index];
-					ScrollToSignalAnimated(SelectedRef());
-					return true;
-				}
-			}
-			if (UiPointInRect(SliderHitRect(m_opacityTrackRect, m_scale), fx, fy))
-			{
-				m_draggingOpacity = true;
-				ApplyOpacityFromX(fx);
-				ScrollToSignalAnimated(SelectedRef());
-				return true;
-			}
-			if (UiPointInRect(SliderHitRect(m_widthTrackRect, m_scale), fx, fy))
-			{
-				m_draggingWidth = true;
-				ApplyWidthFromX(fx);
-				ScrollToSignalAnimated(SelectedRef());
-				return true;
-			}
-			// 数值框的命中优先于滑块：两者几何重叠时要能进入输入状态。
-			if (UiPointInRect(m_widthValueRect, fx, fy))
-			{
-				ScrollToSignalAnimated(SelectedRef());
-				return BeginEdit(StyleEditField::WIDTH);
-			}
-			if (UiPointInRect(m_opacityValueRect, fx, fy))
-			{
-				ScrollToSignalAnimated(SelectedRef());
-				return BeginEdit(StyleEditField::OPACITY);
-			}
-			// 「调整」行：系数与镜像（按下只登记，**抬起**时才展开各自的二级面板，
-			// 与自定义颜色入口同一套交互）、绝对值（单击即切换）。
-			if (UiPointInRect(m_adjustRects[kAdjustGain], fx, fy))
-			{
-				m_pendingGainMenu = true;
-				ScrollToSignalAnimated(SelectedRef());
-				return true;
-			}
-			if (UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy))
-			{
-				m_pendingMirrorMenu = true;
-				ScrollToSignalAnimated(SelectedRef());
-				return true;
-			}
-			if (UiPointInRect(m_adjustRects[kAdjustAbsolute], fx, fy))
-			{
-				style->absolute = !style->absolute;
-				ScrollToSignalAnimated(SelectedRef());
-				return true;
-			}
-		}
-
-		// 列表行。
-		RowPart part = RowPart::NONE;
-		const int row = HitRow(x, y, part);
-		if (row < 0)
-		{
-			return false;
-		}
-
-		const ListRow item = m_rows[static_cast<std::size_t>(row)];
-
-		if (item.kind == RowKind::GROUP)
-		{
-			if (part == RowPart::CHECK)
-			{
-				const bool allVisible = m_tab->GroupAllVisible(item.groupIndex);
-				m_tab->SetGroupVisible(item.groupIndex, !allVisible);
-				m_rowsDirty = true;
-				return true;
-			}
-			if (part == RowPart::CLOSE)
-			{
-				// 关闭分组属于数据层操作，交由宿主窗口处理；但**抬起时才生效**，
-				// 这里只记录目标（按住后移开再松开视为放弃）。
-				m_pendingClosePart = RowPart::CLOSE;
-				m_pendingCloseRow = row;
-				return true;
-			}
-			// 折叠 / 展开分组：**只有**点到「折叠三角」或「组X」标签才生效
-			//（用户 2026-10-16 要求：点到分组名本体不折起）。
-			if (part != RowPart::DISCLOSURE && part != RowPart::GROUP_TITLE)
-			{
-				return true;
-			}
-			ToggleGroupFromRow(item.groupIndex, row);
-			return true;
-		}
-
-		const SignalRef ref{item.groupIndex, item.signalIndex};
-
-		// ✕：用户明确表示不再需要该信号 → 交由宿主从数据层移除并释放其采样内存。
-		// 必须在 SelectSignal 之前处理，避免选中一条即将被删除的信号；
-		// 且与其它 ✕ 一致，**抬起时才真正删除**（按住后移开再松开视为放弃）。
-		if (part == RowPart::REMOVE_SIGNAL)
-		{
-			m_pendingClosePart = RowPart::REMOVE_SIGNAL;
-			m_pendingCloseRow = row;
-			return true;
-		}
-
-		SelectSignal(ref);
-
-		if (part == RowPart::CHECK)
-		{
-			// 勾选/取消勾选会立即触发网格重新划分（取消后空网格随之消失）。
-			m_tab->ToggleVisible(ref);
-			m_rowsDirty = true;
-		}
-		else if (part == RowPart::LANE_BADGE)
-		{
-			// 在左键抬起时弹出，保证菜单不会随着按键松开而消失。
-			m_pendingLaneMenu = true;
-			m_pendingLaneRef = ref;
-		}
-		return true;
-	}
-
-	bool SignalPanel::OnLButtonUp(int x, int y)
-	{
-		bool changed = false;
-
-		// ---- 关闭类按钮（✕）：按下时记录目标，抬起时若指针仍在同一个 ✕ 上才执行 ----
-		if (m_pendingFilterClear)
-		{
-			m_pendingFilterClear = false;
-			const float fx = static_cast<float>(x);
-			const float fy = static_cast<float>(y);
-			const gd::RectF clearRect = FilterClearRect();
-			if (clearRect.Width > 0.0f && UiPointInRect(clearRect, fx, fy))
-			{
-				ClearFilter();
-				changed = true;
-			}
-		}
-		if (m_pendingClosePart != RowPart::NONE)
-		{
-			const RowPart pendingPart = m_pendingClosePart;
-			const int pendingRow = m_pendingCloseRow;
-			m_pendingClosePart = RowPart::NONE;
-			m_pendingCloseRow = -1;
-
-			RowPart part = RowPart::NONE;
-			const int row = HitRow(x, y, part);
-			if (row == pendingRow && part == pendingPart && row >= 0)
-			{
-				const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-				if (m_host != nullptr)
-				{
-					if (pendingPart == RowPart::CLOSE)
-					{
-						PostMessageW(m_host, WM_APP + 1, static_cast<WPARAM>(item.groupIndex), 0);
-					}
-					else
-					{
-						// wParam = 分组下标，lParam = 组内信号下标（见 Application 的消息处理）。
-						PostMessageW(m_host, WM_APP + 2, static_cast<WPARAM>(item.groupIndex),
-						             static_cast<LPARAM>(item.signalIndex));
-					}
-				}
-				changed = true;
-			}
-		}
-
-		if (m_draggingOpacity)
-		{
-			m_draggingOpacity = false;
-			changed = true;
-		}
-		if (m_draggingWidth)
-		{
-			m_draggingWidth = false;
-			changed = true;
-		}
-		if (m_draggingScrollBar)
-		{
-			m_draggingScrollBar = false;
-			changed = true;
-		}
-
-		if (m_pendingColorPicker)
-		{
-			m_pendingColorPicker = false;
-			const float fx = static_cast<float>(x);
-			const float fy = static_cast<float>(y);
-			if (UiPointInRect(m_customChipRect, fx, fy) && m_tab != nullptr)
-			{
-				if (const SignalStyle* style = StyleOf(SelectedRef()))
-				{
-					changed = OpenColorPickerPopup(*style) || changed;
-				}
-			}
-		}
-
-		// 「系数」/「镜像」：按下时只登记，抬起时指针仍在同一按钮上才展开二级面板
-		//（与自定义颜色入口一致：按住后移开再松开视为放弃）。
-		if (m_pendingGainMenu)
-		{
-			m_pendingGainMenu = false;
-			const float fx = static_cast<float>(x);
-			const float fy = static_cast<float>(y);
-			if (UiPointInRect(m_adjustRects[kAdjustGain], fx, fy) && m_tab != nullptr)
-			{
-				changed = OpenGainMenu() || changed;
-			}
-		}
-		if (m_pendingMirrorMenu)
-		{
-			m_pendingMirrorMenu = false;
-			const float fx = static_cast<float>(x);
-			const float fy = static_cast<float>(y);
-			if (UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy) && m_tab != nullptr)
-			{
-				changed = OpenMirrorMenu() || changed;
-			}
-		}
-
-		if (m_pendingLaneMenu)
-		{
-			m_pendingLaneMenu = false;
-			RowPart part = RowPart::NONE;
-			const int row = HitRow(x, y, part);
-			if (row >= 0 && part == RowPart::LANE_BADGE)
-			{
-				const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-				const SignalRef ref{item.groupIndex, item.signalIndex};
-				if (ref == m_pendingLaneRef)
-				{
-					const gd::RectF badge = SignalBadgeRect(row);
-					OpenLaneMenu(ref, static_cast<int>(badge.X),
-					             static_cast<int>(badge.Y + badge.Height));
-					changed = true;
-				}
-			}
-		}
-
-		return changed;
-	}
-
-	bool SignalPanel::OnDoubleClick(int x, int y)
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-
-		const float fx = static_cast<float>(x);
-		const float fy = static_cast<float>(y);
-
-		// 样式区数值框：双击进入（或保持）输入状态。
-		if (UiPointInRect(m_widthValueRect, fx, fy))
-		{
-			return BeginEdit(StyleEditField::WIDTH);
-		}
-		if (UiPointInRect(m_opacityValueRect, fx, fy))
-		{
-			return BeginEdit(StyleEditField::OPACITY);
-		}
-
-		// 样式区顶部「目标」行：双击信号名（或它后面的 GX 标签）进入**改名**编辑态。
-		// ⚠️ 单击不进入编辑（见 `OnLButtonDown`），必须双击 —— 用户明确要求。
-		if (m_tab != nullptr && StyleOf(SelectedRef()) != nullptr)
-		{
-			UpdateTargetRowGeometry();
-			const bool onName =
-			    m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy);
-			const bool onBadge =
-			    m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy);
-			if (onName || onBadge)
-			{
-				// `row < 0` 表示编辑目标是"当前选中信号"（即目标行显示的信号）。
-				m_rowsDirty = true;
-				return BeginEdit(StyleEditField::SIGNAL_NAME, -1);
-			}
-		}
-
-		RowPart part = RowPart::NONE;
-		const int row = HitRow(x, y, part);
-		if (row < 0)
-		{
-			return false;
-		}
-
-		const ListRow item = m_rows[static_cast<std::size_t>(row)];
-
-		// 分组行：双击折叠三角用于折叠，双击名称区域进入重命名。
-		if (item.kind == RowKind::GROUP)
-		{
-			if (part == RowPart::DISCLOSURE)
-			{
-				// 与单击分组行同一入口：悬浮时先滚动就位再播放折起动画。
-				ToggleGroupFromRow(item.groupIndex, row);
-				return true;
-			}
-			if (part != RowPart::BODY)
-			{
-				return false;
-			}
-			// 重命名分组会改变列表行高度以外的展示内容，重建行缓存以保证文字刷新。
-			m_rowsDirty = true;
-			return BeginEdit(StyleEditField::GROUP_TITLE, row);
-		}
-
-		// 复选框、网格徽标与「移除信号」✕ 各自由单击处理，双击不再切换可见性／进入重命名。
-		if (part == RowPart::CHECK || part == RowPart::LANE_BADGE || part == RowPart::REMOVE_SIGNAL)
-		{
-			return false;
-		}
-
-		const SignalRef ref{item.groupIndex, item.signalIndex};
-		SelectSignal(ref);
-		m_rowsDirty = true;
-		return BeginEdit(StyleEditField::SIGNAL_NAME, row);
-	}
-
-	bool SignalPanel::OnRButtonDown(int x, int y)
-	{
-		if (m_dataSet == nullptr || m_tab == nullptr)
-		{
-			return false;
-		}
-
-		RowPart part = RowPart::NONE;
-		const int row = HitRow(x, y, part);
-		if (row < 0)
-		{
-			return false;
-		}
-
-		const ListRow& item = m_rows[static_cast<std::size_t>(row)];
-		if (item.kind == RowKind::GROUP)
-		{
-			OpenGroupMenu(item.groupIndex, x, y);
-			return true;
-		}
-
-		const SignalRef ref{item.groupIndex, item.signalIndex};
-		SelectSignal(ref);
-		OpenSignalMenu(ref, x, y);
-		return true;
-	}
-
-	bool SignalPanel::OnMouseWheel(int delta)
-	{
-		// 用户主动滚动 ⇒ 立即取消正在进行的目标信号滚动动画（否则两者会互相打架）。
-		CancelScrollAnimation();
-
-		if (m_dataSet == nullptr)
-		{
-			return false;
-		}
-
-		const float previous = m_scrollOffset;
-		m_scrollOffset -= static_cast<float>(delta) / 120.0f * 54.0f * m_scale;
-		ClampScroll();
-		return std::fabs(previous - m_scrollOffset) > 0.01f;
-	}
-
-	bool SignalPanel::OnMouseLeave()
-	{
-		const bool changed =
-		    (m_hoverRow >= 0) || (m_hoverStyle != StyleHit::NONE) || m_hoveredSignal.IsValid();
-		m_hoverRow = -1;
-		m_hoverPart = RowPart::NONE;
-		m_hoverStyle = StyleHit::NONE;
-		m_hoverStyleIndex = -1;
-		// 鼠标离开面板 → 取消绘图区的联动高亮（用户要求"移开鼠标时恢复"）。
-		m_hoveredSignal = SignalRef();
-		return changed;
-	}
-
-	void SignalPanel::OpenSignalMenu(const SignalRef& ref, int x, int y)
-	{
-		if (m_menu == nullptr || m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-
-		const SignalStyle* style = StyleOf(ref);
-		const SignalData* signal = m_dataSet->Resolve(ref);
-		if (style == nullptr || signal == nullptr)
-		{
-			return;
-		}
-
-		m_menuTargetSignal = ref;
-		m_menuTargetGroup = -1;
-
-		std::vector<MenuItem> items;
-
-		MenuItem header;
-		header.kind = MenuItemKind::HEADER;
-		header.label = signal->name;
-		items.push_back(header);
-
-		MenuItem toggle;
-		toggle.label = m_tab->IsVisible(ref) ? L"隐藏该信号" : L"显示该信号";
-		toggle.id = CMD_SIGNAL_TOGGLE;
-		items.push_back(toggle);
-
-		MenuItem solo;
-		solo.label = L"仅显示该信号";
-		solo.id = CMD_SIGNAL_SOLO;
-		items.push_back(solo);
-
-		MenuItem showAll;
-		showAll.label = L"显示全部信号";
-		showAll.id = CMD_SIGNAL_SHOW_ALL;
-		items.push_back(showAll);
-
-		MenuItem hideAll;
-		hideAll.label = L"隐藏全部信号";
-		hideAll.id = CMD_SIGNAL_HIDE_ALL;
-		items.push_back(hideAll);
-
-		MenuItem separator;
-		separator.kind = MenuItemKind::SEPARATOR;
-		items.push_back(separator);
-
-		int paletteCount = 0;
-		const std::uint32_t* palette = SignalPalette(paletteCount);
-		MenuItem colors;
-		colors.kind = MenuItemKind::SWATCHES;
-		colors.id = CMD_COLOR_BASE;
-		colors.swatchCount = std::min(paletteCount, 16);
-		colors.checkedSwatch = -1;
-		for (int index = 0; index < colors.swatchCount; ++index)
-		{
-			colors.swatches[index] = palette[index];
-			if (style->color == palette[index])
-			{
-				colors.checkedSwatch = index;
-			}
-		}
-		items.push_back(colors);
-
-		MenuItem modeHeader;
-		modeHeader.kind = MenuItemKind::HEADER;
-		modeHeader.label = L"样式";
-		items.push_back(modeHeader);
-
-		for (int index = 0; index < kModeOptionCount; ++index)
-		{
-			MenuItem mode;
-			mode.label = DrawModeName(kModeOptions[index]);
-			mode.id = CMD_MODE_BASE + index;
-			mode.checked = (style->mode == kModeOptions[index]);
-			items.push_back(mode);
-		}
-
-		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
-		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, x, y, items);
-	}
-
-	void SignalPanel::OpenGroupMenu(int groupIndex, int x, int y)
-	{
-		if (m_menu == nullptr || m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-
-		const SignalGroup* group = m_dataSet->GroupAt(groupIndex);
-		if (group == nullptr)
-		{
-			return;
-		}
-
-		m_menuTargetGroup = groupIndex;
-		m_menuTargetSignal = SignalRef();
-
-		std::vector<MenuItem> items;
-
-		MenuItem header;
-		header.kind = MenuItemKind::HEADER;
-		header.label = group->name;
-		items.push_back(header);
-
-		MenuItem showAll;
-		showAll.label = L"选中该分组全部信号";
-		showAll.id = CMD_GROUP_SHOW_ALL;
-		items.push_back(showAll);
-
-		MenuItem hideAll;
-		hideAll.label = L"取消该分组全部信号";
-		hideAll.id = CMD_GROUP_HIDE_ALL;
-		items.push_back(hideAll);
-
-		MenuItem separator;
-		separator.kind = MenuItemKind::SEPARATOR;
-		items.push_back(separator);
-
-		MenuItem remove;
-		remove.label = L"关闭该分组（从工作区移除）";
-		remove.id = CMD_GROUP_REMOVE;
-		items.push_back(remove);
-
-		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
-		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, x, y, items);
-	}
-
-	void SignalPanel::OpenLaneMenu(const SignalRef& ref, int x, int y)
-	{
-		if (m_menu == nullptr || m_tab == nullptr || m_dataSet == nullptr)
-		{
-			return;
-		}
-
-		const SignalData* signal = m_dataSet->Resolve(ref);
-		if (signal == nullptr)
-		{
-			return;
-		}
-
-		m_menuTargetSignal = ref;
-		m_menuTargetGroup = -1;
-
-		std::vector<MenuItem> items;
-
-		MenuItem header;
-		header.kind = MenuItemKind::HEADER;
-		header.label = L"所属网格";
-		items.push_back(header);
-
-		const std::vector<Lane>& lanes = m_tab->Lanes();
-		const int currentLane = m_tab->LaneOfSignal(ref);
-		for (std::size_t index = 0; index < lanes.size(); ++index)
-		{
-			MenuItem lane;
-			lane.label = L"网格 " + std::to_wstring(index + 1) + L"（" +
-			             std::to_wstring(lanes[index].signals.size()) + L" 条信号）";
-			lane.id = CMD_LANE_BASE + static_cast<int>(index);
-			lane.checked = (currentLane == static_cast<int>(index));
-			items.push_back(lane);
-		}
-
-		MenuItem separator;
-		separator.kind = MenuItemKind::SEPARATOR;
-		items.push_back(separator);
-
-		MenuItem create;
-		create.label = L"新建网格";
-		create.id = CMD_LANE_NEW;
-		items.push_back(create);
-
-		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
-		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, x, y, items);
-	}
-
-	bool SignalPanel::OnMenuCommand(const MenuResult& result)
-	{
-		if (m_tab == nullptr || m_dataSet == nullptr || !result.valid)
-		{
-			return false;
-		}
-
-		// 「系数」/「偏移」二级面板里的输入框提交：就地更新，面板保持打开
-		//（与网格 Y 轴上下限的菜单内联编辑一致），并把夹取后的真实值回写到输入框上。
-		if (result.editCommit)
-		{
-			SignalStyle* style = StyleOf(SelectedRef());
-			if (style != nullptr)
-			{
-				const std::wstring trimmed = Trim(result.editText);
-				wchar_t* stop = nullptr;
-				const double parsed =
-				    trimmed.empty() ? 0.0 : std::wcstod(trimmed.c_str(), &stop);
-				// 非法/空输入保持原值（只把真实值回写到输入框，避免用户看到错误的数字）。
-				const bool valid = !trimmed.empty() && stop != trimmed.c_str() && std::isfinite(parsed);
-				switch (result.id)
-				{
-				case CMD_GAIN_EDIT:
-				{
-					if (valid)
-					{
-						style->gain =
-						    static_cast<float>(std::max(-kGainLimit, std::min(parsed, kGainLimit)));
-					}
-					if (m_menu != nullptr)
-					{
-						m_menu->UpdateItemValue(CMD_GAIN_EDIT, FormatGainText(style->gain),
-						                        FormatNumberText(static_cast<double>(style->gain)));
-					}
-					return false;
-				}
-				case CMD_OFFSET_Y:
-				{
-					if (valid)
-					{
-						style->offsetY = static_cast<float>(
-						    std::max(-static_cast<double>(kGainLimit), std::min(parsed, kGainLimit)));
-					}
-					if (m_menu != nullptr)
-					{
-						m_menu->UpdateItemValue(
-						    CMD_OFFSET_Y, FormatSignedNumber(static_cast<double>(style->offsetY)),
-						    FormatNumberText(static_cast<double>(style->offsetY)));
-					}
-					return false;
-				}
-				case CMD_OFFSET_TIME:
-				{
-					if (valid)
-					{
-						style->offsetTime =
-						    std::max(-kGainLimit, std::min(parsed, kGainLimit));
-					}
-					if (m_menu != nullptr)
-					{
-						m_menu->UpdateItemValue(CMD_OFFSET_TIME,
-						                        FormatOffsetTimeText(style->offsetTime),
-						                        FormatNumberText(style->offsetTime));
-					}
-					return false;
-				}
-				default:
-					break;
-				}
-			}
-			else
-			{
-				return false;
-			}
-		}
-
-		// 标题栏右侧的「还原」图标：系数重置为默认值 1（面板保持打开，输入框立即回显）。
-		if (result.id == CMD_GAIN_RESET)
-		{
-			if (SignalStyle* style = StyleOf(SelectedRef()))
-			{
-				style->gain = 1.0f;
-				if (m_menu != nullptr)
-				{
-					m_menu->UpdateItemValue(CMD_GAIN_EDIT, FormatGainText(style->gain),
-					                        FormatNumberText(static_cast<double>(style->gain)));
-				}
-			}
-			return false;
-		}
-
-		// 「偏移调整」的「还原」图标：Y 与时间偏移都恢复为默认值 0。
-		if (result.id == CMD_OFFSET_RESET)
-		{
-			if (SignalStyle* style = StyleOf(SelectedRef()))
-			{
-				style->offsetY = 0.0f;
-				style->offsetTime = 0.0;
-				if (m_menu != nullptr)
-				{
-					m_menu->UpdateItemValue(CMD_OFFSET_Y, FormatSignedNumber(0.0),
-					                        FormatNumberText(0.0));
-					m_menu->UpdateItemValue(CMD_OFFSET_TIME, FormatOffsetTimeText(0.0),
-					                        FormatNumberText(0.0));
-				}
-			}
-			return false;
-		}
-
-		// 「镜像」二级面板：两行带复选框的切换项（面板保持打开，勾选状态就地回写）。
-		if (result.id == CMD_MIRROR_HORIZONTAL || result.id == CMD_MIRROR_VERTICAL)
-		{
-			if (SignalStyle* style = StyleOf(SelectedRef()))
-			{
-				const bool horizontal = (result.id == CMD_MIRROR_HORIZONTAL);
-				bool& flag = horizontal ? style->mirrorHorizontal : style->mirrorVertical;
-				flag = !flag;
-				if (!horizontal)
-				{
-					// ⚠️ Y 偏移以**未镜像空间**为准：垂直镜像开关变化时同步取反偏移量，
-					// 使绘制等价于「先加上偏移再镜像」（用户明确要求）。
-					style->offsetY = -style->offsetY;
-					if (m_menu != nullptr)
-					{
-						m_menu->UpdateItemValue(
-						    CMD_OFFSET_Y, FormatSignedNumber(static_cast<double>(style->offsetY)),
-						    FormatNumberText(static_cast<double>(style->offsetY)));
-					}
-				}
-				if (m_menu != nullptr)
-				{
-					m_menu->UpdateItemLabel(result.id, horizontal ? L"水平镜像" : L"垂直镜像", flag, true);
-				}
-			}
-			return false;
-		}
-
-		bool needRelayout = false;
-
-		switch (result.id)
-		{
-		case CMD_SIGNAL_TOGGLE:
-			if (m_menuTargetSignal.IsValid())
-			{
-				m_tab->ToggleVisible(m_menuTargetSignal);
-				m_rowsDirty = true;
-				needRelayout = true;
-			}
-			break;
-		case CMD_SIGNAL_SOLO:
-			if (m_menuTargetSignal.IsValid())
-			{
-				m_tab->SoloSignal(m_menuTargetSignal);
-				m_rowsDirty = true;
-				needRelayout = true;
-			}
-			break;
-		case CMD_SIGNAL_SHOW_ALL:
-			m_tab->SetAllVisible(true);
-			m_rowsDirty = true;
-			needRelayout = true;
-			break;
-		case CMD_SIGNAL_HIDE_ALL:
-			m_tab->SetAllVisible(false);
-			m_rowsDirty = true;
-			needRelayout = true;
-			break;
-		case CMD_GROUP_SHOW_ALL:
-			if (m_menuTargetGroup >= 0)
-			{
-				m_tab->SetGroupVisible(m_menuTargetGroup, true);
-				m_rowsDirty = true;
-				needRelayout = true;
-			}
-			break;
-		case CMD_GROUP_HIDE_ALL:
-			if (m_menuTargetGroup >= 0)
-			{
-				m_tab->SetGroupVisible(m_menuTargetGroup, false);
-				m_rowsDirty = true;
-				needRelayout = true;
-			}
-			break;
-		case CMD_GROUP_REMOVE:
-			if (m_menuTargetGroup >= 0 && m_host != nullptr)
-			{
-				PostMessageW(m_host, WM_APP + 1, static_cast<WPARAM>(m_menuTargetGroup), 0);
-			}
-			break;
-		case CMD_LANE_NEW:
-			if (m_menuTargetSignal.IsValid())
-			{
-				m_tab->MoveSignalToLane(*m_dataSet, m_menuTargetSignal, -1);
-				m_rowsDirty = true;
-				needRelayout = true;
-			}
-			break;
-		default:
-			if (result.id >= CMD_LANE_BASE && result.id < CMD_LANE_NEW)
-			{
-				if (m_menuTargetSignal.IsValid())
-				{
-					m_tab->MoveSignalToLane(*m_dataSet, m_menuTargetSignal, result.id - CMD_LANE_BASE);
-					m_rowsDirty = true;
-					needRelayout = true;
-				}
-			}
-			else if (result.id == CMD_COLOR_BASE && result.swatchIndex >= 0)
-			{
-				if (SignalStyle* style = StyleOf(m_menuTargetSignal))
-				{
-					int paletteCount = 0;
-					const std::uint32_t* palette = SignalPalette(paletteCount);
-					style->color = palette[result.swatchIndex % std::max(1, paletteCount)];
-				}
-			}
-			else if (result.id >= CMD_MODE_BASE && result.id < CMD_MODE_BASE + kModeOptionCount)
-			{
-				if (SignalStyle* style = StyleOf(m_menuTargetSignal))
-				{
-					style->mode = kModeOptions[result.id - CMD_MODE_BASE];
-				}
-			}
-			break;
-		}
-
-		return needRelayout;
-	}
 
 } // namespace jdi
+
diff --git a/Components/SignalPanel/Src/SignalPanelInteraction.cpp b/Components/SignalPanel/Src/SignalPanelInteraction.cpp
new file mode 100644
index 0000000..377959d
--- /dev/null
+++ b/Components/SignalPanel/Src/SignalPanelInteraction.cpp
@@ -0,0 +1,2095 @@
+// SignalPanel 实现分片 —— 本文件只包含 SignalPanel 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 SignalPanelInternal.hpp（命名空间 `spdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "SignalPanelInternal.hpp"
+
+namespace jdi
+{
+
+	bool SignalPanel::IsOnFilterBox(int x, int y) const
+	{
+		return UiPointInRect(m_filterRect, static_cast<float>(x), static_cast<float>(y));
+	}
+
+	void SignalPanel::ClearFilter()
+	{
+		if (m_filterText.empty() && !m_filterEditing)
+		{
+			return;
+		}
+		m_filterText.clear();
+		if (m_filterEditing)
+		{
+			// 编辑态下一并重置输入模型，避免残留旧文本（Begin 会整段选中/清空）。
+			m_filterEdit.Begin(std::wstring(), false, EditFilter::ANY, 0u);
+		}
+		// 退出筛选：筛选模式下临时折起的状态与动画一并作废（行集合会整体重建）。
+		m_filterCollapsed.clear();
+		m_groupAnims.clear();
+		m_rowShift.clear();
+		// 清空后回到完整列表：重建行集合、回到顶部。
+		m_rowsDirty = true;
+		m_scrollOffset = 0.0f;
+		m_layoutDirty = true;
+	}
+
+	HCURSOR SignalPanel::QueryCursor(int x, int y)
+	{
+		// 清空按钮 ✕ 是独立可点击控件，用手型光标给出除高亮之外的额外交互提示。
+		const gd::RectF clearRect = FilterClearRect();
+		if (clearRect.Width > 0.0f &&
+		    UiPointInRect(clearRect, static_cast<float>(x), static_cast<float>(y)))
+		{
+			return LoadCursorW(nullptr, IDC_HAND);
+		}
+
+		// 信号行左侧的「移除该信号」✕ 同理。
+		RowPart part = RowPart::NONE;
+		if (HitRow(x, y, part) >= 0 && part == RowPart::REMOVE_SIGNAL)
+		{
+			return LoadCursorW(nullptr, IDC_HAND);
+		}
+
+		// 样式区的可点击控件（「调整」行三个按钮、线宽/透明度数值框）也用手型光标。
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+		// 样式区顶部「目标」行的信号名与 GX 标签：与信号列表行一致，用手型光标提示可交互。
+		UpdateTargetRowGeometry();
+		if ((m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy)) ||
+		    (m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy)))
+		{
+			return LoadCursorW(nullptr, IDC_HAND);
+		}
+		if (UiPointInRect(m_adjustRects[kAdjustGain], fx, fy) ||
+		    UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy) ||
+		    UiPointInRect(m_adjustRects[kAdjustAbsolute], fx, fy) || UiPointInRect(m_widthValueRect, fx, fy) ||
+		    UiPointInRect(m_opacityValueRect, fx, fy))
+		{
+			return LoadCursorW(nullptr, IDC_HAND);
+		}
+		return nullptr;
+	}
+
+	void SignalPanel::BeginFilterEdit()
+	{
+		if (m_filterEditing)
+		{
+			return;
+		}
+		m_filterEditing = true;
+		// 单击进入编辑：光标落在末尾，不做全选（用户可以继续追加筛选词）。
+		m_filterEdit.Begin(m_filterText, false, EditFilter::ANY, 0u);
+	}
+
+	bool SignalPanel::EndFilterEdit()
+	{
+		if (!m_filterEditing)
+		{
+			return false;
+		}
+		// **必须**在 `End()` 之前取出文本：`TextEdit::End()` 会清空内部缓冲区。
+		const std::wstring finalText = Trim(m_filterEdit.Text());
+		m_filterEditing = false;
+		m_filterEdit.End();
+		// 文本在编辑过程中已实时生效，这里只需把最终值再同步一次并收起插入符。
+		m_filterText = finalText;
+		return true;
+	}
+
+	bool SignalPanel::AdvanceGroupAnimations()
+	{
+		if (m_groupAnims.empty())
+		{
+			return false;
+		}
+
+		const std::uint64_t now = GetTickCount64();
+		bool rowsBecameStale = false;
+		for (std::size_t index = 0; index < m_groupAnims.size();)
+		{
+			const GroupAnim& anim = m_groupAnims[index];
+			const std::uint64_t elapsed = (now >= anim.startMs) ? (now - anim.startMs) : 0;
+			if (anim.durationMs == 0u || elapsed >= anim.durationMs)
+			{
+				// 完成：把同步滚动精确落到终点（最后一帧的 eased 进度未必正好是 1）。
+				if (anim.scrollSynced)
+				{
+					m_scrollOffset = anim.scrollTo;
+				}
+				// 折起完成后该组的信号行要**真正移除** ⇒ 行集合需重建
+				//（展开完成后行集合本来就是展开态，无需重建；平移量归零即可）。
+				if (anim.collapsing)
+				{
+					rowsBecameStale = true;
+				}
+				m_groupAnims.erase(m_groupAnims.begin() + static_cast<std::ptrdiff_t>(index));
+			}
+			else
+			{
+				++index;
+			}
+		}
+
+		// ⚠️ **不设置 `m_rowsDirty`**：行高不随动画变化，只需重算逐行位移与内容高度 ——
+		// 这正是本动画方案比“逐行缩放”流畅得多的原因（无需每帧重建行集合）。
+		UpdateAnimGeometry();
+		if (rowsBecameStale)
+		{
+			m_rowsDirty = true;
+		}
+		return !m_groupAnims.empty();
+	}
+
+	void SignalPanel::ToggleGroupFromRow(int groupIndex, int row)
+	{
+		EnsureRows();
+		if (m_tab == nullptr || groupIndex < 0)
+		{
+			return;
+		}
+
+		const int headerRow =
+		    (row >= 0 && row < static_cast<int>(m_rows.size()) &&
+		     m_rows[static_cast<std::size_t>(row)].kind == RowKind::GROUP &&
+		     m_rows[static_cast<std::size_t>(row)].groupIndex == groupIndex)
+		        ? row
+		        : GroupRowIndex(groupIndex);
+
+		const bool collapse = !IsGroupCollapsed(groupIndex);
+		SetGroupCollapsed(groupIndex, collapse);
+
+		// 悬浮（组名的自然位置已在列表上边界之上）且要折起时：**一边向上滚动一边收起**，
+		// 保证悬浮组名始终留在列表最上方，动画结束时滚动偏移恰好落在“组名正好在最上方”。
+		//（用户 2026-10-16 第二轮明确要求：不再“先滚动到位、再播放收起动画”。）
+		float scrollFrom = m_scrollOffset;
+		float scrollTo = m_scrollOffset;
+		bool syncScroll = false;
+		if (collapse && headerRow >= 0)
+		{
+			const float alignOffset = ContentOffsetBeforeRow(headerRow);
+			if (m_scrollOffset > alignOffset + 0.5f)
+			{
+				// 目标滚动量受“折起后的最终内容高度”限制：若内容比列表还短，
+				// 就无法把组名顶到最上方（此时取可达的最大滚动量，避免结束时被强行夹取）。
+				const float finalContent =
+				    std::max(0.0f, NaturalContentHeight() - ShownBlockHeight(groupIndex));
+				const float maxOffset = std::max(0.0f, finalContent - m_listRect.Height);
+				scrollTo = std::max(0.0f, std::min(alignOffset, maxOffset));
+				syncScroll = true;
+			}
+		}
+
+		StartGroupToggle(groupIndex, collapse, scrollFrom, scrollTo, syncScroll);
+	}
+
+	int SignalPanel::HitRow(int x, int y, RowPart& part)
+	{
+		part = RowPart::NONE;
+		EnsureRows();
+
+		if (m_listRect.Height <= 0.0f)
+		{
+			return -1;
+		}
+
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+		if (fy < m_listRect.Y || fy > m_listRect.Y + m_listRect.Height)
+		{
+			return -1;
+		}
+		if (fx < m_listRect.X || fx > m_listRect.X + m_listRect.Width)
+		{
+			return -1;
+		}
+
+		// 「悬浮组名」绘制在最上层，因此命中判定也必须最优先 —— 否则点击会**穿透到
+		// 它下面的那一行**（用户 2026-10-16 报告：组名悬浮时它上面的折叠三角、复选框、
+		// 关闭 ✕、名称区域全都点不动，点击被下层信号行吃掉）。
+		const int rowCount = static_cast<int>(m_rows.size());
+		const int stickyRow = StickyGroupRowIndex(rowCount);
+		if (stickyRow >= 0)
+		{
+			const float stickyTop = StickyGroupRowTop(stickyRow, rowCount);
+			const float stickyHeight = m_rows[static_cast<std::size_t>(stickyRow)].height;
+			if (fy >= stickyTop && fy < stickyTop + stickyHeight)
+			{
+				// 用覆盖几何计算行内区域（`RowRect` 是行内所有派生的唯一几何来源）。
+				m_rowYOverrideActive = true;
+				m_rowYOverrideY = stickyTop;
+				part = RowHitPart(stickyRow, fx, fy);
+				m_rowYOverrideActive = false;
+				return stickyRow;
+			}
+		}
+
+		const float local = fy - m_listRect.Y + m_scrollOffset;
+		if (local < 0.0f)
+		{
+			return -1;
+		}
+
+		// 逐行比较“实际绘制位置”（含折起/展开动画的刚性平移），不能只看滚动偏移：
+		// 动画中信号行的位置与“自然内容坐标”不再一一对应，用后者会点错行。
+		float rowTop = m_listRect.Y - m_scrollOffset;
+		for (std::size_t index = 0; index < m_rows.size(); ++index)
+		{
+			const float shift = (index < m_rowShift.size()) ? m_rowShift[index] : 0.0f;
+			const float previousShift =
+			    (index > 0 && (index - 1) < m_rowShift.size()) ? m_rowShift[index - 1] : 0.0f;
+			rowTop -= (shift - previousShift);
+
+			const ListRow& row = m_rows[index];
+			const float rowBottom = rowTop + row.height;
+			if (row.height > 0.0f && fy >= rowTop && fy < rowBottom)
+			{
+				const int rowIndex = static_cast<int>(index);
+				// 折起/展开动画中已“藏进组名栏”的行不再参与命中（否则它会白白吸走一次点击）。
+				if (rowBottom > AnimationHideTopForRow(rowIndex, stickyRow) + 0.5f)
+				{
+					part = RowHitPart(rowIndex, fx, fy);
+					return rowIndex;
+				}
+				return -1;
+			}
+			rowTop = rowBottom;
+		}
+		return -1;
+	}
+
+	void SignalPanel::StartScrollAnimationTo(float desired)
+	{
+		const float maxOffset = std::max(0.0f, m_contentHeight - m_listRect.Height);
+		desired = std::max(0.0f, std::min(desired, maxOffset));
+		const float distance = std::fabs(desired - m_scrollOffset);
+
+		if (distance < 1.0f)
+		{
+			// 已经到位：不需要动画（但仍然要把残余的亚像素差抹平）。
+			m_scrollOffset = desired;
+			ClampScroll();
+			m_scrollAnimActive = false;
+			return;
+		}
+
+		// 时长随距离增长（越远越快 = 同样时间内走更多距离），到上限后不再增长，
+		// 因此"整个动画过程不会太久"（最长 300ms）。
+		const float durationMs =
+		    std::max(kScrollAnimMinMs, std::min(kScrollAnimMaxMs, distance * kScrollAnimMsPerPixel));
+		m_scrollAnimFrom = m_scrollOffset;
+		m_scrollAnimTo = desired;
+		m_scrollAnimStartMs = GetTickCount64();
+		m_scrollAnimDurationMs = static_cast<std::uint32_t>(durationMs + 0.5f);
+		m_scrollAnimActive = true;
+	}
+
+	void SignalPanel::ScrollToSignal(const SignalRef& ref)
+	{
+		EnsureRows();
+		if (!ref.IsValid())
+		{
+			return;
+		}
+
+		float top = 0.0f;
+		for (std::size_t index = 0; index < m_rows.size(); ++index)
+		{
+			const ListRow& row = m_rows[index];
+			if (row.kind == RowKind::SIGNAL && row.groupIndex == ref.groupIndex &&
+			    row.signalIndex == ref.signalIndex)
+			{
+				if (top < m_scrollOffset)
+				{
+					m_scrollOffset = top;
+				}
+				else if (top + row.height > m_scrollOffset + m_listRect.Height)
+				{
+					m_scrollOffset = top + row.height - m_listRect.Height;
+				}
+				ClampScroll();
+				return;
+			}
+			top += row.height;
+		}
+	}
+
+	void SignalPanel::ScrollToSignalAnimated(const SignalRef& ref)
+	{
+		EnsureRows();
+		float desired = m_scrollOffset;
+		if (!SignalScrollTarget(ref, desired))
+		{
+			return;
+		}
+		// 把列表平滑滚动到目标信号完整可见。
+		StartScrollAnimationTo(desired);
+	}
+
+	bool SignalPanel::AdvanceScrollAnimation()
+	{
+		if (!m_scrollAnimActive)
+		{
+			return false;
+		}
+
+		const std::uint64_t now = GetTickCount64();
+		const std::uint64_t elapsed = (now >= m_scrollAnimStartMs) ? (now - m_scrollAnimStartMs) : 0;
+		float progress = (m_scrollAnimDurationMs > 0u)
+		                     ? static_cast<float>(elapsed) / static_cast<float>(m_scrollAnimDurationMs)
+		                     : 1.0f;
+		if (progress > 1.0f)
+		{
+			progress = 1.0f;
+		}
+
+		// ease-out cubic：起步快、靠近目标时变慢（用户要求"越远时越快，靠近时变慢"）。
+		const float eased = 1.0f - std::pow(1.0f - progress, 3.0f);
+		m_scrollOffset = m_scrollAnimFrom + (m_scrollAnimTo - m_scrollAnimFrom) * eased;
+
+		if (progress >= 1.0f)
+		{
+			m_scrollOffset = m_scrollAnimTo;
+			m_scrollAnimActive = false;
+			ClampScroll();
+			return false;
+		}
+		return true;
+	}
+
+	bool SignalPanel::ApplyWidthFromX(float x)
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		SignalStyle* style = StyleOf(SelectedRef());
+		if (style == nullptr)
+		{
+			return false;
+		}
+
+		const double ratio = UiSliderRatioFromX(m_widthTrackRect, x);
+		float value = static_cast<float>(kWidthMin + ratio * (kWidthMax - kWidthMin));
+		value = std::round(value * 10.0f) / 10.0f;
+		value = ClampFloat(value, kWidthMin, kWidthMax);
+		if (std::fabs(value - style->lineWidth) < 0.001f)
+		{
+			return false;
+		}
+		style->lineWidth = value;
+		return true;
+	}
+
+	bool SignalPanel::BeginEdit(StyleEditField field, int row)
+	{
+		if (m_tab == nullptr || field == StyleEditField::NONE)
+		{
+			return false;
+		}
+		if (m_editField == field && m_editRow == row)
+		{
+			return false;
+		}
+
+		std::wstring initial;
+		switch (field)
+		{
+		case StyleEditField::WIDTH:
+		{
+			const SignalStyle* style = StyleOf(SelectedRef());
+			if (style == nullptr)
+			{
+				return false;
+			}
+			initial = FormatNumber(style->lineWidth, 1);
+			break;
+		}
+		case StyleEditField::OPACITY:
+		{
+			const SignalStyle* style = StyleOf(SelectedRef());
+			if (style == nullptr)
+			{
+				return false;
+			}
+			initial = std::to_wstring(static_cast<int>(style->opacity * 100.0f + 0.5f));
+			break;
+		}
+		case StyleEditField::SIGNAL_NAME:
+		{
+			// `row < 0`：样式区顶部「目标」行 —— 编辑对象就是当前选中的（目标）信号。
+			if (row < 0)
+			{
+				const SignalData* signal = SelectedRef().IsValid() ? m_dataSet->Resolve(SelectedRef()) : nullptr;
+				if (signal == nullptr)
+				{
+					return false;
+				}
+				initial = signal->name;
+				break;
+			}
+			if (row >= static_cast<int>(m_rows.size()))
+			{
+				return false;
+			}
+			const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+			const SignalData* signal = m_dataSet->Resolve(SignalRef{item.groupIndex, item.signalIndex});
+			if (signal == nullptr)
+			{
+				return false;
+			}
+			initial = signal->name;
+			break;
+		}
+		case StyleEditField::GROUP_TITLE:
+		{
+			if (row < 0 || row >= static_cast<int>(m_rows.size()))
+			{
+				return false;
+			}
+			const SignalGroup* group = m_dataSet->GroupAt(m_rows[static_cast<std::size_t>(row)].groupIndex);
+			if (group == nullptr)
+			{
+				return false;
+			}
+			initial = group->name;
+			break;
+		}
+		default:
+			return false;
+		}
+
+		m_editField = field;
+		m_editRow = row;
+
+		if (field == StyleEditField::SIGNAL_NAME && row < 0)
+		{
+			// 「目标」行的输入框与行内名称矩形同源，必须先按当前目标算好几何。
+			UpdateTargetRowGeometry();
+		}
+
+		// 名称类字段可输入任意字符，数值类字段限制为数字与小数点。
+		const bool nameField =
+		    (field == StyleEditField::SIGNAL_NAME) || (field == StyleEditField::GROUP_TITLE);
+		// 不限长度：名称与数值都由各自的提交逻辑处理超长内容。
+		m_edit.Begin(std::move(initial), true, nameField ? EditFilter::ANY : EditFilter::NUMBER, 0u);
+		return true;
+	}
+
+	bool SignalPanel::EndEdit(bool commit)
+	{
+		if (m_editField == StyleEditField::NONE)
+		{
+			return false;
+		}
+
+		const StyleEditField field = m_editField;
+		const int row = m_editRow;
+		const std::wstring text = m_edit.Text();
+
+		m_editField = StyleEditField::NONE;
+		m_editRow = -1;
+		m_edit.End();
+
+		if (!commit || m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return true;
+		}
+
+		const std::wstring trimmed = Trim(text);
+		switch (field)
+		{
+		case StyleEditField::WIDTH:
+		{
+			if (trimmed.empty())
+			{
+				break;
+			}
+			wchar_t* stop = nullptr;
+			const double parsed = std::wcstod(trimmed.c_str(), &stop);
+			if (stop == trimmed.c_str() || parsed != parsed)
+			{
+				break;
+			}
+			if (SignalStyle* style = StyleOf(SelectedRef()))
+			{
+				const float value = ClampFloat(static_cast<float>(parsed), kWidthMin, kWidthMax);
+				style->lineWidth = std::round(value * 10.0f) / 10.0f;
+			}
+			break;
+		}
+		case StyleEditField::OPACITY:
+		{
+			if (trimmed.empty())
+			{
+				break;
+			}
+			wchar_t* stop = nullptr;
+			const double parsed = std::wcstod(trimmed.c_str(), &stop);
+			if (stop == trimmed.c_str() || parsed != parsed)
+			{
+				break;
+			}
+			if (SignalStyle* style = StyleOf(SelectedRef()))
+			{
+				style->opacity = ClampFloat(static_cast<float>(parsed) / 100.0f, 0.0f, 1.0f);
+			}
+			break;
+		}
+		case StyleEditField::SIGNAL_NAME:
+		{
+			if (m_dataSetWritable == nullptr)
+			{
+				break;
+			}
+			if (row < 0)
+			{
+				// 样式区「目标」行：重命名当前选中的（目标）信号。
+				const SignalRef& target = SelectedRef();
+				if (target.IsValid())
+				{
+					m_dataSetWritable->RenameSignal(target.groupIndex, target.signalIndex, trimmed);
+				}
+				// 名称变化会改变「目标」行的文本宽度 ⇒ 几何缓存作废。
+				m_targetGeomValid = false;
+				break;
+			}
+			if (row >= static_cast<int>(m_rows.size()))
+			{
+				break;
+			}
+			const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+			m_dataSetWritable->RenameSignal(item.groupIndex, item.signalIndex, trimmed);
+			break;
+		}
+		case StyleEditField::GROUP_TITLE:
+		{
+			if (row < 0 || row >= static_cast<int>(m_rows.size()) || m_dataSetWritable == nullptr)
+			{
+				break;
+			}
+			m_dataSetWritable->RenameGroup(m_rows[static_cast<std::size_t>(row)].groupIndex, trimmed);
+			break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool SignalPanel::OnEditChar(wchar_t character)
+	{
+		// 「筛选信号」输入框：字符实时进入筛选（无需回车即可看到结果变化）。
+		if (m_filterEditing)
+		{
+			switch (character)
+			{
+			case 0x03: // Ctrl+C
+				m_filterEdit.CopyToClipboard(m_host);
+				return false;
+			case 0x18: // Ctrl+X
+				m_filterEdit.CutToClipboard(m_host);
+				ApplyFilterText(m_filterEdit.Text());
+				return true;
+			case 0x16: // Ctrl+V
+				m_filterEdit.PasteFromClipboard(m_host);
+				ApplyFilterText(m_filterEdit.Text());
+				return true;
+			case 0x01: // Ctrl+A
+				m_filterEdit.SelectAll();
+				return true;
+			default:
+				break;
+			}
+			if (character == L'\r' || character == L'\n')
+			{
+				return EndFilterEdit();
+			}
+			// 退格/删除已由 WM_KEYDOWN 的 OnEditKey 处理，运里忽略控制字符避免重复删除。
+			if (character < 0x20 || character == 0x7F)
+			{
+				return false;
+			}
+			if (!m_filterEdit.Insert(character))
+			{
+				return false;
+			}
+			ApplyFilterText(m_filterEdit.Text());
+			return true;
+		}
+
+		if (m_editField == StyleEditField::NONE)
+		{
+			return false;
+		}
+
+		// 剪贴板与全选快捷键经 WM_CHAR 送达（Ctrl+C/X/V/A 分别对应 3/24/22/1）。
+		switch (character)
+		{
+		case 0x03: // Ctrl+C
+			m_edit.CopyToClipboard(m_host);
+			return false;
+		case 0x18: // Ctrl+X
+			return m_edit.CutToClipboard(m_host);
+		case 0x16: // Ctrl+V
+			return m_edit.PasteFromClipboard(m_host);
+		case 0x01: // Ctrl+A
+			m_edit.SelectAll();
+			return true;
+		default:
+			break;
+		}
+
+		if (character == L'\r' || character == L'\n')
+		{
+			return EndEdit(true);
+		}
+		// 退格/删除已由 WM_KEYDOWN 的 OnEditKey 处理：这里必须忽略控制字符，
+		// 否则同一次按键会被处理两次（一次删除两个字符）。
+		if (character < 0x20 || character == 0x7F)
+		{
+			return false;
+		}
+		// 百分比字段允许直接输入 % 但会被忽略，其余控制字符一律丢弃。
+		if (m_editField == StyleEditField::OPACITY && character == L'%')
+		{
+			return false;
+		}
+		return m_edit.Insert(character);
+	}
+
+	bool SignalPanel::OnEditKey(WPARAM key)
+	{
+		// 「筛选信号」输入框的键盘处理（回车结束编辑，Esc 清空并结束）。
+		if (m_filterEditing)
+		{
+			const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
+			const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
+			switch (key)
+			{
+			case VK_RETURN:
+				return EndFilterEdit();
+			case VK_ESCAPE:
+			{
+				const bool changed = m_filterEdit.Text() != m_filterText;
+				EndFilterEdit();
+				return changed;
+			}
+			case VK_BACK:
+			{
+				if (!m_filterEdit.Backspace())
+				{
+					return false;
+				}
+				ApplyFilterText(m_filterEdit.Text());
+				return true;
+			}
+			case VK_DELETE:
+			{
+				if (!m_filterEdit.DeleteForward())
+				{
+					return false;
+				}
+				ApplyFilterText(m_filterEdit.Text());
+				return true;
+			}
+			case VK_LEFT:
+				return m_filterEdit.MoveCaret(-1, shift);
+			case VK_RIGHT:
+				return m_filterEdit.MoveCaret(1, shift);
+			case VK_HOME:
+				return m_filterEdit.MoveHome(shift);
+			case VK_END:
+				return m_filterEdit.MoveEnd(shift);
+			case 'A':
+				if (control)
+				{
+					m_filterEdit.SelectAll();
+					return true;
+				}
+				break;
+			default:
+				break;
+			}
+			return true;
+		}
+
+		if (m_editField == StyleEditField::NONE)
+		{
+			return false;
+		}
+
+		const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
+		const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
+
+		switch (key)
+		{
+		case VK_RETURN:
+			return EndEdit(true);
+		case VK_ESCAPE:
+			return EndEdit(false);
+		case VK_BACK:
+			return m_edit.Backspace();
+		case VK_DELETE:
+			return m_edit.DeleteForward();
+		case VK_LEFT:
+			return m_edit.MoveCaret(-1, shift);
+		case VK_RIGHT:
+			return m_edit.MoveCaret(1, shift);
+		case VK_HOME:
+			return m_edit.MoveHome(shift);
+		case VK_END:
+			return m_edit.MoveEnd(shift);
+		case 'A':
+			if (control)
+			{
+				m_edit.SelectAll();
+				return true;
+			}
+			break;
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool SignalPanel::CollapseEditSelectionToEnd()
+	{
+		if (m_filterEditing)
+		{
+			return m_filterEdit.DeselectToEnd();
+		}
+		if (m_editField == StyleEditField::NONE)
+		{
+			return false;
+		}
+		return m_edit.DeselectToEnd();
+	}
+
+	bool SignalPanel::OnEditMouseDown(int x, int y)
+	{
+		if (m_filterEditing)
+		{
+			// 编辑态下 ✕ 位于输入框内容区之内，必须优先于插入符定位处理，
+			// 否则点击会被当成"把光标移到此处"而清空不了内容。
+			// 与其它 ✕ 一致：按下只记录目标，抬起时仍在 ✕ 上才真正清空。
+			const gd::RectF clearRect = FilterClearRect();
+			if (clearRect.Width > 0.0f &&
+			    UiPointInRect(clearRect, static_cast<float>(x), static_cast<float>(y)))
+			{
+				m_pendingFilterClear = true;
+				return true;
+			}
+			return UiEditFieldMouseDown(m_fonts->uiSmall, FilterFieldRect(), m_filterEdit, m_scale, x, y);
+		}
+		if (m_editField == StyleEditField::NONE)
+		{
+			return false;
+		}
+		return UiEditFieldMouseDown(m_fonts->ui, EditFieldRect(), m_edit, m_scale, x, y);
+	}
+
+	bool SignalPanel::OnEditMouseMove(int x)
+	{
+		if (m_filterEditing)
+		{
+			return UiEditFieldMouseMove(m_fonts->uiSmall, FilterFieldRect(), m_filterEdit, m_scale, x);
+		}
+		if (m_editField == StyleEditField::NONE)
+		{
+			return false;
+		}
+		return UiEditFieldMouseMove(m_fonts->ui, EditFieldRect(), m_edit, m_scale, x);
+	}
+
+	bool SignalPanel::OnEditMouseUp(int x, int y)
+	{
+		if (m_filterEditing)
+		{
+			// 筛选框右端的清空 ✕ 在编辑态下的**按下**走 OnEditMouseDown（优先于插入符定位），
+			// 抬起同样由宿主送进 EDIT_FIELD 分支，因此确认逻辑要在这里结算：
+			// 只有抬起时指针仍在 ✕ 上才真正清空，移开后松开视为放弃。
+			if (m_pendingFilterClear)
+			{
+				m_pendingFilterClear = false;
+				const gd::RectF clearRect = FilterClearRect();
+				if (clearRect.Width > 0.0f &&
+				    UiPointInRect(clearRect, static_cast<float>(x), static_cast<float>(y)))
+				{
+					ClearFilter();
+					return true;
+				}
+			}
+			if (!m_filterEdit.Dragging())
+			{
+				return false;
+			}
+			m_filterEdit.EndDrag();
+			return true;
+		}
+		if (!m_edit.Dragging())
+		{
+			return false;
+		}
+		m_edit.EndDrag();
+		return true;
+	}
+
+	void SignalPanel::SelectSignal(const SignalRef& ref)
+	{
+		if (m_dataSetWritable != nullptr)
+		{
+			m_dataSetWritable->SetSelected(ref);
+		}
+	}
+
+	bool SignalPanel::ApplyColor(std::uint32_t color)
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		SignalStyle* style = StyleOf(SelectedRef());
+		if (style == nullptr)
+		{
+			return false;
+		}
+
+		// 同时记住最后一次自定义取值，便于切换到预设色后一键回到该颜色。
+		const bool changed = (style->color != color) || (style->customColor != color);
+		style->color = color;
+		style->customColor = color;
+		return changed;
+	}
+
+	bool SignalPanel::ApplyOpacityFromX(float x)
+	{
+		if (m_tab == nullptr)
+		{
+			return false;
+		}
+		SignalStyle* style = StyleOf(SelectedRef());
+		if (style == nullptr)
+		{
+			return false;
+		}
+
+		const float value = static_cast<float>(UiSliderRatioFromX(m_opacityTrackRect, x));
+		if (std::fabs(value - style->opacity) < 0.005f)
+		{
+			return false;
+		}
+		style->opacity = value;
+		return true;
+	}
+
+	bool SignalPanel::OpenGainMenu()
+	{
+		if (m_menu == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+		const SignalStyle* style = StyleOf(SelectedRef());
+		if (style == nullptr)
+		{
+			return false;
+		}
+
+		// 二级面板：两张“标题（带还原图标）+ 输入框”的组合：
+		//   1. 「系数调整」：一整行系数输入框；
+		//   2. 「偏移调整」：下方两行分别为「Y轴」与「时间轴」的偏移输入框。
+		//（与网格 Y 轴上下限的菜单内联编辑同一套做法：提交后面板保持打开，可连续微调。）
+		std::vector<MenuItem> items;
+
+		MenuItem gainHeader;
+		gainHeader.kind = MenuItemKind::HEADER_ACTION;
+		gainHeader.label = L"系数调整";
+		gainHeader.id = CMD_GAIN_RESET;	// 点击标题栏右侧的还原图标 → 系数重置为 1
+		items.push_back(gainHeader);
+
+		// 非编辑态带正号（用户明确要求）；进入编辑后的初始文本用不带符号的纯数值。
+		const std::wstring gainText = FormatGainText(style->gain);
+		const std::wstring gainEditText = FormatNumberText(static_cast<double>(style->gain));
+		MenuItem gainEdit;
+		gainEdit.kind = MenuItemKind::EDIT;
+		gainEdit.label.clear();		// 不显示说明文字：输入框独占整行
+		gainEdit.id = CMD_GAIN_EDIT;
+		gainEdit.value = gainText;
+		gainEdit.editValue = gainEditText;
+		gainEdit.filter = EditFilter::NUMBER;
+		items.push_back(gainEdit);
+
+		MenuItem offsetHeader;
+		offsetHeader.kind = MenuItemKind::HEADER_ACTION;
+		offsetHeader.label = L"偏移调整";
+		offsetHeader.id = CMD_OFFSET_RESET;	// 点击还原图标 → 两个偏移都恢复默认值
+		items.push_back(offsetHeader);
+
+		// 「Y轴」：对绘制值加上一个常数偏移（波形上下移动），非编辑态带正负号。
+		MenuItem offsetY;
+		offsetY.kind = MenuItemKind::EDIT;
+		offsetY.label = L"Y轴";
+		offsetY.id = CMD_OFFSET_Y;
+		offsetY.value = FormatSignedNumber(static_cast<double>(style->offsetY));
+		offsetY.editValue = FormatNumberText(static_cast<double>(style->offsetY));
+		offsetY.filter = EditFilter::NUMBER;
+		items.push_back(offsetY);
+
+		// 「时间轴」：把采样沿时间轴平移（画在 t + offsetTime）。
+		// 非编辑态显示与双光标差值同一套复合单位文本，并**带正负号**（用户明确要求）；
+		// 编辑态显示以秒为单位的数值，并在输入框最右侧提示单位 `s`。
+		MenuItem offsetTime;
+		offsetTime.kind = MenuItemKind::EDIT;
+		offsetTime.label = L"时间轴";
+		offsetTime.id = CMD_OFFSET_TIME;
+		offsetTime.value = FormatOffsetTimeText(style->offsetTime);
+		offsetTime.editValue = FormatNumberText(style->offsetTime);
+		offsetTime.editSuffix = L"s";
+		offsetTime.filter = EditFilter::NUMBER;
+		items.push_back(offsetTime);
+
+		// 锚定在按钮**左上角的上方一点**：二级面板**向上展开**，其左下角对准按钮左上角，
+		// 并再往上让出 `kAdjustMenuGap`（用户明确要求）。
+		//（旧实现在按钮下沿向右下展开，面板会盖住下方内容。）
+		const gd::RectF& button = m_adjustRects[kAdjustGain];
+		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
+		const int anchorY =
+		    static_cast<int>(std::lround(button.Y - kAdjustMenuGap * m_scale));
+		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, static_cast<int>(button.X), anchorY, items,
+		             true);
+		// ⚠️ 菜单一旦打开就会接管鼠标事件，样式区不会再收到 WM_MOUSEMOVE →
+		// 必须在这里主动清掉按钮的悬停态，否则按钮会"像鼠标一直按着"一样持续高亮。
+		ClearStyleHover();
+		return true;
+	}
+
+	bool SignalPanel::OpenMirrorMenu()
+	{
+		if (m_menu == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+		const SignalStyle* style = StyleOf(SelectedRef());
+		if (style == nullptr)
+		{
+			return false;
+		}
+
+		// 两行带复选框的选项：点击即切换、且**保持菜单打开**（可连续勾选两项）。
+		std::vector<MenuItem> items;
+
+		MenuItem horizontal;
+		horizontal.kind = MenuItemKind::NORMAL;
+		horizontal.label = L"水平镜像";
+		horizontal.id = CMD_MIRROR_HORIZONTAL;
+		horizontal.checked = style->mirrorHorizontal;
+		horizontal.keepOpen = true;
+		items.push_back(horizontal);
+
+		MenuItem vertical;
+		vertical.kind = MenuItemKind::NORMAL;
+		vertical.label = L"垂直镜像";
+		vertical.id = CMD_MIRROR_VERTICAL;
+		vertical.checked = style->mirrorVertical;
+		vertical.keepOpen = true;
+		items.push_back(vertical);
+
+		const gd::RectF& button = m_adjustRects[kAdjustMirror];
+		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
+		// 与「系数/偏移」面板同一套锛定：向上展开，左下角 = 按钮左上角再上移一点。
+		const int anchorY =
+		    static_cast<int>(std::lround(button.Y - kAdjustMenuGap * m_scale));
+		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, static_cast<int>(button.X), anchorY, items,
+		             true);
+		ClearStyleHover();
+		return true;
+	}
+
+	void SignalPanel::ClearStyleHover()
+	{
+		if (m_hoverStyle == StyleHit::NONE && m_hoverStyleIndex < 0)
+		{
+			return;
+		}
+		m_hoverStyle = StyleHit::NONE;
+		m_hoverStyleIndex = -1;
+	}
+
+	bool SignalPanel::CloseTransientUi()
+	{
+		bool changed = false;
+		if (m_editField != StyleEditField::NONE)
+		{
+			changed = EndEdit(true) || changed;
+		}
+		// 点击面板之外也要结束「筛选信号」的编辑状态。
+		if (m_filterEditing)
+		{
+			changed = EndFilterEdit() || changed;
+		}
+		if (m_colorPicker != nullptr && m_colorPicker->IsOpen())
+		{
+			m_colorPicker->Close();
+			changed = true;
+		}
+		// 面板外点击：取消尚未抬起确认的关闭操作。
+		m_pendingClosePart = RowPart::NONE;
+		m_pendingCloseRow = -1;
+		m_pendingFilterClear = false;
+		m_pendingGainMenu = false;
+		m_pendingMirrorMenu = false;
+		return changed;
+	}
+
+	bool SignalPanel::OnMouseMove(int x, int y)
+	{
+		// 拖拽优先级最高。
+		if (m_draggingOpacity)
+		{
+			return ApplyOpacityFromX(static_cast<float>(x));
+		}
+		if (m_draggingWidth)
+		{
+			return ApplyWidthFromX(static_cast<float>(x));
+		}
+		if (m_draggingScrollBar)
+		{
+			const gd::RectF thumb = ScrollThumbRect();
+			// ⚠️ 拖拽期间滑块高度不会变（内容高度与列表高度都没变），因此 `thumb.Height` 可安全
+			// 用于本次换算；但 `m_scrollBarRect.Y` 必须取**按下时**记录的值（局部刷新/重排可能
+			// 改掉它）。坐标一律用**客户区** y，因此鼠标移到面板外（如绘图区）也能继续跟随。
+			const float travel = static_cast<float>(y - m_scrollGrabOffset) - m_scrollBarRect.Y;
+			const float usable = m_scrollBarRect.Height - thumb.Height;
+			if (usable > 0.0f)
+			{
+				const float progress = std::max(0.0f, std::min(1.0f, travel / usable));
+				m_scrollOffset = progress * (m_contentHeight - m_listRect.Height);
+				ClampScroll();
+			}
+			return true;
+		}
+
+		RowPart part = RowPart::NONE;
+		const int hoverRow = HitRow(x, y, part);
+
+		StyleHit hoverStyle = StyleHit::NONE;
+		int hoverStyleIndex = -1;
+
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+
+		if (UiPointInRect(m_toggleAllRect, fx, fy))
+		{
+			hoverStyle = StyleHit::TOGGLE_ALL;
+		}
+		else if (UiPointInRect(FilterClearRect(), fx, fy))
+		{
+			// 筛选框右侧的清空 ✕（仅在筛选框有内容时存在）。
+			hoverStyle = StyleHit::FILTER_CLEAR;
+		}
+		else if (m_tab != nullptr && StyleOf(SelectedRef()) != nullptr)
+		{
+			// 「目标」行的信号名 / GX 标签（优先于其余样式控件：它们几何不重叠，
+			// 但显式放在最前更易读）。
+			UpdateTargetRowGeometry();
+			if (UiPointInRect(m_targetRowRect, fx, fy))
+			{
+				if (m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy))
+				{
+					hoverStyle = StyleHit::TARGET_BADGE;
+				}
+				else if (m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy))
+				{
+					hoverStyle = StyleHit::TARGET_NAME;
+				}
+			}
+			for (int index = 0; hoverStyle == StyleHit::NONE && index < m_colorCount; ++index)
+			{
+				if (UiPointInRect(m_colorRects[static_cast<std::size_t>(index)], fx, fy))
+				{
+					hoverStyle = StyleHit::COLOR;
+					hoverStyleIndex = index;
+					break;
+				}
+			}
+			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_customChipRect, fx, fy))
+			{
+				hoverStyle = StyleHit::CUSTOM_CHIP;
+			}
+			if (hoverStyle == StyleHit::NONE)
+			{
+				for (int index = 0; index < kModeOptionCount; ++index)
+				{
+					if (UiPointInRect(m_modeRects[static_cast<std::size_t>(index)], fx, fy))
+					{
+						hoverStyle = StyleHit::MODE;
+						hoverStyleIndex = index;
+						break;
+					}
+				}
+			}
+			if (hoverStyle == StyleHit::NONE &&
+			    UiPointInRect(SliderHitRect(m_opacityTrackRect, m_scale), fx, fy))
+			{
+				hoverStyle = StyleHit::OPACITY_SLIDER;
+			}
+			if (hoverStyle == StyleHit::NONE &&
+			    UiPointInRect(SliderHitRect(m_widthTrackRect, m_scale), fx, fy))
+			{
+				hoverStyle = StyleHit::WIDTH_SLIDER;
+			}
+			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_opacityValueRect, fx, fy))
+			{
+				hoverStyle = StyleHit::OPACITY_VALUE;
+			}
+			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_widthValueRect, fx, fy))
+			{
+				hoverStyle = StyleHit::WIDTH_VALUE;
+			}
+			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_adjustRects[kAdjustGain], fx, fy))
+			{
+				hoverStyle = StyleHit::GAIN_ADJUST;
+			}
+			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy))
+			{
+				hoverStyle = StyleHit::MIRROR_ADJUST;
+			}
+			if (hoverStyle == StyleHit::NONE && UiPointInRect(m_adjustRects[kAdjustAbsolute], fx, fy))
+			{
+				hoverStyle = StyleHit::ABSOLUTE_TOGGLE;
+			}
+		}
+
+		if (hoverRow == m_hoverRow && hoverStyle == m_hoverStyle && hoverStyleIndex == m_hoverStyleIndex &&
+		    part == m_hoverPart)
+		{
+			return false;
+		}
+
+		m_hoverRow = hoverRow;
+		m_hoverPart = part;
+		m_hoverStyle = hoverStyle;
+		m_hoverStyleIndex = hoverStyleIndex;
+
+		// 供绘图区联动高亮的悬停信号（用户 2026-10-15 要求）：
+		//  * 列表里悬停某条信号行 → 高亮它所在的网格 + 该信号的曲线；
+		//  * 样式区「目标」行的信号名 / GX 标签上悬停 → 同样联动高亮。
+		// ⚠️ ✕（移除该信号）不算"悬停到该信号"：它是一条即将被删除的信号，
+		//    高亮它会让人误以为要保留它。
+		SignalRef hovered;
+		if (hoverRow >= 0 && hoverRow < static_cast<int>(m_rows.size()) &&
+		    m_rows[static_cast<std::size_t>(hoverRow)].kind == RowKind::SIGNAL &&
+		    part != RowPart::REMOVE_SIGNAL)
+		{
+			hovered = SignalRef{m_rows[static_cast<std::size_t>(hoverRow)].groupIndex,
+			                    m_rows[static_cast<std::size_t>(hoverRow)].signalIndex};
+		}
+		else if (hoverStyle == StyleHit::TARGET_NAME || hoverStyle == StyleHit::TARGET_BADGE)
+		{
+			hovered = SelectedRef();
+		}
+		m_hoveredSignal = hovered;
+		return true;
+	}
+
+	bool SignalPanel::OnLButtonDown(int x, int y)
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+
+		// 新的按下开始：上一轮留下的"待确认关闭"一律作废。
+		m_pendingClosePart = RowPart::NONE;
+		m_pendingCloseRow = -1;
+		m_pendingFilterClear = false;
+
+		// 「筛选信号」输入框：单击进入编辑；点击其它位置则先结束筛选编辑（文本已实时生效）。
+		if (IsOnFilterBox(x, y))
+		{
+			// 右侧 ✕：**抬起**时才清空（不退出编辑态，便于继续输入）；
+			// 按下后移开再松开视为放弃。
+			if (UiPointInRect(FilterClearRect(), fx, fy))
+			{
+				m_pendingFilterClear = true;
+				return true;
+			}
+			BeginFilterEdit();
+			return true;
+		}
+		if (m_filterEditing)
+		{
+			// 文本已实时生效，这里只需收起编辑态，随后继续处理本次点击。
+			EndFilterEdit();
+		}
+
+		// 滚动条拖拽优先于其它命中测试。
+		if (m_scrollBarVisible && UiPointInRect(m_scrollBarRect, fx, fy))
+		{
+			CancelScrollAnimation();
+			const gd::RectF thumb = ScrollThumbRect();
+			m_draggingScrollBar = true;
+			if (UiPointInRect(thumb, fx, fy))
+			{
+				m_scrollGrabOffset = y - static_cast<int>(thumb.Y);
+			}
+			else
+			{
+				m_scrollGrabOffset = static_cast<int>(thumb.Height * 0.5f);
+				const float travel = fy - m_scrollBarRect.Y - static_cast<float>(m_scrollGrabOffset);
+				const float usable = m_scrollBarRect.Height - thumb.Height;
+				if (usable > 0.0f)
+				{
+					const float progress = std::max(0.0f, std::min(1.0f, travel / usable));
+					m_scrollOffset = progress * (m_contentHeight - m_listRect.Height);
+					ClampScroll();
+				}
+			}
+			return true;
+		}
+
+		m_pendingLaneMenu = false;
+		m_pendingColorPicker = false;
+		m_pendingGainMenu = false;
+		m_pendingMirrorMenu = false;
+
+		// 点击当前输入框以外的位置时提交输入。
+		if (m_editField != StyleEditField::NONE &&
+		    !UiPointInRect(EditFieldRect(), fx, fy))
+		{
+			EndEdit(true);
+		}
+
+		// 全部显示/隐藏。
+		if (UiPointInRect(m_toggleAllRect, fx, fy))
+		{
+			m_tab->SetAllVisible(!AreAllSignalsVisible());
+			m_rowsDirty = true;
+			return true;
+		}
+
+		// 样式编辑区。
+		if (SignalStyle* style = StyleOf(SelectedRef()))
+		{
+			// ---- 顶层「目标」行：单击**不进入编辑**（用户明确要求），只做联动滚动 ----
+			// 双击改名由 `OnDoubleClick` 处理；这里单击即把列表滚动到目标信号，
+			// 便于在长列表（上百条信号的 MF4）里定位正在编辑的那条信号。
+			{
+				UpdateTargetRowGeometry();
+				const bool onName =
+				    m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy);
+				const bool onBadge =
+				    m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy);
+				if (onName || onBadge)
+				{
+					ScrollToSignalAnimated(SelectedRef());
+					return true;
+				}
+			}
+
+			int paletteCount = 0;
+			const std::uint32_t* palette = SignalPalette(paletteCount);
+			for (int index = 0; index < m_colorCount; ++index)
+			{
+				if (UiPointInRect(m_colorRects[static_cast<std::size_t>(index)], fx, fy))
+				{
+					style->color = palette[index % paletteCount];
+					// 联动：样式自定义区的任何交互都把列表滚动到正在编辑的目标信号。
+					ScrollToSignalAnimated(SelectedRef());
+					return true;
+				}
+			}
+			if (UiPointInRect(m_customChipRect, fx, fy))
+			{
+				// 先恢复到记忆的自定义颜色（即便随后收起浮窗也会生效），再在抬起时展开浮窗。
+				style->color = style->customColor;
+				m_pendingColorPicker = true;
+				ScrollToSignalAnimated(SelectedRef());
+				return true;
+			}
+			for (int index = 0; index < kModeOptionCount; ++index)
+			{
+				if (UiPointInRect(m_modeRects[static_cast<std::size_t>(index)], fx, fy))
+				{
+					style->mode = kModeOptions[index];
+					ScrollToSignalAnimated(SelectedRef());
+					return true;
+				}
+			}
+			if (UiPointInRect(SliderHitRect(m_opacityTrackRect, m_scale), fx, fy))
+			{
+				m_draggingOpacity = true;
+				ApplyOpacityFromX(fx);
+				ScrollToSignalAnimated(SelectedRef());
+				return true;
+			}
+			if (UiPointInRect(SliderHitRect(m_widthTrackRect, m_scale), fx, fy))
+			{
+				m_draggingWidth = true;
+				ApplyWidthFromX(fx);
+				ScrollToSignalAnimated(SelectedRef());
+				return true;
+			}
+			// 数值框的命中优先于滑块：两者几何重叠时要能进入输入状态。
+			if (UiPointInRect(m_widthValueRect, fx, fy))
+			{
+				ScrollToSignalAnimated(SelectedRef());
+				return BeginEdit(StyleEditField::WIDTH);
+			}
+			if (UiPointInRect(m_opacityValueRect, fx, fy))
+			{
+				ScrollToSignalAnimated(SelectedRef());
+				return BeginEdit(StyleEditField::OPACITY);
+			}
+			// 「调整」行：系数与镜像（按下只登记，**抬起**时才展开各自的二级面板，
+			// 与自定义颜色入口同一套交互）、绝对值（单击即切换）。
+			if (UiPointInRect(m_adjustRects[kAdjustGain], fx, fy))
+			{
+				m_pendingGainMenu = true;
+				ScrollToSignalAnimated(SelectedRef());
+				return true;
+			}
+			if (UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy))
+			{
+				m_pendingMirrorMenu = true;
+				ScrollToSignalAnimated(SelectedRef());
+				return true;
+			}
+			if (UiPointInRect(m_adjustRects[kAdjustAbsolute], fx, fy))
+			{
+				style->absolute = !style->absolute;
+				ScrollToSignalAnimated(SelectedRef());
+				return true;
+			}
+		}
+
+		// 列表行。
+		RowPart part = RowPart::NONE;
+		const int row = HitRow(x, y, part);
+		if (row < 0)
+		{
+			return false;
+		}
+
+		const ListRow item = m_rows[static_cast<std::size_t>(row)];
+
+		if (item.kind == RowKind::GROUP)
+		{
+			if (part == RowPart::CHECK)
+			{
+				const bool allVisible = m_tab->GroupAllVisible(item.groupIndex);
+				m_tab->SetGroupVisible(item.groupIndex, !allVisible);
+				m_rowsDirty = true;
+				return true;
+			}
+			if (part == RowPart::CLOSE)
+			{
+				// 关闭分组属于数据层操作，交由宿主窗口处理；但**抬起时才生效**，
+				// 这里只记录目标（按住后移开再松开视为放弃）。
+				m_pendingClosePart = RowPart::CLOSE;
+				m_pendingCloseRow = row;
+				return true;
+			}
+			// 折叠 / 展开分组：**只有**点到「折叠三角」或「组X」标签才生效
+			//（用户 2026-10-16 要求：点到分组名本体不折起）。
+			if (part != RowPart::DISCLOSURE && part != RowPart::GROUP_TITLE)
+			{
+				return true;
+			}
+			ToggleGroupFromRow(item.groupIndex, row);
+			return true;
+		}
+
+		const SignalRef ref{item.groupIndex, item.signalIndex};
+
+		// ✕：用户明确表示不再需要该信号 → 交由宿主从数据层移除并释放其采样内存。
+		// 必须在 SelectSignal 之前处理，避免选中一条即将被删除的信号；
+		// 且与其它 ✕ 一致，**抬起时才真正删除**（按住后移开再松开视为放弃）。
+		if (part == RowPart::REMOVE_SIGNAL)
+		{
+			m_pendingClosePart = RowPart::REMOVE_SIGNAL;
+			m_pendingCloseRow = row;
+			return true;
+		}
+
+		SelectSignal(ref);
+
+		if (part == RowPart::CHECK)
+		{
+			// 勾选/取消勾选会立即触发网格重新划分（取消后空网格随之消失）。
+			m_tab->ToggleVisible(ref);
+			m_rowsDirty = true;
+		}
+		else if (part == RowPart::LANE_BADGE)
+		{
+			// 在左键抬起时弹出，保证菜单不会随着按键松开而消失。
+			m_pendingLaneMenu = true;
+			m_pendingLaneRef = ref;
+		}
+		return true;
+	}
+
+	bool SignalPanel::OnLButtonUp(int x, int y)
+	{
+		bool changed = false;
+
+		// ---- 关闭类按钮（✕）：按下时记录目标，抬起时若指针仍在同一个 ✕ 上才执行 ----
+		if (m_pendingFilterClear)
+		{
+			m_pendingFilterClear = false;
+			const float fx = static_cast<float>(x);
+			const float fy = static_cast<float>(y);
+			const gd::RectF clearRect = FilterClearRect();
+			if (clearRect.Width > 0.0f && UiPointInRect(clearRect, fx, fy))
+			{
+				ClearFilter();
+				changed = true;
+			}
+		}
+		if (m_pendingClosePart != RowPart::NONE)
+		{
+			const RowPart pendingPart = m_pendingClosePart;
+			const int pendingRow = m_pendingCloseRow;
+			m_pendingClosePart = RowPart::NONE;
+			m_pendingCloseRow = -1;
+
+			RowPart part = RowPart::NONE;
+			const int row = HitRow(x, y, part);
+			if (row == pendingRow && part == pendingPart && row >= 0)
+			{
+				const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+				if (m_host != nullptr)
+				{
+					if (pendingPart == RowPart::CLOSE)
+					{
+						PostMessageW(m_host, WM_APP + 1, static_cast<WPARAM>(item.groupIndex), 0);
+					}
+					else
+					{
+						// wParam = 分组下标，lParam = 组内信号下标（见 Application 的消息处理）。
+						PostMessageW(m_host, WM_APP + 2, static_cast<WPARAM>(item.groupIndex),
+						             static_cast<LPARAM>(item.signalIndex));
+					}
+				}
+				changed = true;
+			}
+		}
+
+		if (m_draggingOpacity)
+		{
+			m_draggingOpacity = false;
+			changed = true;
+		}
+		if (m_draggingWidth)
+		{
+			m_draggingWidth = false;
+			changed = true;
+		}
+		if (m_draggingScrollBar)
+		{
+			m_draggingScrollBar = false;
+			changed = true;
+		}
+
+		if (m_pendingColorPicker)
+		{
+			m_pendingColorPicker = false;
+			const float fx = static_cast<float>(x);
+			const float fy = static_cast<float>(y);
+			if (UiPointInRect(m_customChipRect, fx, fy) && m_tab != nullptr)
+			{
+				if (const SignalStyle* style = StyleOf(SelectedRef()))
+				{
+					changed = OpenColorPickerPopup(*style) || changed;
+				}
+			}
+		}
+
+		// 「系数」/「镜像」：按下时只登记，抬起时指针仍在同一按钮上才展开二级面板
+		//（与自定义颜色入口一致：按住后移开再松开视为放弃）。
+		if (m_pendingGainMenu)
+		{
+			m_pendingGainMenu = false;
+			const float fx = static_cast<float>(x);
+			const float fy = static_cast<float>(y);
+			if (UiPointInRect(m_adjustRects[kAdjustGain], fx, fy) && m_tab != nullptr)
+			{
+				changed = OpenGainMenu() || changed;
+			}
+		}
+		if (m_pendingMirrorMenu)
+		{
+			m_pendingMirrorMenu = false;
+			const float fx = static_cast<float>(x);
+			const float fy = static_cast<float>(y);
+			if (UiPointInRect(m_adjustRects[kAdjustMirror], fx, fy) && m_tab != nullptr)
+			{
+				changed = OpenMirrorMenu() || changed;
+			}
+		}
+
+		if (m_pendingLaneMenu)
+		{
+			m_pendingLaneMenu = false;
+			RowPart part = RowPart::NONE;
+			const int row = HitRow(x, y, part);
+			if (row >= 0 && part == RowPart::LANE_BADGE)
+			{
+				const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+				const SignalRef ref{item.groupIndex, item.signalIndex};
+				if (ref == m_pendingLaneRef)
+				{
+					const gd::RectF badge = SignalBadgeRect(row);
+					OpenLaneMenu(ref, static_cast<int>(badge.X),
+					             static_cast<int>(badge.Y + badge.Height));
+					changed = true;
+				}
+			}
+		}
+
+		return changed;
+	}
+
+	bool SignalPanel::OnDoubleClick(int x, int y)
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+
+		const float fx = static_cast<float>(x);
+		const float fy = static_cast<float>(y);
+
+		// 样式区数值框：双击进入（或保持）输入状态。
+		if (UiPointInRect(m_widthValueRect, fx, fy))
+		{
+			return BeginEdit(StyleEditField::WIDTH);
+		}
+		if (UiPointInRect(m_opacityValueRect, fx, fy))
+		{
+			return BeginEdit(StyleEditField::OPACITY);
+		}
+
+		// 样式区顶部「目标」行：双击信号名（或它后面的 GX 标签）进入**改名**编辑态。
+		// ⚠️ 单击不进入编辑（见 `OnLButtonDown`），必须双击 —— 用户明确要求。
+		if (m_tab != nullptr && StyleOf(SelectedRef()) != nullptr)
+		{
+			UpdateTargetRowGeometry();
+			const bool onName =
+			    m_targetNameRect.Width > 0.0f && UiPointInRect(m_targetNameRect, fx, fy);
+			const bool onBadge =
+			    m_targetBadgeRect.Width > 0.0f && UiPointInRect(m_targetBadgeRect, fx, fy);
+			if (onName || onBadge)
+			{
+				// `row < 0` 表示编辑目标是"当前选中信号"（即目标行显示的信号）。
+				m_rowsDirty = true;
+				return BeginEdit(StyleEditField::SIGNAL_NAME, -1);
+			}
+		}
+
+		RowPart part = RowPart::NONE;
+		const int row = HitRow(x, y, part);
+		if (row < 0)
+		{
+			return false;
+		}
+
+		const ListRow item = m_rows[static_cast<std::size_t>(row)];
+
+		// 分组行：双击折叠三角用于折叠，双击名称区域进入重命名。
+		if (item.kind == RowKind::GROUP)
+		{
+			if (part == RowPart::DISCLOSURE)
+			{
+				// 与单击分组行同一入口：悬浮时先滚动就位再播放折起动画。
+				ToggleGroupFromRow(item.groupIndex, row);
+				return true;
+			}
+			if (part != RowPart::BODY)
+			{
+				return false;
+			}
+			// 重命名分组会改变列表行高度以外的展示内容，重建行缓存以保证文字刷新。
+			m_rowsDirty = true;
+			return BeginEdit(StyleEditField::GROUP_TITLE, row);
+		}
+
+		// 复选框、网格徽标与「移除信号」✕ 各自由单击处理，双击不再切换可见性／进入重命名。
+		if (part == RowPart::CHECK || part == RowPart::LANE_BADGE || part == RowPart::REMOVE_SIGNAL)
+		{
+			return false;
+		}
+
+		const SignalRef ref{item.groupIndex, item.signalIndex};
+		SelectSignal(ref);
+		m_rowsDirty = true;
+		return BeginEdit(StyleEditField::SIGNAL_NAME, row);
+	}
+
+	bool SignalPanel::OnRButtonDown(int x, int y)
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr)
+		{
+			return false;
+		}
+
+		RowPart part = RowPart::NONE;
+		const int row = HitRow(x, y, part);
+		if (row < 0)
+		{
+			return false;
+		}
+
+		const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+		if (item.kind == RowKind::GROUP)
+		{
+			OpenGroupMenu(item.groupIndex, x, y);
+			return true;
+		}
+
+		const SignalRef ref{item.groupIndex, item.signalIndex};
+		SelectSignal(ref);
+		OpenSignalMenu(ref, x, y);
+		return true;
+	}
+
+	bool SignalPanel::OnMouseWheel(int delta)
+	{
+		// 用户主动滚动 ⇒ 立即取消正在进行的目标信号滚动动画（否则两者会互相打架）。
+		CancelScrollAnimation();
+
+		if (m_dataSet == nullptr)
+		{
+			return false;
+		}
+
+		const float previous = m_scrollOffset;
+		m_scrollOffset -= static_cast<float>(delta) / 120.0f * 54.0f * m_scale;
+		ClampScroll();
+		return std::fabs(previous - m_scrollOffset) > 0.01f;
+	}
+
+	bool SignalPanel::OnMouseLeave()
+	{
+		const bool changed =
+		    (m_hoverRow >= 0) || (m_hoverStyle != StyleHit::NONE) || m_hoveredSignal.IsValid();
+		m_hoverRow = -1;
+		m_hoverPart = RowPart::NONE;
+		m_hoverStyle = StyleHit::NONE;
+		m_hoverStyleIndex = -1;
+		// 鼠标离开面板 → 取消绘图区的联动高亮（用户要求"移开鼠标时恢复"）。
+		m_hoveredSignal = SignalRef();
+		return changed;
+	}
+
+	void SignalPanel::OpenSignalMenu(const SignalRef& ref, int x, int y)
+	{
+		if (m_menu == nullptr || m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+
+		const SignalStyle* style = StyleOf(ref);
+		const SignalData* signal = m_dataSet->Resolve(ref);
+		if (style == nullptr || signal == nullptr)
+		{
+			return;
+		}
+
+		m_menuTargetSignal = ref;
+		m_menuTargetGroup = -1;
+
+		std::vector<MenuItem> items;
+
+		MenuItem header;
+		header.kind = MenuItemKind::HEADER;
+		header.label = signal->name;
+		items.push_back(header);
+
+		MenuItem toggle;
+		toggle.label = m_tab->IsVisible(ref) ? L"隐藏该信号" : L"显示该信号";
+		toggle.id = CMD_SIGNAL_TOGGLE;
+		items.push_back(toggle);
+
+		MenuItem solo;
+		solo.label = L"仅显示该信号";
+		solo.id = CMD_SIGNAL_SOLO;
+		items.push_back(solo);
+
+		MenuItem showAll;
+		showAll.label = L"显示全部信号";
+		showAll.id = CMD_SIGNAL_SHOW_ALL;
+		items.push_back(showAll);
+
+		MenuItem hideAll;
+		hideAll.label = L"隐藏全部信号";
+		hideAll.id = CMD_SIGNAL_HIDE_ALL;
+		items.push_back(hideAll);
+
+		MenuItem separator;
+		separator.kind = MenuItemKind::SEPARATOR;
+		items.push_back(separator);
+
+		int paletteCount = 0;
+		const std::uint32_t* palette = SignalPalette(paletteCount);
+		MenuItem colors;
+		colors.kind = MenuItemKind::SWATCHES;
+		colors.id = CMD_COLOR_BASE;
+		colors.swatchCount = std::min(paletteCount, 16);
+		colors.checkedSwatch = -1;
+		for (int index = 0; index < colors.swatchCount; ++index)
+		{
+			colors.swatches[index] = palette[index];
+			if (style->color == palette[index])
+			{
+				colors.checkedSwatch = index;
+			}
+		}
+		items.push_back(colors);
+
+		MenuItem modeHeader;
+		modeHeader.kind = MenuItemKind::HEADER;
+		modeHeader.label = L"样式";
+		items.push_back(modeHeader);
+
+		for (int index = 0; index < kModeOptionCount; ++index)
+		{
+			MenuItem mode;
+			mode.label = DrawModeName(kModeOptions[index]);
+			mode.id = CMD_MODE_BASE + index;
+			mode.checked = (style->mode == kModeOptions[index]);
+			items.push_back(mode);
+		}
+
+		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
+		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, x, y, items);
+	}
+
+	void SignalPanel::OpenGroupMenu(int groupIndex, int x, int y)
+	{
+		if (m_menu == nullptr || m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+
+		const SignalGroup* group = m_dataSet->GroupAt(groupIndex);
+		if (group == nullptr)
+		{
+			return;
+		}
+
+		m_menuTargetGroup = groupIndex;
+		m_menuTargetSignal = SignalRef();
+
+		std::vector<MenuItem> items;
+
+		MenuItem header;
+		header.kind = MenuItemKind::HEADER;
+		header.label = group->name;
+		items.push_back(header);
+
+		MenuItem showAll;
+		showAll.label = L"选中该分组全部信号";
+		showAll.id = CMD_GROUP_SHOW_ALL;
+		items.push_back(showAll);
+
+		MenuItem hideAll;
+		hideAll.label = L"取消该分组全部信号";
+		hideAll.id = CMD_GROUP_HIDE_ALL;
+		items.push_back(hideAll);
+
+		MenuItem separator;
+		separator.kind = MenuItemKind::SEPARATOR;
+		items.push_back(separator);
+
+		MenuItem remove;
+		remove.label = L"关闭该分组（从工作区移除）";
+		remove.id = CMD_GROUP_REMOVE;
+		items.push_back(remove);
+
+		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
+		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, x, y, items);
+	}
+
+	void SignalPanel::OpenLaneMenu(const SignalRef& ref, int x, int y)
+	{
+		if (m_menu == nullptr || m_tab == nullptr || m_dataSet == nullptr)
+		{
+			return;
+		}
+
+		const SignalData* signal = m_dataSet->Resolve(ref);
+		if (signal == nullptr)
+		{
+			return;
+		}
+
+		m_menuTargetSignal = ref;
+		m_menuTargetGroup = -1;
+
+		std::vector<MenuItem> items;
+
+		MenuItem header;
+		header.kind = MenuItemKind::HEADER;
+		header.label = L"所属网格";
+		items.push_back(header);
+
+		const std::vector<Lane>& lanes = m_tab->Lanes();
+		const int currentLane = m_tab->LaneOfSignal(ref);
+		for (std::size_t index = 0; index < lanes.size(); ++index)
+		{
+			MenuItem lane;
+			lane.label = L"网格 " + std::to_wstring(index + 1) + L"（" +
+			             std::to_wstring(lanes[index].signals.size()) + L" 条信号）";
+			lane.id = CMD_LANE_BASE + static_cast<int>(index);
+			lane.checked = (currentLane == static_cast<int>(index));
+			items.push_back(lane);
+		}
+
+		MenuItem separator;
+		separator.kind = MenuItemKind::SEPARATOR;
+		items.push_back(separator);
+
+		MenuItem create;
+		create.label = L"新建网格";
+		create.id = CMD_LANE_NEW;
+		items.push_back(create);
+
+		const gd::RectF bounds = (m_clientBounds.Width > 1.0f) ? m_clientBounds : m_area;
+		m_menu->Open(MenuScope::SIGNAL_PANEL, bounds, x, y, items);
+	}
+
+	bool SignalPanel::OnMenuCommand(const MenuResult& result)
+	{
+		if (m_tab == nullptr || m_dataSet == nullptr || !result.valid)
+		{
+			return false;
+		}
+
+		// 「系数」/「偏移」二级面板里的输入框提交：就地更新，面板保持打开
+		//（与网格 Y 轴上下限的菜单内联编辑一致），并把夹取后的真实值回写到输入框上。
+		if (result.editCommit)
+		{
+			SignalStyle* style = StyleOf(SelectedRef());
+			if (style != nullptr)
+			{
+				const std::wstring trimmed = Trim(result.editText);
+				wchar_t* stop = nullptr;
+				const double parsed =
+				    trimmed.empty() ? 0.0 : std::wcstod(trimmed.c_str(), &stop);
+				// 非法/空输入保持原值（只把真实值回写到输入框，避免用户看到错误的数字）。
+				const bool valid = !trimmed.empty() && stop != trimmed.c_str() && std::isfinite(parsed);
+				switch (result.id)
+				{
+				case CMD_GAIN_EDIT:
+				{
+					if (valid)
+					{
+						style->gain =
+						    static_cast<float>(std::max(-kGainLimit, std::min(parsed, kGainLimit)));
+					}
+					if (m_menu != nullptr)
+					{
+						m_menu->UpdateItemValue(CMD_GAIN_EDIT, FormatGainText(style->gain),
+						                        FormatNumberText(static_cast<double>(style->gain)));
+					}
+					return false;
+				}
+				case CMD_OFFSET_Y:
+				{
+					if (valid)
+					{
+						style->offsetY = static_cast<float>(
+						    std::max(-static_cast<double>(kGainLimit), std::min(parsed, kGainLimit)));
+					}
+					if (m_menu != nullptr)
+					{
+						m_menu->UpdateItemValue(
+						    CMD_OFFSET_Y, FormatSignedNumber(static_cast<double>(style->offsetY)),
+						    FormatNumberText(static_cast<double>(style->offsetY)));
+					}
+					return false;
+				}
+				case CMD_OFFSET_TIME:
+				{
+					if (valid)
+					{
+						style->offsetTime =
+						    std::max(-kGainLimit, std::min(parsed, kGainLimit));
+					}
+					if (m_menu != nullptr)
+					{
+						m_menu->UpdateItemValue(CMD_OFFSET_TIME,
+						                        FormatOffsetTimeText(style->offsetTime),
+						                        FormatNumberText(style->offsetTime));
+					}
+					return false;
+				}
+				default:
+					break;
+				}
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+		// 标题栏右侧的「还原」图标：系数重置为默认值 1（面板保持打开，输入框立即回显）。
+		if (result.id == CMD_GAIN_RESET)
+		{
+			if (SignalStyle* style = StyleOf(SelectedRef()))
+			{
+				style->gain = 1.0f;
+				if (m_menu != nullptr)
+				{
+					m_menu->UpdateItemValue(CMD_GAIN_EDIT, FormatGainText(style->gain),
+					                        FormatNumberText(static_cast<double>(style->gain)));
+				}
+			}
+			return false;
+		}
+
+		// 「偏移调整」的「还原」图标：Y 与时间偏移都恢复为默认值 0。
+		if (result.id == CMD_OFFSET_RESET)
+		{
+			if (SignalStyle* style = StyleOf(SelectedRef()))
+			{
+				style->offsetY = 0.0f;
+				style->offsetTime = 0.0;
+				if (m_menu != nullptr)
+				{
+					m_menu->UpdateItemValue(CMD_OFFSET_Y, FormatSignedNumber(0.0),
+					                        FormatNumberText(0.0));
+					m_menu->UpdateItemValue(CMD_OFFSET_TIME, FormatOffsetTimeText(0.0),
+					                        FormatNumberText(0.0));
+				}
+			}
+			return false;
+		}
+
+		// 「镜像」二级面板：两行带复选框的切换项（面板保持打开，勾选状态就地回写）。
+		if (result.id == CMD_MIRROR_HORIZONTAL || result.id == CMD_MIRROR_VERTICAL)
+		{
+			if (SignalStyle* style = StyleOf(SelectedRef()))
+			{
+				const bool horizontal = (result.id == CMD_MIRROR_HORIZONTAL);
+				bool& flag = horizontal ? style->mirrorHorizontal : style->mirrorVertical;
+				flag = !flag;
+				if (!horizontal)
+				{
+					// ⚠️ Y 偏移以**未镜像空间**为准：垂直镜像开关变化时同步取反偏移量，
+					// 使绘制等价于「先加上偏移再镜像」（用户明确要求）。
+					style->offsetY = -style->offsetY;
+					if (m_menu != nullptr)
+					{
+						m_menu->UpdateItemValue(
+						    CMD_OFFSET_Y, FormatSignedNumber(static_cast<double>(style->offsetY)),
+						    FormatNumberText(static_cast<double>(style->offsetY)));
+					}
+				}
+				if (m_menu != nullptr)
+				{
+					m_menu->UpdateItemLabel(result.id, horizontal ? L"水平镜像" : L"垂直镜像", flag, true);
+				}
+			}
+			return false;
+		}
+
+		bool needRelayout = false;
+
+		switch (result.id)
+		{
+		case CMD_SIGNAL_TOGGLE:
+			if (m_menuTargetSignal.IsValid())
+			{
+				m_tab->ToggleVisible(m_menuTargetSignal);
+				m_rowsDirty = true;
+				needRelayout = true;
+			}
+			break;
+		case CMD_SIGNAL_SOLO:
+			if (m_menuTargetSignal.IsValid())
+			{
+				m_tab->SoloSignal(m_menuTargetSignal);
+				m_rowsDirty = true;
+				needRelayout = true;
+			}
+			break;
+		case CMD_SIGNAL_SHOW_ALL:
+			m_tab->SetAllVisible(true);
+			m_rowsDirty = true;
+			needRelayout = true;
+			break;
+		case CMD_SIGNAL_HIDE_ALL:
+			m_tab->SetAllVisible(false);
+			m_rowsDirty = true;
+			needRelayout = true;
+			break;
+		case CMD_GROUP_SHOW_ALL:
+			if (m_menuTargetGroup >= 0)
+			{
+				m_tab->SetGroupVisible(m_menuTargetGroup, true);
+				m_rowsDirty = true;
+				needRelayout = true;
+			}
+			break;
+		case CMD_GROUP_HIDE_ALL:
+			if (m_menuTargetGroup >= 0)
+			{
+				m_tab->SetGroupVisible(m_menuTargetGroup, false);
+				m_rowsDirty = true;
+				needRelayout = true;
+			}
+			break;
+		case CMD_GROUP_REMOVE:
+			if (m_menuTargetGroup >= 0 && m_host != nullptr)
+			{
+				PostMessageW(m_host, WM_APP + 1, static_cast<WPARAM>(m_menuTargetGroup), 0);
+			}
+			break;
+		case CMD_LANE_NEW:
+			if (m_menuTargetSignal.IsValid())
+			{
+				m_tab->MoveSignalToLane(*m_dataSet, m_menuTargetSignal, -1);
+				m_rowsDirty = true;
+				needRelayout = true;
+			}
+			break;
+		default:
+			if (result.id >= CMD_LANE_BASE && result.id < CMD_LANE_NEW)
+			{
+				if (m_menuTargetSignal.IsValid())
+				{
+					m_tab->MoveSignalToLane(*m_dataSet, m_menuTargetSignal, result.id - CMD_LANE_BASE);
+					m_rowsDirty = true;
+					needRelayout = true;
+				}
+			}
+			else if (result.id == CMD_COLOR_BASE && result.swatchIndex >= 0)
+			{
+				if (SignalStyle* style = StyleOf(m_menuTargetSignal))
+				{
+					int paletteCount = 0;
+					const std::uint32_t* palette = SignalPalette(paletteCount);
+					style->color = palette[result.swatchIndex % std::max(1, paletteCount)];
+				}
+			}
+			else if (result.id >= CMD_MODE_BASE && result.id < CMD_MODE_BASE + kModeOptionCount)
+			{
+				if (SignalStyle* style = StyleOf(m_menuTargetSignal))
+				{
+					style->mode = kModeOptions[result.id - CMD_MODE_BASE];
+				}
+			}
+			break;
+		}
+
+		return needRelayout;
+	}
+
+} // namespace jdi
+
diff --git a/Components/SignalPanel/Src/SignalPanelInternal.hpp b/Components/SignalPanel/Src/SignalPanelInternal.hpp
new file mode 100644
index 0000000..204b2fb
--- /dev/null
+++ b/Components/SignalPanel/Src/SignalPanelInternal.hpp
@@ -0,0 +1,316 @@
+#ifndef __SIGNALPANEL_INTERNAL_HPP__
+#define __SIGNALPANEL_INTERNAL_HPP__
+
+// SignalPanel 组件内部共享的常量与工具函数（私有头，仅本组件的 .cpp 使用）。
+//
+// 本组件的实现按功能拆成多个协作文件，它们共用这一份内部工具集。
+//
+// ⚠️ 为让多个翻译单元都能使用，原匿名命名空间改为**具名**命名空间 `spdetail`，
+//    并把其中每个函数与常量标为 `inline` —— 单一定义、单一副本，不会产生代码重复。
+//    各实现文件在包含本头之后用 `using namespace spdetail;` 引入这些工具，
+//    因此函数体里原有的非限定调用一行都不用改。
+
+#include <windows.h>
+#include <objidl.h>
+#include <gdiplus.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "SignalPanel.hpp"
+#include "UiControls.hpp"
+#include "Utf8Util.hpp"
+
+namespace jdi
+{
+
+	namespace spdetail
+	{
+	/**
+	 * @brief SignalPanel 内部工具集（常量与自由函数）。
+	 *
+	 * 全部符号都是 `inline` ⇒ 多个翻译单元共用同一个定义：既不重复符号，也不产生多份代码。
+	 * 不要把它们移回匿名命名空间（那样每个 .cpp 都会各自复制一份）。
+	 */
+		inline const float kHeaderHeight = 38.0f;		/**< 标题区高度（逻辑像素）。 */
+		inline const float kGroupRowHeight = 30.0f;		/**< 分组行高。 */
+		inline const float kSignalRowHeight = 27.0f;	/**< 信号行高。 */
+		inline const float kPadding = 12.0f;			/**< 通用内边距。 */
+		inline const float kCheckSize = 15.0f;			/**< 复选框尺寸。 */
+		inline const float kSwatchSize = 12.0f;		/**< 信号行颜色小方块尺寸。 */
+		inline const float kBadgeWidth = 30.0f;		/**< 网格徽标宽度。 */
+		inline const float kBadgeHeight = 17.0f;		/**< 网格徽标高度。 */
+		inline const float kCorner = 4.0f;				/**< 通用圆角半径。 */
+		inline const float kDisclosureWidth = 16.0f;	/**< 折叠三角占位宽度。 */
+		inline const float kIndent = 14.0f;			/**< 信号行相对分组行的缩进。 */
+		inline const float kScrollBarThickness = 8.0f;	/**< 滚动条宽度。 */
+		inline const float kCloseButtonSize = 18.0f;	/**< 行尾关闭（✕）按钮尺寸（分组行与信号行共用）。 */
+		inline const float kGroupSeparatorGap = 7.0f;	/**< 分组标签与分隔线/名称的间距。 */
+		inline const float kGroupSeparatorWidth = 1.0f;	/**< 分组标签右侧分隔线宽度。 */
+		inline const float kFilterHeight = 26.0f;		/**< 「筛选信号」输入框高度。 */
+		inline const float kFilterPadV = 5.0f;			/**< 筛选框上下留白。 */
+		inline const float kFilterTextPad = 4.0f;		/**< 筛选框内文字/输入框相对外框的内缩（四边一致）。 */
+		inline const float kRowTailGap = 6.0f;			/**< 网格徽标与行尾 ✕ 之间的间距。 */
+
+		/**
+		 * @brief 大小写无关的通配符匹配（`*` 匹配任意长度的任意字符序列）。
+		 * @param [IN] text 待匹配文本。
+		 * @param [IN] pattern 模式（可含多个 `*`）。
+		 * @return 匹配返回 true。
+		 */
+		inline bool WildcardMatchNoCase(const std::wstring& text, const std::wstring& pattern)
+		{
+			const auto fold = [](wchar_t character) -> wchar_t
+			{
+				// 仅对基本拉丁字母做大小写折叠（中文等其它字符原样比较）。
+				if (character >= L'A' && character <= L'Z')
+				{
+					return static_cast<wchar_t>(character - L'A' + L'a');
+				}
+				return character;
+			};
+
+			// 经典双指针回溯：`star` 记录最近一个 `*` 的位置，`resume` 记录当时尝试的文本位置。
+			std::size_t t = 0;
+			std::size_t p = 0;
+			std::size_t star = std::wstring::npos;
+			std::size_t resume = 0;
+
+			while (t < text.size())
+			{
+				if (p < pattern.size() && pattern[p] == L'*')
+				{
+					star = p;
+					resume = t;
+					++p;
+				}
+				else if (p < pattern.size() && fold(pattern[p]) == fold(text[t]))
+				{
+					++p;
+					++t;
+				}
+				else if (star != std::wstring::npos)
+				{
+					p = star + 1;
+					++resume;
+					t = resume;
+				}
+				else
+				{
+					return false;
+				}
+			}
+
+			// 文本已耗尽：模式剩余部分必须全是 `*`。
+			while (p < pattern.size() && pattern[p] == L'*')
+			{
+				++p;
+			}
+			return p == pattern.size();
+		}
+
+		// 样式编辑区：固定五行网格（颜色 / 样式 / 调整 / 线宽 / 透明度），
+		// 行高、间距与内容列宽度统一，保证面板宽度变化时各行控件始终对齐，且不会被无限制拉伸。
+		inline const float kStylePadH = 12.0f;			/**< 样式区左右内边距。 */
+		inline const float kStylePadV = 12.0f;			/**< 样式区上下内边距。 */
+		inline const float kStyleRowHeight = 26.0f;	/**< 样式区单行高度。 */
+		inline const float kStyleRowGap = 10.0f;		/**< 样式区行间距。 */
+		inline const float kStyleLabelWidth = 44.0f;	/**< 样式行标签列宽度。 */
+		inline const float kStyleLabelGap = 8.0f;		/**< 标签列与内容列间距。 */
+		inline const float kStyleRowCount = 5.0f;		/**< 样式区固定行数（不含顶部「目标」行）。 */
+		inline const float kStyleTargetRowHeight = 26.0f;	/**< 样式区顶部「目标」行高度（与其它行一致）。 */
+		/**
+		 * @brief GX 网格标签与信号名之间的间距（逻辑像素）。
+		 *
+		 * 用户要求：目标信号已绘制到网格时，在信号名**后方**显示它所在的 GX 标签。
+		 */
+		inline const float kTargetBadgeGap = 8.0f;
+		/**
+		 * @brief 平滑滚动的动画时长（毫秒）。
+		 *
+		 * 距离越远时长越长（但不会无限增长），靠近时由 ease-out 自动变慢 —— 用户要求
+		 * “越远时越快、靠近时变慢”且“整个动画过程不要太久”。
+		 */
+		inline const float kScrollAnimMinMs = 130.0f;		/**< 最短时长（短距离）。 */
+		inline const float kScrollAnimMaxMs = 300.0f;		/**< 最长时长（长距离）。 */
+		inline const float kScrollAnimMsPerPixel = 0.35f;	/**< 每像素距离增加的时长。 */
+
+		// ---- 分组折起/展开动画（用户 2026-10-16 要求）----
+		// 整组信号作为一个**刚性整体**向上平移（收起）/ 向下平移（展开），
+		// 越过组名下边界的部分被裁掉 —— 即“抽拉卷尺”观感：元素相对位置不变。
+		// 总时长 = clamp(基础 + 行数×每行, 下限, 上限)，保证“整个动画过程不会太久”。
+		inline const float kGroupAnimBaseMs = 115.0f;		/**< 动画基础时长。 */
+		inline const float kGroupAnimPerRowMs = 6.0f;		/**< 每多一行增加的时长。 */
+		inline const float kGroupAnimMinMs = 150.0f;		/**< 最短时长。 */
+		inline const float kGroupAnimMaxMs = 320.0f;		/**< 最长时长。 */
+		inline const float kStyleContentMax = 260.0f;	/**< 内容列最大宽度（再拉宽面板也不再延伸）。 */
+		inline const float kSwatchEdge = 18.0f;		/**< 颜色色块边长上限（含自定义颜色入口）。 */
+		inline const float kSwatchMin = 11.0f;			/**< 颜色色块边长下限。 */
+		inline const float kSwatchGap = 4.0f;			/**< 颜色色块最小间距。 */
+		inline const float kSwatchMaxGap = 10.0f;		/**< 颜色色块最大间距（用于铺满内容列）。 */
+		inline const float kSliderValueWidth = 52.0f;	/**< 滑块行数值文本宽度（透明度与线宽一致）。 */
+		inline const float kSliderValueGap = 8.0f;		/**< 滑块轨道与数值文本间距。 */
+		inline const float kTrackHeight = 6.0f;		/**< 滑块轨道高度。 */
+		inline const float kAdjustGap = 6.0f;			/**< 「调整」行三个按钮之间的间距。 */
+		inline const float kAdjustMenuGap = 4.0f;		/**< 「系数/偏移」「镜像」二级面板与按钮左上角的额外间距。 */
+
+		/** 「调整」行的按钮下标（与 `m_adjustRects` 同序）。 */
+		inline const int kAdjustGain = 0;		/**< 系数（点击展开系数二级面板）。 */
+		inline const int kAdjustMirror = 1;	/**< 镜像（点击展开镜像二级面板）。 */
+		inline const int kAdjustAbsolute = 2;	/**< 绝对值。 */
+		inline const int kAdjustCount = 3;		/**< 按钮数量。 */
+
+		// 线宽范围与「稀疏信号默认线宽」共用 `DataModel.hpp` 的常量，避免两处漂移
+		//（稀疏信号初始化时用的最大线宽必须与这里滑块的上限完全一致）。
+		inline const float kWidthMin = kSignalLineWidthMin;	/**< 允许的最小线宽（px）。 */
+		inline const float kWidthMax = kSignalLineWidthMax;	/**< 允许的最大线宽（px）。 */
+
+		/** @brief 系数调整允许的绝对值上限（防止输入极端值把波形完全挤出可视区）。 */
+		inline const double kGainLimit = 10000.0;
+
+		/** @brief 系数为默认值 1（不做任何缩放）时按钮显示为未启用样式。 */
+		inline bool GainIsDefault(float gain)
+		{
+			return std::fabs(gain - 1.0f) < 1.0e-6f;
+		}
+
+		/** @brief 可选绘制样式顺序（不含阶梯方式）。 */
+		inline const DrawMode kModeOptions[] = {DrawMode::LINE, DrawMode::SCATTER, DrawMode::LINE_SCATTER};
+		inline const int kModeOptionCount = static_cast<int>(sizeof(kModeOptions) / sizeof(kModeOptions[0]));
+
+		/**
+		 * @brief 计算滑块的便捷命中矩形（比轨道略大，便于拖拽）。
+		 * @param [IN] track 轨道矩形。
+		 * @param [IN] scale 缩放比例。
+		 * @return 命中矩形。
+		 */
+		inline gd::RectF SliderHitRect(const gd::RectF& track, float scale)
+		{
+			return gd::RectF(track.X - 6.0f * scale, track.Y - 9.0f * scale, track.Width + 12.0f * scale,
+			                 track.Height + 18.0f * scale);
+		}
+
+		/**
+		 * @brief 判断颜色是否偏暗（用于在色块之上选择可读的图标颜色）。
+		 * @param [IN] color 0xAARRGGBB 颜色值。
+		 * @return 相对亮度低于阈值返回 true。
+		 */
+		inline bool IsDarkColor(std::uint32_t color)
+		{
+			const double r = static_cast<double>((color >> 16) & 0xFFu);
+			const double g = static_cast<double>((color >> 8) & 0xFFu);
+			const double b = static_cast<double>(color & 0xFFu);
+			return (0.299 * r + 0.587 * g + 0.114 * b) < 140.0;
+		}
+
+		/**
+		 * @brief 将数值限制到合法区间。
+		 * @param [IN] value 输入值。
+		 * @param [IN] low 下限。
+		 * @param [IN] high 上限。
+		 * @return 限制后的数值。
+		 */
+		inline float ClampFloat(float value, float low, float high)
+		{
+			return (value < low) ? low : ((value > high) ? high : value);
+		}
+
+		/**
+		 * @brief 数值文本：**至少两位小数**，精度更高时按实际精度显示。
+		 *
+		 * 例：`1` → `1.00`、`2.5` → `2.50`、`0.125` → `0.125`、`1.2345678` → `1.2345678`。
+		 * 实现：从 2 位小数开始递增位数，直到文本能精确表示该数值
+		 *（容差 1e-7 相对量，与 float 精度匹配）。
+		 *
+		 * @param [IN] value 数值。
+		 * @return 显示文本。
+		 */
+		inline std::wstring FormatNumberText(double value)
+		{
+			const double tolerance = std::max(1.0e-12, std::fabs(value) * 1.0e-7);
+			for (int decimals = 2; decimals <= 9; ++decimals)
+			{
+				const std::wstring text = jdi::FormatNumber(value, decimals);
+				const double parsed = std::wcstod(text.c_str(), nullptr);
+				if (std::fabs(parsed - value) <= tolerance)
+				{
+					return text;
+				}
+			}
+			return jdi::FormatNumber(value, 9);
+		}
+
+		/**
+		 * @brief 带正负符号的数值文本（非编辑态显示偏移量时使用）。
+		 *
+		 * 规则（用户明确要求）：**正数带 `+`、负数带 `-`、0 不带任何符号**。
+		 * （旧实现 0 也会显示 `+0.00`，用户报告“偏移调整的 Y 轴输入框默认值为 0 时也显示了正号，这不正确”。）
+		 * @param [IN] value 数值。
+		 * @return 形如 `+1.50` / `-0.25` / `0.00` 的文本。
+		 */
+		inline std::wstring FormatSignedNumber(double value)
+		{
+			const std::wstring text = FormatNumberText(std::fabs(value));
+			if (value > 0.0)
+			{
+				return L"+" + text;
+			}
+			if (value < 0.0)
+			{
+				return L"-" + text;
+			}
+			return text;	// 0：不带符号
+		}
+
+		/**
+		 * @brief 把系数格式化为界面文本（与偏移量同一套两位小数规则 + 显式正号）。
+		 *
+		 * 规则（用户明确要求）：“系数调整”输入框**非编辑态**显示时，非 0 正值前面加 `+`，
+		 * 负值按原样显示负号，0 不带符号。编辑态仍用不带符号的纯数值（见 `FormatNumberText`）。
+		 * @param [IN] gain 系数。
+		 * @return 显示文本。
+		 */
+		inline std::wstring FormatGainText(float gain)
+		{
+			const double value = static_cast<double>(gain);
+			if (value > 0.0)
+			{
+				return L"+" + FormatNumberText(value);
+			}
+			return FormatNumberText(value);
+		}
+
+		/**
+		 * @brief 「时间轴」偏移的非编辑态显示文本（`Δt：` + 带正负号的复合单位间隔）。
+		 *
+		 * 规则（用户明确要求）：在 `Δt：` 冒号后的时间显示值**前面加上正负号**，
+		 * 只有值为 0 时不显示符号。示例：`Δt：+1h 1min 2s` / `Δt：-5s 60ms` / `Δt：0s`。
+		 *（`FormatDurationCompound` 内部取绝对值，因此符号由这里补上。）
+		 * @param [IN] seconds 时间偏移（秒，可为负）。
+		 * @return 显示文本。
+		 */
+		inline std::wstring FormatOffsetTimeText(double seconds)
+		{
+			if (seconds > 0.0)
+			{
+				return L"Δt：+" + FormatDurationCompound(seconds);
+			}
+			if (seconds < 0.0)
+			{
+				return L"Δt：-" + FormatDurationCompound(seconds);
+			}
+			return L"Δt：" + FormatDurationCompound(0.0);
+		}
+	} // namespace spdetail
+
+	using namespace spdetail;
+
+} // namespace jdi
+
+#endif // __SIGNALPANEL_INTERNAL_HPP__
+
diff --git a/Components/SignalPanel/Src/SignalPanelPaint.cpp b/Components/SignalPanel/Src/SignalPanelPaint.cpp
new file mode 100644
index 0000000..9b5346d
--- /dev/null
+++ b/Components/SignalPanel/Src/SignalPanelPaint.cpp
@@ -0,0 +1,697 @@
+// SignalPanel 实现分片 —— 本文件只包含 SignalPanel 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 SignalPanelInternal.hpp（命名空间 `spdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "SignalPanelInternal.hpp"
+
+namespace jdi
+{
+
+	void SignalPanel::PaintStickyGroupRow(gd::Graphics& g, int row)
+	{
+		if (row < 0 || row >= static_cast<int>(m_rows.size()) ||
+		    m_rows[static_cast<std::size_t>(row)].kind != RowKind::GROUP)
+		{
+			return;
+		}
+
+		const int rowCount = static_cast<int>(m_rows.size());
+		const float height = m_rows[static_cast<std::size_t>(row)].height;
+		const float naturalY = RowRect(row).Y;
+		const float stickyY = StickyGroupRowTop(row, rowCount);
+		if (stickyY + height <= m_listRect.Y + 0.5f)
+		{
+			return;		// 已经整块滑出列表上边界
+		}
+
+		m_rowYOverrideActive = true;
+		m_rowYOverrideY = stickyY;
+		// 悬浮行必须是不透明的，否则下面的信号行会与组名叠在一起看不清；
+		// `FillRowRect` 会把矩形夹到列表矩形（GDI 填充不受 GDI+ 裁剪约束）。
+		SetRowClip(gd::RectF(m_listRect.X, stickyY, m_listRect.Width, height));
+		FillRowRect(g, gd::RectF(m_listRect.X, stickyY, m_listRect.Width, height), m_theme->panelBg);
+		PaintGroupRow(g, row);
+		ClearRowClip();
+		// 只有真正“浮”在其它行之上时才补一条底部边界线（否则会与正常绘制有差异）。
+		if (stickyY > naturalY + 0.5f)
+		{
+			UiDrawLine(g, m_listRect.X, stickyY + height - 0.5f, m_listRect.X + m_listRect.Width,
+			           stickyY + height - 0.5f, m_theme->border, 1.0f);
+		}
+		m_rowYOverrideActive = false;
+	}
+
+	void SignalPanel::Paint(gd::Graphics& g)
+	{
+		if (m_theme == nullptr || m_fonts == nullptr)
+		{
+			return;
+		}
+
+		EnsureRows();
+		UiFillRect(g, m_area, m_theme->panelBg);
+
+		// 标题区。
+		{
+			std::wstring title = L"信号";
+			if (m_dataSet != nullptr && m_tab != nullptr)
+			{
+				title += L" · " + std::to_wstring(m_tab->VisibleCount()) + L"/" +
+				         std::to_wstring(TotalSignalCount()) + L" 已选";
+			}
+
+			gd::RectF titleRect(m_headerRect.X + kPadding * m_scale, m_headerRect.Y,
+			                    std::max(20.0f, m_headerRect.Width - kPadding * 2.0f * m_scale -
+			                                        m_toggleAllRect.Width - 8.0f * m_scale),
+			                    m_headerRect.Height);
+			UiText(g, UiEllipsize(title, m_fonts->uiBold, titleRect.Width), m_fonts->uiBold, titleRect,
+			       m_theme->textStrong, TextAlign::LEFT);
+
+			const bool allVisible = AreAllSignalsVisible();
+			const std::wstring toggleLabel = allVisible ? L"全部隐藏" : L"全部显示";
+			const bool toggleHover = (m_hoverStyle == StyleHit::TOGGLE_ALL);
+			if (toggleHover)
+			{
+				UiFillRoundRect(g, m_toggleAllRect, kCorner * m_scale, m_theme->hover);
+			}
+			UiDrawRoundRect(g, m_toggleAllRect, kCorner * m_scale, m_theme->border, 1.0f);
+			const bool enabled = (m_dataSet != nullptr && !m_dataSet->Empty());
+			UiText(g, toggleLabel, m_fonts->uiSmall, m_toggleAllRect,
+			       enabled ? m_theme->text : m_theme->textMuted, TextAlign::CENTER);
+		}
+
+		// 「筛选信号」输入框：未输入内容时显示占位提示，单击进入编辑，输入实时过滤下方列表。
+		{
+			UiFillRoundRect(g, m_filterRect, kCorner * m_scale, m_theme->cardBg);
+			UiDrawRoundRect(g, m_filterRect, kCorner * m_scale,
+			                m_filterEditing ? m_theme->accent : m_theme->border,
+			                m_filterEditing ? 1.6f : 1.0f);
+
+			const float pad = kFilterTextPad * m_scale;
+			const gd::RectF clearRect = FilterClearRect();
+			// 有输入内容时在右侧留出 ✕ 的位置，文本不会压到按钮上。
+			const float textRight = (clearRect.Width > 0.0f) ? clearRect.X : (m_filterRect.X + m_filterRect.Width);
+			const float textWidth = std::max(8.0f, textRight - pad - (m_filterRect.X + pad));
+			const gd::RectF textRect(m_filterRect.X + pad, m_filterRect.Y, textWidth,
+			                         m_filterRect.Height);
+
+			if (m_filterEditing)
+			{
+				// 外框（m_filterRect）已经画好了底板与强调色边框，这里只叠加文本内容。
+				// 若改用 UiDrawEditField，会在外框内部再套一个带边框的圆角框，
+				// 空内容时只剩一圈内框十分突兀（用户明确要求去掉这层"内圈"）。
+				gd::RectF fieldRect = FilterFieldRect();
+				fieldRect.Width = std::max(8.0f, textWidth + pad);
+				UiDrawEditFieldContent(g, fieldRect, m_filterEdit, m_fonts->uiSmall, m_scale);
+			}
+			else if (m_filterText.empty())
+			{
+				UiText(g, L"筛选信号", m_fonts->uiSmall, textRect, m_theme->textMuted, TextAlign::LEFT);
+			}
+			else
+			{
+				UiText(g, UiEllipsize(m_filterText, m_fonts->uiSmall, textWidth), m_fonts->uiSmall,
+				       textRect, m_theme->text, TextAlign::LEFT);
+			}
+
+			// 清空按钮 ✕：仅在筛选框有内容时出现，悬停高亮（鼠标光标保持箭头）。
+			if (clearRect.Width > 0.0f)
+			{
+				const bool clearHot = (m_hoverStyle == StyleHit::FILTER_CLEAR);
+				if (clearHot)
+				{
+					UiFillRoundRect(g, clearRect, 3.0f * m_scale, WithAlpha(m_theme->danger, 0x33));
+				}
+				const std::uint32_t crossColor = clearHot ? m_theme->danger : m_theme->textMuted;
+				const float crossPad = clearRect.Width * 0.28f;
+				UiDrawLine(g, clearRect.X + crossPad, clearRect.Y + crossPad,
+				           clearRect.X + clearRect.Width - crossPad,
+				           clearRect.Y + clearRect.Height - crossPad, crossColor, 1.5f * m_scale);
+				UiDrawLine(g, clearRect.X + clearRect.Width - crossPad, clearRect.Y + crossPad,
+				           clearRect.X + crossPad, clearRect.Y + clearRect.Height - crossPad, crossColor,
+				           1.5f * m_scale);
+			}
+		}
+
+		// 列表区。
+		{
+			const int saveState = g.Save();
+			g.SetClip(gd::RectF(m_listRect.X, m_listRect.Y, m_listRect.Width, m_listRect.Height));
+
+			if (m_dataSet == nullptr || m_dataSet->Empty())
+			{
+				UiText(g, L"尚未加载数据，请打开数据文件", m_fonts->uiSmall, m_listRect, m_theme->textMuted,
+				       TextAlign::CENTER);
+			}
+			else if (m_rows.empty() && !m_filterText.empty())
+			{
+				// 筛选结果为空：明确提示"无匹配"，而不是让人误以为数据丢失。
+				UiText(g, L"无匹配的筛选信号", m_fonts->uiSmall, m_listRect, m_theme->textMuted,
+				       TextAlign::CENTER);
+			}
+			else
+			{
+				const int rowCount = static_cast<int>(m_rows.size());
+				// 先定出要「悬浮」的分组行（若有）：常规循环跳过它，最后统一钉在列表顶部绘制，
+				// 否则它会先被画一次在滚动位置上、又被画一次在顶部（视觉上重叠两份）。
+				const int stickyRow = StickyGroupRowIndex(rowCount);
+				for (int row = 0; row < rowCount; ++row)
+				{
+					if (row == stickyRow)
+					{
+						continue;
+					}
+					const gd::RectF rect = RowRect(row);
+					if (rect.Y + rect.Height < m_listRect.Y || rect.Y > m_listRect.Y + m_listRect.Height)
+					{
+						continue;
+					}
+
+					// 折起/展开动画：信号行整组向上平移，越过组名下边界的部分要“消失（藏进组名栏）”。
+					// 已经完全越过的行整行跳过（省一次绘制），部分越过的行把裁剪上边界抬到组名下边界；
+					// ⚠️ 此时还必须把 **GDI+ 裁剪**也收紧到同一条线 —— 行内的色块 / 复选框 / 网格徽标
+					// 走的是 GDI+ 绘制（只受 `SetClip` 约束），不收紧就会画到组名栏上面去。
+					const int rowSave = g.Save();
+					SetRowClip(rect);
+					const float hideTop = AnimationHideTopForRow(row, stickyRow);
+					if (hideTop > rect.Y + 0.5f)
+					{
+						if (rect.Y + rect.Height <= hideTop + 0.5f)
+						{
+							g.Restore(rowSave);
+							ClearRowClip();
+							continue;
+						}
+						ClampRowClipTop(hideTop);
+						g.SetClip(m_rowClipRect, gd::CombineModeIntersect);
+					}
+
+					if (m_rows[static_cast<std::size_t>(row)].kind == RowKind::GROUP)
+					{
+						PaintGroupRow(g, row);
+					}
+					else
+					{
+						PaintSignalRow(g, row);
+					}
+					g.Restore(rowSave);
+					ClearRowClip();
+				}
+
+				PaintStickyGroupRow(g, stickyRow);
+			}
+
+			g.Restore(saveState);
+		}
+
+		PaintScrollBar(g);
+		PaintStyleSection(g);
+
+		// 分隔线。
+		UiDrawLine(g, m_area.X + m_area.Width - 1.0f, m_area.Y, m_area.X + m_area.Width - 1.0f,
+		           m_area.Y + m_area.Height, m_theme->border, 1.0f);
+		UiDrawLine(g, m_headerRect.X, m_headerRect.Y + m_headerRect.Height - 1.0f,
+		           m_headerRect.X + m_headerRect.Width, m_headerRect.Y + m_headerRect.Height - 1.0f,
+		           m_theme->border, 1.0f);
+		if (m_styleRect.Height > 0.0f)
+		{
+			UiDrawLine(g, m_styleRect.X, m_styleRect.Y, m_styleRect.X + m_styleRect.Width, m_styleRect.Y,
+			           m_theme->border, 1.0f);
+		}
+	}
+
+	void SignalPanel::PaintRowText(gd::Graphics& g, const std::wstring& text, HFONT font,
+	                               const gd::RectF& rect, std::uint32_t argb, TextAlign align)
+	{
+		// 行内文本必须显式裁剪：GDI 文本不遵循 GDI+ 的 `SetClip`，
+		// 否则列表滚动时顶部那些“部分可见”的行会把组名/信号名画到筛选框上。
+		// 另外，分组折起动画期间行高会连续缩小 —— 此时必须裁到**本行矩形**内，
+		// 否则垂直居中的文字会溢出到相邻行上。
+		UiTextClipped(g, text, font, rect, argb, align, m_rowClipActive ? m_rowClipRect : m_listRect);
+	}
+
+	void SignalPanel::FillRowRect(gd::Graphics& g, const gd::RectF& rect, std::uint32_t argb)
+	{
+		// 夹取而不是裁剪：纯色填充下两者等价，而夹取对 `UiFillRect` 的 GDI 快路径同样有效
+		//（大面积不透明矩形会改走 GDI `FillRect`，它同样不受 GDI+ 裁剪约束）。
+		gd::RectF clipped = rect;
+		clipped.Intersect(m_rowClipActive ? m_rowClipRect : m_listRect);
+		if (clipped.Width <= 0.0f || clipped.Height <= 0.0f)
+		{
+			return;
+		}
+		UiFillRect(g, clipped, argb);
+	}
+
+	void SignalPanel::PaintGroupRow(gd::Graphics& g, int row)
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr || row < 0 || row >= static_cast<int>(m_rows.size()))
+		{
+			return;
+		}
+
+		const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+		const SignalGroup* group = m_dataSet->GroupAt(item.groupIndex);
+		if (group == nullptr)
+		{
+			return;
+		}
+
+		const gd::RectF rect = RowRect(row);
+		const bool hovered = (m_hoverRow == row);
+		if (hovered)
+		{
+			FillRowRect(g, rect, m_theme->hover);
+		}
+		FillRowRect(g, gd::RectF(rect.X, rect.Y, 2.0f * m_scale, rect.Height),
+		            WithAlpha(m_theme->borderStrong, 0x90));
+
+		const float baseX = rect.X + kPadding * m_scale;
+		const float centerY = rect.Y + rect.Height * 0.5f;
+		const bool collapsed = IsGroupCollapsed(item.groupIndex);
+
+		// 折叠三角。
+		{
+			const float cx = baseX + kDisclosureWidth * m_scale * 0.5f;
+			const std::uint32_t color =
+			    (hovered && m_hoverPart == RowPart::DISCLOSURE) ? m_theme->accent : m_theme->text;
+			UiDrawTriangleIcon(g, gd::RectF(cx - 6.0f * m_scale, centerY - 6.0f * m_scale, 12.0f * m_scale,
+			                                12.0f * m_scale),
+			                   color, collapsed ? IconDirection::RIGHT : IconDirection::DOWN);
+		}
+
+		// 分组复选框（三态：全选 / 部分 / 未选）。
+		const gd::RectF checkRect(baseX + kDisclosureWidth * m_scale, centerY - kCheckSize * m_scale * 0.5f,
+		                          kCheckSize * m_scale, kCheckSize * m_scale);
+		const bool allVisible = m_tab->GroupAllVisible(item.groupIndex);
+		const bool anyVisible = m_tab->GroupHasVisible(item.groupIndex);
+		UiDrawCheckBox(g, checkRect, allVisible ? 1 : (anyVisible ? 2 : 0), 3.0f * m_scale);
+
+		const gd::RectF closeRect = GroupCloseRect(row);
+
+		// 分组标题：左侧为“组X”标签，右侧以绘制的竖线分隔分组名（不使用字符），再显示可重命名的名称。
+		const std::wstring groupLabel = GroupLabelText(item.groupIndex);
+		// 项数文本与 `RowNameRect`（组名编辑框）共用同一来源，保证名称宽度与绘制不漂移。
+		const std::wstring stats = GroupStatsText(row);
+		const float groupWidth = GroupLabelWidth(row);
+		const float statsWidth = UiMeasureTextWidth(m_fonts->uiSmall, stats);
+		const float statsRight = closeRect.X - 6.0f * m_scale;
+		const float nameLeft = checkRect.X + checkRect.Width + 8.0f * m_scale;
+		const float nameAreaLeft =
+		    nameLeft + groupWidth + kGroupSeparatorGap * 2.0f * m_scale + kGroupSeparatorWidth * m_scale;
+		const float nameWidth =
+		    std::max(20.0f, statsRight - statsWidth - 6.0f * m_scale - nameAreaLeft);
+
+		// 序号以强调色突出，便于在多组之间快速定位。
+		PaintRowText(g, groupLabel, m_fonts->uiBold, gd::RectF(nameLeft, rect.Y, groupWidth, rect.Height),
+		             m_theme->accent, TextAlign::LEFT);
+
+		// 竖线分隔符：以绘制方式实现，与文字基线无关，排版更稳。
+		FillRowRect(g, gd::RectF(nameLeft + groupWidth + kGroupSeparatorGap * m_scale,
+		                         rect.Y + 7.0f * m_scale, kGroupSeparatorWidth * m_scale,
+		                         rect.Height - 14.0f * m_scale),
+		            WithAlpha(m_theme->borderStrong, 0xB0));
+
+		if (m_editField == StyleEditField::GROUP_TITLE && m_editRow == row)
+		{
+			UiDrawEditField(g, RowNameRect(row), m_edit, m_fonts->uiSmall, m_scale);
+		}
+		else
+		{
+			PaintRowText(g, UiEllipsize(group->name, m_fonts->uiBold, nameWidth), m_fonts->uiBold,
+			             gd::RectF(nameAreaLeft, rect.Y, nameWidth, rect.Height), m_theme->textStrong,
+			             TextAlign::LEFT);
+		}
+
+		PaintRowText(g, stats, m_fonts->uiSmall, gd::RectF(statsRight - statsWidth, rect.Y, statsWidth, rect.Height),
+		             m_theme->textMuted, TextAlign::RIGHT);
+
+		// 关闭按钮（从工作区移除该分组）。
+		const bool closeHot = hovered && (m_hoverPart == RowPart::CLOSE);
+		if (closeHot)
+		{
+			UiFillRoundRect(g, closeRect, 3.0f * m_scale, m_theme->pressed);
+		}
+		UiDrawCrossIcon(g, closeRect, closeHot ? m_theme->danger : m_theme->textMuted, 1.5f * m_scale);
+	}
+
+	void SignalPanel::PaintSignalRow(gd::Graphics& g, int row)
+	{
+		if (m_dataSet == nullptr || m_tab == nullptr || row < 0 || row >= static_cast<int>(m_rows.size()))
+		{
+			return;
+		}
+
+		const ListRow& item = m_rows[static_cast<std::size_t>(row)];
+		const SignalRef ref{item.groupIndex, item.signalIndex};
+		const SignalData* signal = m_dataSet->Resolve(ref);
+		const SignalStyle* style = StyleOf(ref);
+		if (signal == nullptr || style == nullptr)
+		{
+			return;
+		}
+
+		const gd::RectF rect = RowRect(row);
+		const bool selected = (SelectedRef() == ref);
+		const bool hovered = (m_hoverRow == row);
+
+		if (selected)
+		{
+			FillRowRect(g, rect, m_theme->selection);
+			FillRowRect(g, gd::RectF(rect.X, rect.Y, 2.0f * m_scale, rect.Height), m_theme->accent);
+		}
+		else if (hovered)
+		{
+			FillRowRect(g, rect, m_theme->hover);
+		}
+
+		const float baseX = rect.X + kPadding * m_scale + kIndent * m_scale;
+		const float centerY = rect.Y + rect.Height * 0.5f;
+
+		// 复选框。
+		const gd::RectF checkRect(baseX + kDisclosureWidth * m_scale, centerY - kCheckSize * m_scale * 0.5f,
+		                          kCheckSize * m_scale, kCheckSize * m_scale);
+		// 可见性属于当前标签页，与全局共享的显示外观分开读取。
+		const bool visible = m_tab->IsVisible(ref);
+		UiDrawCheckBox(g, checkRect, visible ? 1 : 0, 3.0f * m_scale);
+
+		// 颜色块：叠加不透明度，透明度过低时自动补描边（与样式区色块规则一致）。
+		const gd::RectF swatchRect(checkRect.X + checkRect.Width + 6.0f * m_scale,
+		                           centerY - kSwatchSize * m_scale * 0.5f, kSwatchSize * m_scale,
+		                           kSwatchSize * m_scale);
+		UiDrawSwatch(g, swatchRect, style->color, visible ? style->opacity : 0.3f, 2.5f * m_scale,
+		             m_scale);
+
+		// 网格徽标（可点击，用于调整所属网格）。行尾 ✕ 恒在最右侧，徽标整体前移让位。
+		const int laneIndex = m_tab->LaneOfSignal(ref);
+		const bool badgeVisible = (laneIndex >= 0) && visible;
+		const gd::RectF badgeRect = SignalBadgeRect(row);
+		const gd::RectF removeRect = SignalRemoveRect(row);
+
+		float nameRightLimit = removeRect.X - 6.0f * m_scale;
+		if (badgeVisible)
+		{
+			nameRightLimit = badgeRect.X - 6.0f * m_scale;
+		}
+
+		// 名称：完全保留文件内的列名（含 "[n]" 序号与括号描述），双击可重命名。
+		const float nameLeft = swatchRect.X + swatchRect.Width + 6.0f * m_scale;
+		if (m_editField == StyleEditField::SIGNAL_NAME && m_editRow == row)
+		{
+			UiDrawEditField(g, RowNameRect(row), m_edit, m_fonts->ui, m_scale);
+		}
+		else
+		{
+			const float nameWidth = std::max(16.0f, nameRightLimit - nameLeft);
+			const std::uint32_t nameColor = visible ? m_theme->text : m_theme->textMuted;
+			PaintRowText(g, UiEllipsize(signal->name, m_fonts->ui, nameWidth), m_fonts->ui,
+			             gd::RectF(nameLeft, rect.Y, nameWidth, rect.Height), nameColor, TextAlign::LEFT);
+		}
+
+		if (badgeVisible)
+		{
+			const bool badgeHot = hovered && (m_hoverPart == RowPart::LANE_BADGE);
+			UiFillRoundRect(g, badgeRect, kBadgeHeight * m_scale * 0.5f,
+			                badgeHot ? m_theme->accentSoft : m_theme->cardBg);
+			UiDrawRoundRect(g, badgeRect, kBadgeHeight * m_scale * 0.5f,
+			                badgeHot ? m_theme->accent : m_theme->border, 1.0f);
+			PaintRowText(g, L"G" + std::to_wstring(laneIndex + 1), m_fonts->monoSmall, badgeRect,
+			             badgeHot ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
+		}
+
+		// 「移除该信号」✕：位于信号条目最右端，尺寸/样式/右边距与分组行的关闭 ✕ 完全一致。
+		// 最后绘制，确保它永远压在最上层（与分组行 ✕ 的绘制顺序保持一致）。
+		{
+			const bool removeHot = hovered && (m_hoverPart == RowPart::REMOVE_SIGNAL);
+			if (removeHot)
+			{
+				UiFillRoundRect(g, removeRect, 3.0f * m_scale, m_theme->pressed);
+			}
+			UiDrawCrossIcon(g, removeRect, removeHot ? m_theme->danger : m_theme->textMuted,
+			                1.5f * m_scale);
+		}
+	}
+
+	void SignalPanel::PaintScrollBar(gd::Graphics& g)
+	{
+		if (!m_scrollBarVisible || m_contentHeight <= m_listRect.Height)
+		{
+			return;
+		}
+
+		UiFillRoundRect(g, m_scrollBarRect, kScrollBarThickness * m_scale * 0.5f, m_theme->gridWeak);
+		UiFillRoundRect(g, ScrollThumbRect(), kScrollBarThickness * m_scale * 0.5f, m_theme->borderStrong);
+	}
+
+	void SignalPanel::PaintStyleSection(gd::Graphics& g)
+	{
+		if (m_styleRect.Height <= 0.0f)
+		{
+			return;
+		}
+
+		UiFillRect(g, m_styleRect, m_theme->panelBg);
+
+		// ---- 顶部「目标」行（无论是否已选中信号都要绘制：未选中时显示占位文本）----
+		PaintTargetRow(g);
+
+		const SignalStyle* style = (m_tab == nullptr) ? nullptr : StyleOf(SelectedRef());
+		if (style == nullptr || SelectedRef().IsValid() == false)
+		{
+			// 提示文本只占「目标」行以下的区域，避免与目标行重叠。
+			const float top = m_targetRowRect.Y + m_targetRowRect.Height;
+			UiText(g, L"请选择信号以编辑样式", m_fonts->uiSmall,
+			       gd::RectF(m_styleRect.X, top, m_styleRect.Width,
+			                 std::max(0.0f, m_styleRect.Y + m_styleRect.Height - top)),
+			       m_theme->textMuted, TextAlign::CENTER);
+			return;
+		}
+
+		const float labelWidth = kStyleLabelWidth * m_scale;
+
+		// 行标签统一以整行为基准垂直居中，确保与同行控件纵向对齐。
+		auto paintRowLabel = [&](int rowIndex, const wchar_t* text)
+		{
+			const gd::RectF& row = m_styleRowRects[static_cast<std::size_t>(rowIndex)];
+			UiText(g, text, m_fonts->uiSmall, gd::RectF(row.X, row.Y, labelWidth, row.Height),
+			       m_theme->textMuted, TextAlign::LEFT);
+		};
+
+		// ---- 第一行：颜色（预设色块 + 自定义颜色入口）----
+		{
+			paintRowLabel(0, L"颜色");
+
+			int paletteCount = 0;
+			const std::uint32_t* palette = SignalPalette(paletteCount);
+
+			// 判定“当前是否在用自定义色”：必须同时满足
+			//   1) 显示颜色等于记忆的自定义色；
+			//   2) 该颜色不是任何一个可见的预设色。
+			// 否则一旦自定义色与某个预设色相同时，点击那个预设色块会把高亮错误地
+			// 挪到自定义色块上（用户报告的“点预设色直接跳到自定义色块”）。
+			bool presetMatches = false;
+			for (int index = 0; index < m_colorCount; ++index)
+			{
+				if (style->color == palette[index % paletteCount])
+				{
+					presetMatches = true;
+					break;
+				}
+			}
+			const bool customActive = (style->color == style->customColor) && !presetMatches;
+			for (int index = 0; index < m_colorCount; ++index)
+			{
+				const gd::RectF& rect = m_colorRects[static_cast<std::size_t>(index)];
+				const std::uint32_t color = palette[index % paletteCount];
+				const bool hovered = (m_hoverStyle == StyleHit::COLOR && m_hoverStyleIndex == index);
+				const bool active = !customActive && (style->color == color);
+
+				// 预设色块同样叠加不透明度；透明度过低时自动补描边以保证可辨识（与自定义色块一致）。
+				UiDrawSwatch(g, rect, color, style->opacity, kCorner * m_scale, m_scale);
+				if (active || hovered)
+				{
+					const gd::RectF ring(rect.X - 2.0f * m_scale, rect.Y - 2.0f * m_scale,
+					                     rect.Width + 4.0f * m_scale, rect.Height + 4.0f * m_scale);
+					UiDrawRoundRect(g, ring, 5.0f * m_scale,
+					                active ? m_theme->textStrong : m_theme->borderStrong,
+					                active ? 1.6f : 1.0f);
+				}
+			}
+
+			// 自定义颜色入口：与预设色块完全同尺寸、同外框规则的小方格，仅多一个加号图标。
+			// 方格始终显示记忆的自定义颜色，因此从任意预设色再次点击它都能立即回到上次的自定义色。
+			const bool chipHot = (m_hoverStyle == StyleHit::CUSTOM_CHIP);
+			const std::uint32_t chipColor =
+			    UiDrawSwatch(g, m_customChipRect, style->customColor, style->opacity, kCorner * m_scale, m_scale);
+			const std::uint32_t iconColor = IsDarkColor(chipColor) ? 0xFFFDF6E3u : 0xFF073642u;
+			UiDrawPlusIcon(g, m_customChipRect, iconColor, 1.6f * m_scale);
+
+			// 当前正在使用自定义颜色、或鼠标悬停时，显示与预设色块一致的外框。
+			if (customActive || chipHot)
+			{
+				const gd::RectF& chip = m_customChipRect;
+				const gd::RectF ring(chip.X - 2.0f * m_scale, chip.Y - 2.0f * m_scale,
+				                     chip.Width + 4.0f * m_scale, chip.Height + 4.0f * m_scale);
+				UiDrawRoundRect(g, ring, 5.0f * m_scale,
+				                customActive ? m_theme->textStrong : m_theme->borderStrong,
+				                customActive ? 1.6f : 1.0f);
+			}
+		}
+
+		// ---- 第二行：样式（线段 / 散点 / 点线）----
+		{
+			paintRowLabel(1, L"样式");
+
+			for (int index = 0; index < kModeOptionCount; ++index)
+			{
+				const gd::RectF& rect = m_modeRects[static_cast<std::size_t>(index)];
+				const bool active = (style->mode == kModeOptions[index]);
+				const bool hovered = (m_hoverStyle == StyleHit::MODE && m_hoverStyleIndex == index);
+
+				UiFillRoundRect(g, rect, kCorner * m_scale,
+				                active ? m_theme->accentSoft : (hovered ? m_theme->hover : m_theme->cardBg));
+				UiDrawRoundRect(g, rect, kCorner * m_scale, active ? m_theme->accent : m_theme->border, 1.0f);
+				UiText(g, DrawModeName(kModeOptions[index]), m_fonts->uiSmall, rect,
+				       active ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
+			}
+		}
+
+		// ---- 第三行：调整（系数 / 镜像 / 绝对值，三个切换类按钮）----
+		// 结算顺序固定为「系数 → 绝对值 → 镜像」；「系数」「镜像」点击后展开二级面板。
+		{
+			paintRowLabel(2, L"调整");
+
+			const auto paintToggle = [&](int index, const wchar_t* label, bool checked, StyleHit target)
+			{
+				const gd::RectF& rect = m_adjustRects[static_cast<std::size_t>(index)];
+				const bool hot = (m_hoverStyle == target);
+				UiFillRoundRect(g, rect, kCorner * m_scale,
+				                checked ? m_theme->accentSoft : (hot ? m_theme->hover : m_theme->cardBg));
+				UiDrawRoundRect(g, rect, kCorner * m_scale,
+				                checked ? m_theme->accent : m_theme->border, 1.0f);
+				UiText(g, label, m_fonts->uiSmall, rect,
+				       checked ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
+			};
+			// 系数/偏移：系数不等于默认值 1、或任一偏移不为 0 时显示为"已启用"。
+			paintToggle(kAdjustGain, L"系数/偏移",
+			            !GainIsDefault(style->gain) || style->Offset(), StyleHit::GAIN_ADJUST);
+			// 镜像：水平或垂直任一被勾选即显示为激活态。
+			paintToggle(kAdjustMirror, L"镜像", style->Mirrored(), StyleHit::MIRROR_ADJUST);
+			paintToggle(kAdjustAbsolute, L"绝对值", style->absolute, StyleHit::ABSOLUTE_TOGGLE);
+		}
+
+		// ---- 第四行：线宽（数值可点击输入）----
+		{
+			paintRowLabel(3, L"线宽");
+
+			const double ratio =
+			    (static_cast<double>(style->lineWidth) - kWidthMin) / (kWidthMax - kWidthMin);
+			const bool active = m_draggingWidth || (m_hoverStyle == StyleHit::WIDTH_SLIDER);
+			UiDrawSlider(g, m_widthTrackRect, ratio, m_theme->accent, active, m_scale);
+
+			if (m_editField == StyleEditField::WIDTH)
+			{
+				UiDrawEditField(g, m_widthValueRect, m_edit, m_fonts->monoSmall, m_scale);
+			}
+			else
+			{
+				const std::wstring numberText = FormatNumber(style->lineWidth, 1);
+				const std::wstring fullText = numberText + L" px";
+				// 空间不足时省略单位，保证数值本身完整可读。
+				const std::wstring shown =
+				    (UiMeasureTextWidth(m_fonts->monoSmall, fullText) >
+				     m_widthValueRect.Width - 6.0f * m_scale)
+				        ? numberText
+				        : fullText;
+				UiText(g, shown, m_fonts->monoSmall, m_widthValueRect, m_theme->textStrong, TextAlign::RIGHT);
+			}
+		}
+
+		// ---- 第五行：透明度（数值可点击输入）----
+		{
+			paintRowLabel(4, L"透明度");
+
+			const bool active = m_draggingOpacity || (m_hoverStyle == StyleHit::OPACITY_SLIDER);
+			UiDrawSlider(g, m_opacityTrackRect, static_cast<double>(style->opacity), m_theme->accent, active,
+			             m_scale);
+
+			if (m_editField == StyleEditField::OPACITY)
+			{
+				UiDrawEditField(g, m_opacityValueRect, m_edit, m_fonts->monoSmall, m_scale);
+			}
+			else
+			{
+				const int percent = static_cast<int>(style->opacity * 100.0f + 0.5f);
+				UiText(g, std::to_wstring(percent) + L"%", m_fonts->monoSmall, m_opacityValueRect,
+				       m_theme->textStrong, TextAlign::RIGHT);
+			}
+		}
+	}
+
+	void SignalPanel::PaintTargetRow(gd::Graphics& g)
+	{
+		if (m_fonts == nullptr || m_theme == nullptr || m_targetRowRect.Width <= 0.0f)
+		{
+			return;
+		}
+		UpdateTargetRowGeometry();
+
+		const float labelWidth = kStyleLabelWidth * m_scale;
+		// 行标签与前五行一致（同一标签列宽度、同一纵向居中基准）。
+		UiText(g, L"目标", m_fonts->uiSmall,
+		       gd::RectF(m_targetRowRect.X, m_targetRowRect.Y, labelWidth, m_targetRowRect.Height),
+		       m_theme->textMuted, TextAlign::LEFT);
+
+		const SignalRef& target = SelectedRef();
+		const SignalData* signal =
+		    (m_dataSet != nullptr && target.IsValid()) ? m_dataSet->Resolve(target) : nullptr;
+
+		// 没有可编辑的目标信号：只显示占位提示（与样式区其余行的"请选择信号"提示一致）。
+		if (signal == nullptr)
+		{
+			const float contentLeft = m_targetRowRect.X + labelWidth + kStyleLabelGap * m_scale;
+			UiText(g, L"未选择信号", m_fonts->uiSmall,
+			       gd::RectF(contentLeft, m_targetRowRect.Y,
+			                 std::max(0.0f, m_targetRowRect.X + m_targetRowRect.Width - contentLeft),
+			                 m_targetRowRect.Height),
+			       m_theme->textMuted, TextAlign::LEFT);
+			return;
+		}
+
+		// 名称：悬停时给一层与信号列表行一致的背景高亮（用户要求"显示与交互效果相同"）。
+		if (m_hoverStyle == StyleHit::TARGET_NAME && m_targetNameRect.Width > 0.0f)
+		{
+			UiFillRoundRect(g, m_targetNameRect, kCorner * m_scale, m_theme->hover);
+		}
+
+		if (m_editField == StyleEditField::SIGNAL_NAME && m_editRow < 0)
+		{
+			UiDrawEditField(g, EditFieldRect(), m_edit, m_fonts->ui, m_scale);
+		}
+		else
+		{
+			// 颜色与信号列表行一致：已绘制到网格用常态色，未绘制用弱色。
+			const std::uint32_t nameColor = (m_targetGeomLane >= 0) ? m_theme->text : m_theme->textMuted;
+			// ⚠️ 这里**不能**用 `PaintRowText`（它把文本裁到 `m_listRect`，而「目标」行在样式区、
+			//    列表矩形之外 ⇒ 文本会被完全裁掉，用户报告“信号名与 GX 标签都没正确绘制”）。
+			UiText(g, UiEllipsize(signal->name, m_fonts->ui, m_targetNameRect.Width), m_fonts->ui,
+			       m_targetNameRect, nameColor, TextAlign::LEFT);
+		}
+
+		// GX 网格标签：信号已绘制到某个网格时显示在名称**后方**（用户 2026-10-15 要求），
+		// 并与其它控件一样**右对齐到内容列右边缘**。
+		if (m_targetBadgeRect.Width > 0.0f)
+		{
+			const bool badgeHot = (m_hoverStyle == StyleHit::TARGET_BADGE);
+			UiFillRoundRect(g, m_targetBadgeRect, kBadgeHeight * m_scale * 0.5f,
+			                badgeHot ? m_theme->accentSoft : m_theme->cardBg);
+			UiDrawRoundRect(g, m_targetBadgeRect, kBadgeHeight * m_scale * 0.5f,
+			                badgeHot ? m_theme->accent : m_theme->border, 1.0f);
+			UiText(g, L"G" + std::to_wstring(m_targetGeomLane + 1), m_fonts->monoSmall,
+			       m_targetBadgeRect, badgeHot ? m_theme->textStrong : m_theme->text, TextAlign::CENTER);
+		}
+	}
+
+
+} // namespace jdi
+
diff --git a/Documents/agent_mem.md b/Documents/agent_mem.md
index e53d434..9b8c8ad 100644
--- a/Documents/agent_mem.md
+++ b/Documents/agent_mem.md
@@ -2182,7 +2182,7 @@ Components/Shared/Src/UiControls.cpp
 - ⚠️ 新增组件目录必须同时登记进 `Makefile` 的 `CXX_INCLUDES_PATHS` / `CXX_SOURCES_PATHS`
   以及 `.preflight/perf/build.ps1` 的 `$includes` / `$srcDirs`。
 
-#### 五、二进制瘦身：1 013 248 → **754 176 B（−25.6%）**
+#### 五、二进制瘦身：1 013 248 → **764 416 B（−24.6%）**
 
 - **真因**是 **`Resources/JustDataInspector.ico` 的 256×256@32bpp 条目以未压缩 BMP 存储
   （270 376 B，占整包 27%）**，而不是 `PlotView.cpp`。改为 **PNG 存储**（Vista+ 标准做法，
@@ -2207,16 +2207,35 @@ Components/Shared/Src/UiControls.cpp
   `nb30.h`（由 `windows.h` 引入）的 `#define GROUP_NAME 0x80`，导致枚举编译失败，改名
   `GROUP_TITLE` 解决。同类高风险名：`GROUP_NAME`、`TIME`、`SMALL`、`NEAR`、`FAR`、`IGNORE`。
 
-#### 七、本轮**未**完成（诚实记录，勿误以为已完成）
+#### 七、多文件拆分（本轮**已完成**，不再是遗留项）
 
-1. **`PlotView.cpp`（13 695 行 / 544 KB）按功能拆分**：未执行。前置改造是把第 13–888 行的
-   匿名命名空间（~870 行常量与工具函数）改成具名命名空间并**逐个 `inline`**，
-   再做 5 个协作文件的搬移；必须“搬一类 → 编译 → 跑四套探针”反复迭代，本轮时间不足以安全完成。
-   ⚠️ 切勿草率动手 —— 它会直接影响 `Paint()` 分支顺序与图层/装饰缓存不变量（见 §11.2）。
-2. `SignalPanel.cpp`（145 KB）/ `Application.cpp`（104 KB）/ `DataModel.cpp`（88 KB）的多文件化：
-   未执行。三者中 **`SignalPanel.cpp` 的辅助区只有 ~60 行，是性价比最高的下一个拆分入口**。
-3. `Lane` 抽出 `LanePanelState`（内聚性重构）：未执行。
-4. `SetStatusMessage(..., isError)` 的模态阻塞解耦：未执行（需要用户拍板提示样式）。
+四个大文件都按同一手法拆成多个协作文件（私有内部头 + 具名命名空间 + 全 `inline` + 按名字分桶搬移）：
+
+| 原文件 | 拆分后 |
+| --- | --- |
+| `PlotView.cpp`（13 695 行 / 544 KB） | `PlotView.cpp`(787) + `PlotViewPaint.cpp`(6 367) + `PlotViewInteraction.cpp`(2 715) + `PlotViewFeatures.cpp`(3 005) + `PlotViewInternal.hpp`(936) |
+| `SignalPanel.cpp`（4 184 行） | `SignalPanel.cpp`(1 141) + `SignalPanelPaint.cpp`(697) + `SignalPanelInteraction.cpp`(2 095) + `SignalPanelInternal.hpp` |
+| `Application.cpp`（3 135 行） | `Application.cpp`(1 427) + `ApplicationCommands.cpp`(1 184) + `ApplicationLoading.cpp`(270) + `ApplicationInternal.hpp` |
+| `DataModel.cpp`（2 615 行） | `DataModel.cpp`(1 583，含自由函数区) + `DataModelTab.cpp`(732) + `DataModelInternal.hpp` |
+
+⚠️⚠️ **关键手法（要做同类拆分时必须照做）**：
+1. 原文件的**匿名命名空间**（PlotView 约 870 行）搬进 `<组件>Internal.hpp`，改成**具名**命名空间，
+   并把其中**每个函数与常量标 `inline`** ⇒ 多 TU 共用同一定义（不重复符号、不多份代码）。
+2. 头部末尾 `using namespace <ns>;` ⇒ 各 .cpp 里原有的非限定调用**一行都不用改**。
+3. ⚠️ `[[maybe_unused]]` 之类属性**必须排在 `inline` 之前**；`struct`/`enum`/`using` 不可加 `inline`。
+4. ⚠️ **首个成员定义之前的所有行**（通常是命名空间外的自由函数，DataModel 有约 390 行）
+   必须跟着进核心文件，否则会被静默丢弃（拆分脚本已把首个片段的起点设为 0）。
+5. ⚠️ 内部头要带上原文件真正用到的全部头（DataModel 需要 `Theme.hpp`/`<cstring>`/`<cstdio>`/
+   `<deque>`/`<atomic>`/`<cwctype>`/`<new>`）。
+6. ⚠️ **拆分不会减小机器码，反而略增**：实测 754 176 → 764 416 B（+10 240 B，+1.4%），
+   因为 `inline` 工具函数每个引用它的 TU 各生成一份（PE 无 ICF）。
+
+#### 八、本轮仍**未**完成（诚实记录）
+
+1. `Lane` 抽出 `LanePanelState`（内聚性重构，非冗余清理）：未执行。`Lane` 含 4 类实验性功能的
+   状态与各自面板坐标，建议后续把「开关 + 每信号参数 + 面板位置」抽成 `LanePanelState`。
+2. `SetStatusMessage(..., isError)` 的模态阻塞解耦：未执行（需要用户拍板提示样式）。
+3. 上一轮建议的 MF4 压缩块 / `##DL` 数据列表：按用户要求继续不做。
 
 ---
 
@@ -2269,7 +2288,7 @@ Components/Shared/Src/UiControls.cpp
 | 2026-10-15 | DeepSeek-V4.1-Flash（**起源设备**） | **信号面板滚动条跟随 / 工具栏连点丢状态 / 图层网格线步长 / 多网格单点自适应 / 单点信号拖拽（详见 §9.32）**。① **滚动条"卡住"**：`Application::WM_MOUSEMOVE` 的 `plotOnlyMove` 只看 `inPlot && m_mouseOverPlot`，拖滚动条进绘图区后判定"只影响绘图区"⇒ 面板滚动值变了却不重绘；修法：新增 `draggingNonPlot`（正在拖非绘图区组件时一律完整失效）。② **工具栏丢点击**：窗口类带 `CS_DBLCLKS` ⇒ 快速第二次按下被合成 `WM_LBUTTONDBLCLK` 而工具栏没处理（**按下丢失**）；且 `HandleMouseMove` 只要不在工具栏上就 `OnMouseLeave()` ⇒ 清掉 `m_pressedIndex`（按住划出再回按钮松手无效）；两处都已修。③ **网格线错位/丢失/闪烁**：`PaintLane` 的竖向主刻步长取自 `Tab().ViewMin/ViewMax`，而渲染信号图层时该区间已被改成**宽窗口**（≈2×）⇒ 图层辅助线步长 2×、位置与前台不同、判重判据也错位；修法：新增 `m_renderTimeStep`，由 `RenderLaneLayerRegion` 用**前台跨度**算好传入。④ **多网格单点「适应视图」**：新增 `FitSinglePointLanes()`（左右边界 = 最左/最右数据点 ± **一个网格小格**；逐网格 Y 自适应、各留**一个 Y 小格**；全部点同刻 ⇒ 跨度 1s 居中；单值网格 ⇒ Y 跨度 1 居中）。⑤ **单点信号**：`HitTestSignal` 新增单点分支 + 环状光晕 + 可拖拽换网格（悬停**不改光标**，按下后才改）。验证：离屏 `.preflight/check` **67/67 通过**（连跑 3 次稳定）；**A/B** 回退六处修复 ⇒ **17 项如实失败**（含 [C] 辅助线 49px vs 25px、20 vs 40 条、最大偏移 539px）；`make release` 零警告、链接通过。 |
 | 2026-10-16 | DeepSeek-V4.1-Flash（**另一台设备**） | **分组折起/展开动画 + 筛选态可折起（项数按筛选计数）+ 悬浮组名可交互与"先滚动再折起" + 「适应视图」与「Y 轴自适应」彻底同源（详见 §9.35）**。① **折起动画**：`SignalPanel::m_groupAnims` + `GroupRowScale()` —— 每行速度倍率 `1 + 1.2×ordinal/(行数−1)`（**离组名越远越快收尽**）叠加 ease-out cubic（末段减速），总时长 `clamp(115+14×行数, 140, 300)` ms；`BuildRows` 输出**非整行高**，低于 0.75 逻辑 px 的行不再产生；宿主 `WM_TIMER` 同时驱动滚动与折起动画（`Render` 判定改为二者取或）；新增 `SetRowClip/ClearRowClip` 把行内容裁到本行（否则垂直居中文本溢出到相邻行）。② **筛选态折起**：筛选模式改用**独立**的 `m_filterCollapsed`（默认展开，不污染普通列表），`ListRow::displayCount` 承载"该组内符合筛选条件的个数"，筛选文本/清空/数据变化即清空。③ **悬浮组名可交互**：根因是 `HitRow` 只按滚动偏移映射行 ⇒ 点击穿透到下层；修法：`HitRow` 先用 `StickyGroupRowIndex()`+`StickyGroupRowTop()` 判定悬浮行矩形并临时用 `m_rowYOverrideActive` + 新的 `RowHitPart()` 算行内区域，并跳过高度为 0 的行；新增 `ToggleGroupFromRow()`：正悬浮时 `StartScrollAnimationTo(行内容偏移, groupIndex)`（挂起请求 `m_pendingGroupToggle`），滚动到位后才启动折起动画。④ **单点信号上两种自适应不一致**：`FitSinglePointCluster` 曾另算"半径留白 + 跨度 1"且把 `fitYToSelection` 置回 false ⇒ 点「适应视图」既改区间又**关掉 Y 轴自适应**；修法：单点簇只负责时间轴（居中 + 一大格 1s），**逐网格幅值轴与常规路径/Y 轴自适应完全同源**（`fitYToSelection` → `AutoRangeLaneToView`，否则 `autoRange=true`，再接 `ApplySinglePointValueMargins`），且**绝不改写** `fitYToSelection`。验证：新增离屏探针 `.preflight/perf/panelanim_main.cpp`（真实 `Application` + `SW_HIDE`）**94/94 通过**（连跑 3 次稳定；覆盖折起/展开的分帧过渡、单调收敛、越靠下越矮、末态精确无残留、筛选计数与独立折起状态、悬浮四个可交互区域全部命中且下层行仍可点、点击后"先滚动到位再折起"、真实 MF4 单点信号两种自适应逐位一致/往返稳定）；**A/B** 三组（回退绘图区修复 / 禁用悬浮命中优先 / 动画时长置 0）分别 **4 / 13 / 8 项如实失败**；既有 `verify` **49/49**（顺带修正 4 条与远端新规则不符的过期断言）、`datacheck` **69/69**、`edgecheck` **46/46**；`make release` 零警告。 |
 | 2026-10-16 | DeepSeek-V4.1-Flash（**另一台设备**） | **动画改「抽拉卷尺」式刚性平移 + 筛选态折叠三角修正 + 样式区「目标」行绘制/布局修正（详见 §9.36）**。① **动画重做**（推翻上一轮的“按行缩放”）：整组信号作为**刚性整体**平移，**行高永不变**、只维护一个逐行平移量 `m_rowShift` ⇒ 动画期间**无需重建行集合**（流畅关键）；收起时逐条被组名栏吞掉、展开时逐条冒出；中途反向点击**从当前位移续接**不跳变；时长 `clamp(115+6×行数, 150, 320)` ms。② **藏进组名栏的裁剪**：信号行越过组名的**绘制**下边界即裁掉，且除 GDI 裁剪外**必须用 `g.SetClip(..., CombineModeIntersect)` 同时收紧 GDI+ 裁剪**（否则行内色块/复选框/徽标画到组名栏上）。③ **悬浮组名折起改为“一边滚动一边收起”**（推翻“先滚动到位再折起”）：`scrollSynced` 让滚动与平移按同一进度推进 ⇒ 组名屏幕位置恒定；结束时滚动偏移恰好落在“组名正好在最上方”，并且**无跳变**；旧 `m_pendingGroupToggle` 机制删除。④ **筛选态折叠三角**：`PaintFileRow` 改读 `IsGroupCollapsed()`（筛选模式用的是独立的 `m_filterCollapsed`），修复“三角维持筛选前状态”。⑤ **「目标」行**：`PaintTargetRow` 误用列表裁剪版 `PaintRowText` ⇒ 名称与 GX 文本被完全裁掉（改用 `UiText`）；GX 标签改为**右对齐到内容列右边缘**、名称无标签时占满内容列；`EditFieldRect()` 对目标行只返回名称矩形（否则改名输入框把 GX 标签包进去）。验证：离屏探针 `.preflight/perf/panelanim_main.cpp` **147/147 通过**（连跑 3 次稳定；含逐帧断言组名栏像素零变化、`m_rowsDirty` 恒 false、滚动单调且恰好落位、筛选/普通态折叠三角逐像素 0 差异、目标行文本像素存在与两端对齐）；**A/B** 五组（回退筛选三角+非刚性平移 / 回退目标行绘制与布局 / 关闭同步滚动 / 去掉 GDI+ 收紧裁剪 / 不续接位移）分别 **4 / 6 / 6 / 2 / 1 项如实失败**；`verify` **49/49**、`datacheck` **69/69**、`edgecheck` **46/46**；`make clean && make all` 零警告。 |
-| 2026-10-16 | DeepSeek-V4.1-Flash（**另一台设备**） | **分组折起热区与改名输入框修正 + 数据模型去冗余（单一名称）+ 新增 `Components/Shared` 组件 + 过时注释/命名大清理 + 二进制瘦身 25.6%（详见 §9.37 与本轮报告 `Documents/refactor_report_2026-10-16.md`）**。① **折起热区**（用户要求）：点分组**名称**不再折起，只有**折叠三角**或**「组X」标签**（新增 `RowPart::GROUP_TITLE`）才折起。② **分组改名输入框不再吞掉「N 项」**：`RowNameRect` 右边界改为项数左缘；新增 `GroupLabelText`/`GroupStatsText` 作为文本与宽度的唯一来源。③ **`SignalData`/`SignalGroup` 只留一个名称字段**：删除 `displayName` 与 `Title()`（31 处改用 `name`），`SetSignalDisplayName`/`SetGroupDisplayName` → **`RenameSignal`/`RenameGroup`**（空名一律拒绝）；删除死成员 `Application::m_loadingBytes`。④ **新增 `Components/Shared`**（用户要求）：从 `PaintUtil` 迁出全部**控件**（图标/复选框/滑块/内联输入框/颜色样块/取值胶囊配色）到 `UiControls.hpp/.cpp`，`PaintUtil` 只留低层原语；依赖方向固定 `Components/* → Components/Shared → Utilities`。⑤ **过时注释/命名**：`文件下标`→`分组下标`、`文件分组`→`分组` 等一批；形参名 `file`→`axis`/`group`；`PaintFileRow`→`PaintGroupRow`、`FileCloseRect`→`GroupCloseRect`、`OpenFileMenu`→`OpenGroupMenu`、`FileGroupLabelWidth`→`GroupLabelWidth`、`StyleEditField::FILE_NAME`→`GROUP_TITLE`；修复 `DataModel.hpp` 两处被压扁的注释块与 `NewTab` 重复文档块。⑥ **二进制瘦身**：真因是 **ICO 里 256×256 未压缩 BMP 条目（270 KB，占整包 27%）**，改为 **PNG 存储**（观感零变化）⇒ `Target.exe` **1 013 248 → 754 176 B（−25.6%）**；实测“拆分大文件不减小机器码”、`--gc-sections` 反而 +9 KB（已回退）。验证：`panelanim` **156/156**、`verify` **49/49**、`datacheck` **69/69**、`edgecheck` **46/46**；**A/B** 回退两处 UI 修复 **10 项如实失败**；`make release`/`make debug` 零警告。⚠️ **未完成（已如实记录）**：`PlotView.cpp`（13.7 K 行）与其它大文件的多文件化拆分、`LanePanelState` 抽取、模态提示解耦。 |
+| 2026-10-16 | DeepSeek-V4.1-Flash（**另一台设备**） | **分组折起热区与改名输入框修正 + 数据模型去冗余（单一名称）+ 新增 `Components/Shared` 组件 + 过时注释/命名大清理 + 二进制瘦身 24.6% 并完成多文件拆分（详见 §9.37 与本轮报告 `Documents/refactor_report_2026-10-16.md`）**。① **折起热区**（用户要求）：点分组**名称**不再折起，只有**折叠三角**或**「组X」标签**（新增 `RowPart::GROUP_TITLE`）才折起。② **分组改名输入框不再吞掉「N 项」**：`RowNameRect` 右边界改为项数左缘；新增 `GroupLabelText`/`GroupStatsText` 作为文本与宽度的唯一来源。③ **`SignalData`/`SignalGroup` 只留一个名称字段**：删除 `displayName` 与 `Title()`（31 处改用 `name`），`SetSignalDisplayName`/`SetGroupDisplayName` → **`RenameSignal`/`RenameGroup`**（空名一律拒绝）；删除死成员 `Application::m_loadingBytes`。④ **新增 `Components/Shared`**（用户要求）：从 `PaintUtil` 迁出全部**控件**（图标/复选框/滑块/内联输入框/颜色样块/取值胶囊配色）到 `UiControls.hpp/.cpp`，`PaintUtil` 只留低层原语；依赖方向固定 `Components/* → Components/Shared → Utilities`。⑤ **过时注释/命名**：`文件下标`→`分组下标`、`文件分组`→`分组` 等一批；形参名 `file`→`axis`/`group`；`PaintFileRow`→`PaintGroupRow`、`FileCloseRect`→`GroupCloseRect`、`OpenFileMenu`→`OpenGroupMenu`、`FileGroupLabelWidth`→`GroupLabelWidth`、`StyleEditField::FILE_NAME`→`GROUP_TITLE`；修复 `DataModel.hpp` 两处被压扁的注释块与 `NewTab` 重复文档块。⑥ **多文件拆分（本轮完成）**：`PlotView.cpp`（13 695 行）+ `SignalPanel.cpp` + `Application.cpp` + `DataModel.cpp` 四个大文件全部按功能拆成多个协作文件（私有内部头 + 具名命名空间 + 全 `inline` + 按名字分桶），最大单文件 544 KB → 276 KB。⑦ **二进制瘦身**：真因是 **ICO 里 256×256 未压缩 BMP 条目（270 KB，占整包 27%）**，改为 **PNG 存储**（观感零变化）⇒ `Target.exe` **1 013 248 → 764 416 B（−24.6%）**；实测“拆分不会减小机器码，反而 +1.4%”、`--gc-sections` 反而 +9 KB（已回退）。验证：`panelanim` **156/156**、`verify` **49/49**、`datacheck` **69/69**、`edgecheck` **46/46**；**A/B** 回退两处 UI 修复 **10 项如实失败**；`make release`/`make debug` 零警告。⚠️ **未完成（已如实记录）**：`PlotView.cpp`（13.7 K 行）与其它大文件的多文件化拆分、`LanePanelState` 抽取、模态提示解耦。 |
 
 ---
 
@@ -2650,6 +2669,25 @@ Components/Shared/Src/UiControls.cpp
     ⚠️ **拆分大文件不会减小机器码**；“拆分 ⇒ 瘦身”不成立。
     ⚠️ `-ffunction-sections/-fdata-sections/--gc-sections` 在本工程**反而增大 9 KB**（已回退）。
     ⚠️ `.o` 字节数受节对齐/重定位表主导，**判断“代码搬去哪了”要用 `nm`，不要看 `.o` 大小**。
+91. ⚠️⚠️ **大文件多文件化的唯一安全手法**（本轮已对 `PlotView`/`SignalPanel`/`Application`/`DataModel`
+    四个文件执行）：
+    1. 把原文件的**匿名命名空间**（PlotView 约 870 行）整块搬进 `<组件>Internal.hpp`，
+       从 `namespace { }` 改成**具名**命名空间（`pvdetail`/`spdetail`/`appdetail`/`dmdetail`），
+       并把其中**每个函数与常量都标 `inline`**；
+    2. 头部末尾加 `using namespace <ns>;` ⇒ 各 .cpp 里原有的非限定调用**一行都不用改**；
+    3. 成员定义按「方法名 → 分片」归类后**整块搬移**（纯代码搬移，不改函数体）。
+    ⚠️ 易错点：
+    * `[[maybe_unused]]` 等属性**必须排在 `inline` 之前**（`inline [[x]] T` 非法）；
+      单独的 `{`/`}` 行、注释行、`struct`/`enum`/`using`/`template` 行**不能**加 `inline`；
+    * 匿名命名空间的**结束行可能带注释**（`} // namespace`），匹配时不能只认 `^\t}$`；
+    * **首个成员定义之前的所有行**必须跟着进核心文件（`DataModel.cpp` 有约 390 行命名空间外的
+      自由函数），否则会被静默丢弃；
+    * 内部头要带上原文件真正用到的全部头（`DataModel` 需 `Theme.hpp`/`<cstring>`/`<cstdio>`/
+      `<deque>`/`<atomic>`/`<cwctype>`/`<new>`）。
+92. ⚠️ **多文件化会略增产物**：`inline` 工具函数会在每个引用它的 TU 各生成一份（PE 无 ICF 合并），
+    实测 `PlotView` 拆分 +5 120 B、四个文件全部拆完 +10 240 B（共 +1.4%）。
+    这是**可维护性换体积**的有意取舍；若日后必须压体积，优先考虑把工具函数收敛到单个 TU
+    （用 `extern` 声明 + 单一实现）而不是撤销拆分。
 71. ⚠️ **`FitAll()` 在没有任何可见信号时不得置位 `Tab().ViewInitialized()`**：
     否则用户先连点几次「适应视图」（此时无信号被勾选）再勾选第一个信号，
     `Application::SynchronizeView` 会**跳过初次自适应**，视界停在“无信号”那次的整段范围上，
diff --git a/Documents/refactor_report_2026-10-16.md b/Documents/refactor_report_2026-10-16.md
index 77a6f40..1fb9bca 100644
--- a/Documents/refactor_report_2026-10-16.md
+++ b/Documents/refactor_report_2026-10-16.md
@@ -5,7 +5,8 @@
 > 巨型实现文件；③ 为二进制产物瘦身；④ 全部改动不得影响功能与性能。
 >
 > 结论：**UI 缺陷已修复并 A/B 验证；数据模型去冗余（信号 / 分组只保留唯一名称）落地；全仓过时注释与
-> 命名批量修正；新增 `Components/Shared` 组件并迁入通用 UI 控件；产物体积 −25.6%（1013 KB → 737 KB）**。
+> 命名批量修正；新增 `Components/Shared` 组件并迁入通用 UI 控件；三个大文件（PlotView / SignalPanel /
+> Application / DataModel）按功能拆分为多个协作文件；产物体积 **−24.6%**（1 013 248 → 764 416 B）**。
 > 四套离屏测试（49 + 69 + 46 + **156** 条断言）全绿、`make release` / `make debug` 零警告。
 > **`PlotView.cpp` 的整体拆分本轮未执行**（见 §五，附可执行的落地方案与原因）。
 
@@ -151,13 +152,13 @@ Components/*（功能组件）  ──▶  Components/Shared（UI 控件）  ─
 
 ## 五、二进制瘦身（实测）
 
-### 5.1 结论：**1013 KB → 737 KB（−25.6%，省 ≈276 KB）**
+### 5.1 结论：**1 013 248 → 764 416 B（−24.6%，省 248 832 B）**
 
 | 项 | 大小 |
 | --- | --- |
 | `Target.exe`（Release `-Os -s`，本轮前） | 1 013 248 B |
-| `Target.exe`（Release `-Os -s`，本轮后） | **754 176 B** |
-| 差值 | **−259 072 B（−25.6%）** |
+| `Target.exe`（Release `-Os -s`，本轮后） | **764 416 B** |
+| 差值 | **−248 832 B（−24.6%）** |
 | （参考）`Target.exe`（Debug `-O0`，未 strip） | 13 849 441 B |
 
 ### 5.2 真正的体积来源（实测，纠正“都是 PlotView.cpp 撑大的”这一推断）
@@ -212,31 +213,55 @@ Components/*（功能组件）  ──▶  Components/Shared（UI 控件）  ─
 
 ## 七、本轮未完成 / 后续建议（诚实记录）
 
-### 7.1 `PlotView.cpp`（13 695 行 / 544 KB）按功能拆分 —— **本轮未执行**
+### 7.1 `PlotView.cpp`（13 695 行 / 544 KB）按功能拆分 —— **已完成**
 
-* **为什么不硬做**：拆分本身是**纯代码搬移**（不改变行为），真正的成本在**前置条件**：
-  该文件的辅助区（第 13–888 行的匿名命名空间，含 ~870 行常量与工具函数）被**全部**成员函数
-  广泛引用。要让多个 .cpp 共享它们，必须先把匿名命名空间改成具名命名空间并**逐个函数标注
-  `inline`**（否则多 TU 重复定义或产生 N 份机器码），再逐个把成员定义搬走。
-  这是一次需要“搬一类 → 编译 → 跑四套探针”反复迭代的工程（预计 5 个 .cpp：基底/图层缓存、
-  绘制、命中与交互、派生曲线调度、浮动面板），**在没有足够时间逐步验证时贸然动手会破坏
-  性能敏感的渲染路径**，因此本轮**主动不做**，而不是草率地做一半。
-* **推荐的落地方案（可直接照着做）**：
-  1. 新建 `Components/PlotView/Src/PlotViewInternal.hpp`：包含现有 `#include` 段 +
-     `namespace jdi { namespace pvdetail { <常量与工具函数，逐个加 inline> } using namespace pvdetail; }`；
-  2. `PlotView.cpp` 只留核心（构造/析构、`Layout`/`RefreshLanes`/`BuildLaneVisuals`、缓存失效）；
-  3. 按**粘连度**由低到高搬移：`PlotViewDerived.cpp`（曲线线程池与 `CurveSpanFor` / `ScheduleCurveJob`）、
-     `PlotViewPanels.cpp`（4 类实验性浮动面板的几何/命中/绘制）、`PlotViewInteraction.cpp`
-     （`On*` 与命中测试）、`PlotViewPaint.cpp`（`Paint*` 与图层/装饰缓存）；
-  4. 每搬一个文件：`make release` 零警告 + `verify`/`panelanim` 全绿，再继续。
-  5. ⚠️ 千万别动 `Paint()` 的**分支顺序**与图层/装饰缓存的既有不变量（见 `agent_mem.md` §11.2）。
+拆成 4 个协作文件 + 1 个组件私有头（共 6 个文件，最大单文件从 544 KB 降到 270 KB）：
 
-### 7.2 其余组件的多文件化（同样未执行）
+| 文件 | 行数 | 职责 |
+| --- | --- | --- |
+| `Inc/PlotView.hpp` | — | 类声明（未改） |
+| `Src/PlotView.cpp` | 787 | 视图核心：构造/析构、上下文、布局、坐标映射、视界与平移、网格结构与归属 |
+| `Src/PlotViewPaint.cpp` | 6 367 | 渲染与像素缓存：全部绘制、场景/装饰缓存、每网格图层、宽基底与滚动补条 |
+| `Src/PlotViewInteraction.cpp` | 2 715 | 交互与编辑：命中测试、鼠标/键盘、光标形状、内联输入框、浮动面板层序 |
+| `Src/PlotViewFeatures.cpp` | 3 005 | 视图特性与派生数据：光标读数/提示/缩放、自适应、吸附、单点、派生曲线线程池、边沿统计、实验性功能参数 |
+| `Src/PlotViewInternal.hpp` | 936 | 组件私有：原**匿名命名空间**的常量与工具（常量与函数全部 `inline`） |
 
-`SignalPanel.cpp`（145 KB / 3.7 K 行）、`Application.cpp`（104 KB）、`DataModel.cpp`（88 KB）
-同样适合按“列表/绘制/交互/编辑”“窗口与消息/命令与动作/加载”“数据集合/统计与采样/标签页配置”
-拆成 3–4 个文件。`SignalPanel.cpp` 的辅助区仅约 60 行（十几个常量 + 少量格式化函数），
-**改造成本远低于 `PlotView.cpp`**，是下一步性价比最高的拆分入口。
+**关键手法（也是本次能安全拆开的前提）**：
+原 `PlotView.cpp` 第 13–889 行是一个约 870 行的**匿名命名空间**（常量 + 工具函数），被所有成员函数广泛引用。
+若直接拆文件，各 .cpp 都拿不到这些工具。做法是：
+
+1. 把该块搬进 `PlotViewInternal.hpp`，从**匿名**命名空间改为**具名** `namespace pvdetail`；
+2. 块内**每个函数与常量都标 `inline`**（含 `[[maybe_unused]]` 属性要先于 `inline`）⇒
+   多个翻译单元共用**同一个定义**：既不重复符号，也不产生多份机器码；
+3. 头部末尾 `using namespace pvdetail;` ⇒ 各 .cpp 函数体里原有的非限定调用（`IntersectRect` / `NiceStep` …）
+   **一行都不用改**；
+4. 成员定义按“方法名 → 分片”归类后整块搬移，即**纯代码搬移**，不改任何一行函数体。
+
+**验证**：`make release` / `make debug` 零警告；四套探针全绿（`verify` 49/49 含逐像素断言）。
+**代价（诚实记录）**：产物 **754 176 → 764 416 B（+10 240 B，+1.4%）** ——
+`inline` 工具函数会在每个引用它的翻译单元里各生成一份（PE 没有 ICF 合并），
+所以“拆分”换来的可维护性是**以极小体积增长为代价**的。这再次印证：
+**拆分解决的是可维护性，不是体积**（体积那 −24.6% 全部来自图标）。
+
+### 7.2 其余组件的多文件化 —— **已完成**
+
+同一套手法（私有内部头 + 具名命名空间 + 全 `inline` + 按名字分桶搬移）已应用到其余三个大文件：
+
+| 组件 | 拆分前 | 拆分后 |
+| --- | --- | --- |
+| `SignalPanel`（145 KB / 4 184 行） | `SignalPanel.cpp` | `SignalPanel.cpp`（核心 1 141 行）+ `SignalPanelPaint.cpp`（697）+ `SignalPanelInteraction.cpp`（2 095）+ `SignalPanelInternal.hpp` |
+| `Application`（104 KB / 3 135 行） | `Application.cpp` | `Application.cpp`（核心 1 427 行）+ `ApplicationCommands.cpp`（1 184）+ `ApplicationLoading.cpp`（270）+ `ApplicationInternal.hpp` |
+| `DataModel`（88 KB / 2 615 行） | `DataModel.cpp` | `DataModel.cpp`（核心 1 583 行，含自由函数区）+ `DataModelTab.cpp`（732，全部 `TabConfig`）+ `DataModelInternal.hpp` |
+
+⚠️ 拆分过程中对两个**易错点**做了专门处理（均已固化到 `.preflight/perf/split_component.ps1`）：
+
+1. **首个成员定义之前的行不能丢**：`DataModel.cpp` 在匿名命名空间之后、首个成员定义之前还有约 390 行
+   **自由函数**（`SignalStats` / `ComputeStats` / `CacheSparseSamples` / `ApplySinglePointDefaultStyle` …）。
+   分桶时把“第一个片段”的起点设为 0，这些行就会跟着进核心文件。
+2. **包含的依赖不能漏**：内部头必须带上原文件真正用到的头（如 `DataModel` 需要 `Theme.hpp`、`<cstring>`、
+   `<cstdio>`、`<deque>`、`<atomic>`、`<cwctype>`、`<new>`）。
+
+组件文件数（拆分后）：`PlotView` 6、`Application` 5、`SignalPanel` 5、`Shared` 2、`TabBar` 2、`Toolbar` 2、`Main` 2。
 
 ### 7.3 `Lane` 的内聚性（上一轮建议 5）
 
@@ -260,16 +285,28 @@ Components/*（功能组件）  ──▶  Components/Shared（UI 控件）  ─
 ```
 新增  Components/Shared/Inc/UiControls.hpp          通用 UI 控件（自 PaintUtil 迁出）
 新增  Components/Shared/Src/UiControls.cpp
+新增  Components/PlotView/Src/PlotViewInternal.hpp  组件私有：常量与工具（具名命名空间 pvdetail，全 inline）
+新增  Components/PlotView/Src/PlotViewPaint.cpp     渲染与像素缓存
+新增  Components/PlotView/Src/PlotViewInteraction.cpp 交互、命中与编辑
+新增  Components/PlotView/Src/PlotViewFeatures.cpp  视图特性与派生数据
+新增  Components/SignalPanel/Src/SignalPanelInternal.hpp
+新增  Components/SignalPanel/Src/SignalPanelPaint.cpp
+新增  Components/SignalPanel/Src/SignalPanelInteraction.cpp
+新增  Components/Application/Src/ApplicationInternal.hpp
+新增  Components/Application/Src/ApplicationCommands.cpp
+新增  Components/Application/Src/ApplicationLoading.cpp
+新增  Utilities/Src/DataModelInternal.hpp
+新增  Utilities/Src/DataModelTab.cpp
 修改  Utilities/Inc/PaintUtil.hpp                  移除 16 个控件声明
 修改  Utilities/Src/PaintUtil.cpp                  移除控件实现（953 → 571 行）
 修改  Utilities/Inc/DataModel.hpp                  SignalData/SignalGroup 单一名称字段；注释/命名修正
-修改  Utilities/Src/DataModel.cpp                  RenameSignal / RenameGroup（空名被拒）
+修改  Utilities/Src/DataModel.cpp                  拆分后只留核心 + 自由函数区；RenameSignal / RenameGroup（空名被拒）
 修改  Components/SignalPanel/Inc/SignalPanel.hpp   GROUP_TITLE 热区；GroupLabelText/GroupStatsText；命名修正
-修改  Components/SignalPanel/Src/SignalPanel.cpp   折起热区、改名输入框边界、过时注释/命名
-修改  Components/PlotView/Inc/PlotView.hpp         过时注释（“文件”→分组、形参名 axis）
-修改  Components/PlotView/Src/PlotView.cpp         Title() → name；过时注释
+修改  Components/SignalPanel/Src/SignalPanel.cpp   拆分后只留核心；折起热区、改名输入框边界、过时注释/命名
+修改  Components/PlotView/Inc/PlotView.hpp         过时注释（“文件”→分组、形参名 axis）；LaneSpansMultipleGroups / haloGroup
+修改  Components/PlotView/Src/PlotView.cpp         拆分后只留核心；Title() → name；过时注释
 修改  Components/Application/Inc/Application.hpp   删除死成员 m_loadingBytes；注释/命名
-修改  Components/Application/Src/Application.cpp   过时注释/命名
+修改  Components/Application/Src/Application.cpp   拆分后只留核心；过时注释/命名
 修改  Components/TabBar/Src/TabBar.cpp             引入 UiControls.hpp
 修改  Components/Toolbar/Inc/Toolbar.hpp           注释修正
 修改  Utilities/Src/PopupMenu.cpp | ColorPickerPopup.cpp   引入 UiControls.hpp
diff --git a/Utilities/Src/DataModel.cpp b/Utilities/Src/DataModel.cpp
index 2dbc422..666025e 100644
--- a/Utilities/Src/DataModel.cpp
+++ b/Utilities/Src/DataModel.cpp
@@ -1,325 +1,12 @@
-#include "DataModel.hpp"
-
-#include <algorithm>
-#include <atomic>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cwctype>
-#include <deque>
-#include <limits>
-#include <new>
-
-#include <windows.h>	// Sleep（低内存设备的“少量多次”节流）
-
-#include "Theme.hpp"
-#include "Utf8Util.hpp"
+// DataModel 实现分片 —— 本文件只包含 DataModel 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 DataModelInternal.hpp（命名空间 `dmdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "DataModelInternal.hpp"
 
 namespace jdi
 {
 
-	namespace
-	{
-		const double kMissing = std::numeric_limits<double>::quiet_NaN();	/**< 缺失值占位。 */
-		const double kDefaultLineWidth = 1.6;								/**< 默认线宽。 */
-
-		/**
-		 * @brief 为网格范围补充留白，避免波形紧贴边界。
-		 *
-		 * ⚠️ 实际规则实现在 `DataModel.hpp` 的 `PadValueRange()`：它同时被
-		 * 「选区 Y 轴自适应」使用，两处必须逐位一致（否则两种自适应会算出不同区间）。
-		 *
-		 * @param [IN, OUT] yMin 范围下限。
-		 * @param [IN, OUT] yMax 范围上限。
-		 */
-		void PadRange(double& yMin, double& yMax)
-		{
-			PadValueRange(yMin, yMax);
-		}
-
-		/**
-		 * @brief 依据全部可见信号重新生成网格划分。
-		 * @param [IN] visible 各信号的可见性（按 [分组][信号] 索引）。
-		 * @param [IN] lanes 网格集合（原地更新）。
-		 * @param [IN] mode 网格划分策略。
-		 */
-		void RebuildLanes(const std::vector<std::vector<bool>>& visible, std::vector<Lane>& lanes,
-		                  LaneMode mode)
-		{
-			// 随网格携带的“网格自身状态”（按信号继承）：重建网格时不能丢。
-			struct LaneCarry
-			{
-				bool matched = false;		/**< 是否找到该信号原本所在的网格（false = 新出现的信号）。 */
-				bool fitYToSelection = false;
-				bool edgeCount = false;
-				double edgeValue = 0.0;
-				bool edgeValueValid = false;
-				bool edgePanelOpen = true;
-				double edgePanelX = -1.0;
-				double edgePanelY = -1.0;
-				bool edgeCenter = false;
-				std::vector<Lane::EdgeCenterItem> edgeCenterItems;
-				bool edgeCenterPanelOpen = true;
-				double edgeCenterPanelX = -1.0;
-				double edgeCenterPanelY = -1.0;
-				bool meanFilter = false;
-				std::vector<Lane::MeanFilterItem> meanFilterItems;
-				bool meanFilterPanelOpen = true;
-				double meanFilterPanelX = -1.0;
-				double meanFilterPanelY = -1.0;
-				bool weakPeak = false;
-				std::vector<Lane::WeakPeakItem> weakPeakItems;
-				bool weakPeakPanelOpen = true;
-				double weakPeakPanelX = -1.0;
-				double weakPeakPanelY = -1.0;
-			};
-
-			// 先记下每个信号原来所在网格的网格自身状态：
-			// 勾选可见性会重建网格，若不携带，用户刚打开的开关会被悄悄清掉。
-			//
-			// ⚠️ 同时记下「重建之前是否**每个**网格都开着 `fitYToSelection`」：
-			// 那就是「全局 Y 轴自适应」的正式定义。新勾选信号产生的**新网格**必须继承它，
-			// 否则全局开关看着是开的、新网格却不按当前视界自适应（用户报告的缺陷）。
-			bool previousAllAutoFit = !lanes.empty();
-			for (const Lane& lane : lanes)
-			{
-				if (!lane.fitYToSelection)
-				{
-					previousAllAutoFit = false;
-					break;
-				}
-			}
-
-			std::vector<std::pair<SignalRef, LaneCarry>> previousCarry;
-			for (const Lane& lane : lanes)
-			{
-				LaneCarry carry;
-				carry.matched = true;
-				carry.fitYToSelection = lane.fitYToSelection;
-				carry.edgeCount = lane.edgeCount;
-				carry.edgeValue = lane.edgeValue;
-				carry.edgeValueValid = lane.edgeValueValid;
-				carry.edgePanelOpen = lane.edgePanelOpen;
-				carry.edgePanelX = lane.edgePanelX;
-				carry.edgePanelY = lane.edgePanelY;
-				carry.edgeCenter = lane.edgeCenter;
-				carry.edgeCenterItems = lane.edgeCenterItems;
-				carry.edgeCenterPanelOpen = lane.edgeCenterPanelOpen;
-				carry.edgeCenterPanelX = lane.edgeCenterPanelX;
-				carry.edgeCenterPanelY = lane.edgeCenterPanelY;
-				carry.meanFilter = lane.meanFilter;
-				carry.meanFilterItems = lane.meanFilterItems;
-				carry.meanFilterPanelOpen = lane.meanFilterPanelOpen;
-				carry.meanFilterPanelX = lane.meanFilterPanelX;
-				carry.meanFilterPanelY = lane.meanFilterPanelY;
-				carry.weakPeak = lane.weakPeak;
-				carry.weakPeakItems = lane.weakPeakItems;
-				carry.weakPeakPanelOpen = lane.weakPeakPanelOpen;
-				carry.weakPeakPanelX = lane.weakPeakPanelX;
-				carry.weakPeakPanelY = lane.weakPeakPanelY;
-				for (const SignalRef& ref : lane.signals)
-				{
-					previousCarry.emplace_back(ref, carry);
-				}
-			}
-			const auto inheritedCarry = [&previousCarry](const SignalRef& ref)
-			{
-				for (const std::pair<SignalRef, LaneCarry>& entry : previousCarry)
-				{
-					if (entry.first == ref)
-					{
-						return entry.second;
-					}
-				}
-				return LaneCarry();
-			};
-			const auto applyCarry = [&inheritedCarry, previousAllAutoFit](Lane& lane, const SignalRef& ref)
-			{
-				const LaneCarry carry = inheritedCarry(ref);
-				// 新出现的信号（之前没有网格）：继承「全局 Y 轴自适应」是否开启。
-				lane.fitYToSelection = carry.matched ? carry.fitYToSelection : previousAllAutoFit;
-				lane.edgeCount = carry.edgeCount;
-				lane.edgeValue = carry.edgeValue;
-				lane.edgeValueValid = carry.edgeValueValid;
-				lane.edgePanelOpen = carry.edgePanelOpen;
-				lane.edgePanelX = carry.edgePanelX;
-				lane.edgePanelY = carry.edgePanelY;
-				lane.edgeCenter = carry.edgeCenter;
-				lane.edgeCenterItems = carry.edgeCenterItems;
-				lane.edgeCenterPanelOpen = carry.edgeCenterPanelOpen;
-				lane.edgeCenterPanelX = carry.edgeCenterPanelX;
-				lane.edgeCenterPanelY = carry.edgeCenterPanelY;
-				lane.meanFilter = carry.meanFilter;
-				lane.meanFilterItems = carry.meanFilterItems;
-				lane.meanFilterPanelOpen = carry.meanFilterPanelOpen;
-				lane.meanFilterPanelX = carry.meanFilterPanelX;
-				lane.meanFilterPanelY = carry.meanFilterPanelY;
-				lane.weakPeak = carry.weakPeak;
-				lane.weakPeakItems = carry.weakPeakItems;
-				lane.weakPeakPanelOpen = carry.weakPeakPanelOpen;
-				lane.weakPeakPanelX = carry.weakPeakPanelX;
-				lane.weakPeakPanelY = carry.weakPeakPanelY;
-			};
-
-			// 收集全部可见信号引用。
-			std::vector<SignalRef> visibleRefs;
-			for (std::size_t groupIndex = 0; groupIndex < visible.size(); ++groupIndex)
-			{
-				for (std::size_t signalIndex = 0; signalIndex < visible[groupIndex].size(); ++signalIndex)
-				{
-					if (visible[groupIndex][signalIndex])
-					{
-						SignalRef ref;
-						ref.groupIndex = static_cast<int>(groupIndex);
-						ref.signalIndex = static_cast<int>(signalIndex);
-						visibleRefs.push_back(ref);
-					}
-				}
-			}
-
-			// 判断某引用对应的信号是否可见（越界视为不可见）。
-			const auto isVisibleRef = [&visible](const SignalRef& ref)
-			{
-				if (ref.groupIndex < 0 || static_cast<std::size_t>(ref.groupIndex) >= visible.size())
-				{
-					return false;
-				}
-				const std::vector<bool>& fileVisible = visible[static_cast<std::size_t>(ref.groupIndex)];
-				if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
-				{
-					return false;
-				}
-				return fileVisible[static_cast<std::size_t>(ref.signalIndex)];
-			};
-
-			// 某信号当前所属的网格下标（-1 表示尚未分配网格）。
-			const auto laneIndexOf = [&lanes](const SignalRef& ref)
-			{
-				for (std::size_t index = 0; index < lanes.size(); ++index)
-				{
-					const std::vector<SignalRef>& refs = lanes[index].signals;
-					if (std::find(refs.begin(), refs.end(), ref) != refs.end())
-					{
-						return static_cast<int>(index);
-					}
-				}
-				return -1;
-			};
-
-			if (mode == LaneMode::PER_SIGNAL)
-			{
-				// 每条可见信号独占一个网格：网格数量严格跟随可见信号数量。
-				// **顺序按"原有网格位置"优先**：已经分配过网格的信号保持其相对次序，
-				// 新勾选（此前没有网格）的信号统一追加到最下方。
-				// 若直接按 visibleRefs（文件/列序）重建，新勾选的信号会按其列序
-				// 插到中间，位置看起来"不确定"。
-				std::vector<SignalRef> ordered;
-				ordered.reserve(visibleRefs.size());
-				for (const SignalRef& ref : visibleRefs)
-				{
-					if (laneIndexOf(ref) >= 0)
-					{
-						ordered.push_back(ref);
-					}
-				}
-				std::stable_sort(ordered.begin(), ordered.end(),
-				                 [&laneIndexOf](const SignalRef& a, const SignalRef& b)
-				                 { return laneIndexOf(a) < laneIndexOf(b); });
-				for (const SignalRef& ref : visibleRefs)
-				{
-					if (laneIndexOf(ref) < 0)
-					{
-						ordered.push_back(ref);
-					}
-				}
-
-				lanes.clear();
-				lanes.reserve(ordered.size());
-				for (const SignalRef& ref : ordered)
-				{
-					Lane lane;
-					lane.autoRange = true;
-					applyCarry(lane, ref);
-					lane.signals.push_back(ref);
-					lanes.push_back(std::move(lane));
-				}
-			}
-			else if (mode == LaneMode::MERGED)
-			{
-				// 全部可见信号合并到同一网格；无可见信号时不保留空网格。
-				bool previousAutoRange = true;
-				double previousYMin = -1.0;
-				double previousYMax = 1.0;
-				if (lanes.size() == 1)
-				{
-					previousAutoRange = lanes[0].autoRange;
-					previousYMin = lanes[0].yMin;
-					previousYMax = lanes[0].yMax;
-				}
-
-				lanes.clear();
-				if (!visibleRefs.empty())
-				{
-					Lane lane;
-					lane.autoRange = previousAutoRange;
-					lane.yMin = previousYMin;
-					lane.yMax = previousYMax;
-					applyCarry(lane, visibleRefs.front());
-					lane.signals = visibleRefs;
-					lanes.push_back(std::move(lane));
-				}
-			}
-			else
-			{
-				// 自定义划分：仅移除不可见信号与由此产生的空网格，保持用户排布。
-				for (Lane& lane : lanes)
-				{
-					std::vector<SignalRef>& refs = lane.signals;
-					refs.erase(std::remove_if(refs.begin(), refs.end(),
-					                          [&isVisibleRef](const SignalRef& ref)
-					                          { return !isVisibleRef(ref); }),
-					            refs.end());
-				}
-
-				lanes.erase(std::remove_if(lanes.begin(), lanes.end(),
-				                           [](const Lane& lane) { return lane.signals.empty(); }),
-				            lanes.end());
-
-				// 未分配网格的可见信号各自独占一个新网格。
-				// 注意：不能把它们塞进已有的第一个网格——那会导致“拖拽合并后新勾选的信号
-				// 被悄悄并入合并网格”，用户看不到新增的独立泳道。
-				for (const SignalRef& ref : visibleRefs)
-				{
-					bool placed = false;
-					for (const Lane& lane : lanes)
-					{
-						if (std::find(lane.signals.begin(), lane.signals.end(), ref) != lane.signals.end())
-						{
-							placed = true;
-							break;
-						}
-					}
-					if (placed)
-					{
-						continue;
-					}
-
-					Lane lane;
-					lane.autoRange = true;
-					applyCarry(lane, ref);
-					lane.signals.push_back(ref);
-					lanes.push_back(std::move(lane));
-				}
-			}
-
-			// 统一重命名，保证编号连续。
-			for (std::size_t index = 0; index < lanes.size(); ++index)
-			{
-				lanes[index].name = L"网格 " + std::to_wstring(index + 1);
-			}
-		}
-	}
 
 	const wchar_t* DrawModeName(DrawMode mode)
 	{
@@ -1891,725 +1578,6 @@ namespace jdi
 		return true;
 	}
 
-	TabConfig::TabConfig()
-	    : m_name(L"视图 1")
-	{
-	}
-
-	void TabConfig::SyncToDataSet(const DataSet& dataSet)
-	{
-		const std::size_t groupCount = dataSet.GroupCount();
-		m_visible.resize(groupCount);
-		// ⚠️ 只对**新出现的**分组应用默认折叠状态：已存在的分组保持用户当前的展开/折叠选择。
-		m_collapsed.resize(groupCount, m_groupsCollapsedByDefault);
-
-		for (std::size_t groupIndex = 0; groupIndex < groupCount; ++groupIndex)
-		{
-			const SignalGroup* group = dataSet.GroupAt(static_cast<int>(groupIndex));
-			if (group == nullptr)
-			{
-				continue;
-			}
-
-			// 新增信号默认为未勾选（由用户自行决定查看哪些信号），
-			// 其显示外观已在 DataSet 中初始化完毕。
-			m_visible[groupIndex].resize(group->signals.size(), false);
-		}
-
-		// 清理已失效的网格引用（选中状态由 DataSet 统一维护）。
-		for (Lane& lane : m_lanes)
-		{
-			std::vector<SignalRef>& refs = lane.signals;
-			refs.erase(std::remove_if(refs.begin(), refs.end(),
-			                          [&dataSet](const SignalRef& ref) { return dataSet.Resolve(ref) == nullptr; }),
-			           refs.end());
-		}
-		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
-		                             [](const Lane& lane) { return lane.signals.empty(); }),
-		              m_lanes.end());
-
-		SyncLanes();
-	}
-
-	void TabConfig::RemapAfterGroupRemoval(int groupIndex)
-	{
-		if (groupIndex < 0)
-		{
-			return;
-		}
-
-		const std::size_t slot = static_cast<std::size_t>(groupIndex);
-		if (slot < m_visible.size())
-		{
-			m_visible.erase(m_visible.begin() + groupIndex);
-		}
-		if (slot < m_collapsed.size())
-		{
-			m_collapsed.erase(m_collapsed.begin() + groupIndex);
-		}
-
-		for (Lane& lane : m_lanes)
-		{
-			std::vector<SignalRef>& refs = lane.signals;
-			refs.erase(std::remove_if(refs.begin(), refs.end(),
-			                          [groupIndex](const SignalRef& ref)
-			                          { return ref.groupIndex == groupIndex; }),
-			           refs.end());
-			for (SignalRef& ref : refs)
-			{
-				if (ref.groupIndex > groupIndex)
-				{
-					--ref.groupIndex;
-				}
-			}
-		}
-		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
-		                             [](const Lane& lane) { return lane.signals.empty(); }),
-		              m_lanes.end());
-	}
-
-	void TabConfig::RemapAfterSignalRemoval(int groupIndex, int signalIndex)
-	{
-		if (groupIndex < 0 || signalIndex < 0)
-		{
-			return;
-		}
-
-		// 可见性表：删掉该信号对应的那一列。
-		const std::size_t slot = static_cast<std::size_t>(groupIndex);
-		if (slot < m_visible.size())
-		{
-			std::vector<bool>& fileVisible = m_visible[slot];
-			if (static_cast<std::size_t>(signalIndex) < fileVisible.size())
-			{
-				fileVisible.erase(fileVisible.begin() + signalIndex);
-			}
-		}
-
-		// 网格归属：删掉该信号本身，并把同一分组内位于其后的引用下标前移一位。
-		for (Lane& lane : m_lanes)
-		{
-			std::vector<SignalRef>& refs = lane.signals;
-			refs.erase(std::remove_if(refs.begin(), refs.end(),
-			                          [groupIndex, signalIndex](const SignalRef& ref)
-			                          {
-				                          return ref.groupIndex == groupIndex &&
-				                                 ref.signalIndex == signalIndex;
-			                          }),
-			           refs.end());
-			for (SignalRef& ref : refs)
-			{
-				if (ref.groupIndex == groupIndex && ref.signalIndex > signalIndex)
-				{
-					--ref.signalIndex;
-				}
-			}
-
-			// 均值滤波 / 中心轴边沿计数 / 弱峰调整的条目同样持有信号引用，必须一起删除/前移。
-			// 三类条目都是「带 `ref` 的结构体」，因此用泛型 lambda 统一处理
-			//（弱峰调整的参数与均值滤波不同，不能再共用同一个具体类型）。
-			const auto purgeRefs = [groupIndex, signalIndex](auto& items)
-			{
-				using ItemType = typename std::decay_t<decltype(items)>::value_type;
-				items.erase(std::remove_if(items.begin(), items.end(),
-				                           [groupIndex, signalIndex](const ItemType& item)
-				                           {
-					                           return item.ref.groupIndex == groupIndex &&
-					                                  item.ref.signalIndex == signalIndex;
-				                           }),
-				            items.end());
-				for (ItemType& item : items)
-				{
-					if (item.ref.groupIndex == groupIndex && item.ref.signalIndex > signalIndex)
-					{
-						--item.ref.signalIndex;
-					}
-				}
-			};
-			purgeRefs(lane.meanFilterItems);
-			purgeRefs(lane.edgeCenterItems);
-			purgeRefs(lane.weakPeakItems);
-		}
-		// 被移除信号若独占了某个网格，该网格随之消失（与取消勾选的行为一致）。
-		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
-		                             [](const Lane& lane) { return lane.signals.empty(); }),
-		              m_lanes.end());
-	}
-
-	bool TabConfig::IsVisible(const SignalRef& ref) const
-	{
-		if (ref.groupIndex < 0 || static_cast<std::size_t>(ref.groupIndex) >= m_visible.size())
-		{
-			return false;
-		}
-		const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(ref.groupIndex)];
-		if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
-		{
-			return false;
-		}
-		return fileVisible[static_cast<std::size_t>(ref.signalIndex)];
-	}
-
-	void TabConfig::SetVisible(const SignalRef& ref, bool visible)
-	{
-		if (ref.groupIndex < 0 || static_cast<std::size_t>(ref.groupIndex) >= m_visible.size())
-		{
-			return;
-		}
-		std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(ref.groupIndex)];
-		if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
-		{
-			return;
-		}
-		if (fileVisible[static_cast<std::size_t>(ref.signalIndex)] == visible)
-		{
-			return;
-		}
-		fileVisible[static_cast<std::size_t>(ref.signalIndex)] = visible;
-
-		// 合并模式下新勾选的信号独占一个新网格：切到自定义划分后，
-		// RebuildLanes 会把尚未分配网格的可见信号各自放入新网格。
-		if (visible && m_laneMode == LaneMode::MERGED)
-		{
-			m_laneMode = LaneMode::CUSTOM;
-		}
-
-		SyncLanes();
-	}
-
-	void TabConfig::ToggleVisible(const SignalRef& ref)
-	{
-		SetVisible(ref, !IsVisible(ref));
-	}
-
-	void TabConfig::SetGroupVisible(int groupIndex, bool visible)
-	{
-		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_visible.size())
-		{
-			return;
-		}
-		std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(groupIndex)];
-		// 合并模式下“新增”的信号同样应各自独占网格（与 SetVisible 一致）：
-		// 先切到自定义划分，RebuildLanes 会把尚未分配网格的可见信号追加到最下方。
-		// 只有确实存在“原本不可见”的信号时才切模式，避免重复点击默默改掉划分策略。
-		const bool anyHidden =
-		    std::find(fileVisible.begin(), fileVisible.end(), false) != fileVisible.end();
-		if (visible && anyHidden && m_laneMode == LaneMode::MERGED)
-		{
-			m_laneMode = LaneMode::CUSTOM;
-		}
-		std::fill(fileVisible.begin(), fileVisible.end(), visible);
-		SyncLanes();
-	}
-
-	void TabConfig::SetAllVisible(bool visible)
-	{
-		bool anyHidden = false;
-		for (const std::vector<bool>& fileVisible : m_visible)
-		{
-			if (std::find(fileVisible.begin(), fileVisible.end(), false) != fileVisible.end())
-			{
-				anyHidden = true;
-				break;
-			}
-		}
-		// 同上：合并模式下新增的信号各自独占网格，且排列在最下方。
-		if (visible && anyHidden && m_laneMode == LaneMode::MERGED)
-		{
-			m_laneMode = LaneMode::CUSTOM;
-		}
-		for (std::vector<bool>& fileVisible : m_visible)
-		{
-			std::fill(fileVisible.begin(), fileVisible.end(), visible);
-		}
-		SyncLanes();
-	}
-
-	void TabConfig::SoloSignal(const SignalRef& ref)
-	{
-		for (std::vector<bool>& fileVisible : m_visible)
-		{
-			std::fill(fileVisible.begin(), fileVisible.end(), false);
-		}
-		SetVisible(ref, true);
-	}
-
-	bool TabConfig::GroupHasVisible(int groupIndex) const
-	{
-		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_visible.size())
-		{
-			return false;
-		}
-		const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(groupIndex)];
-		return std::find(fileVisible.begin(), fileVisible.end(), true) != fileVisible.end();
-	}
-
-	bool TabConfig::GroupAllVisible(int groupIndex) const
-	{
-		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_visible.size())
-		{
-			return false;
-		}
-		const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(groupIndex)];
-		if (fileVisible.empty())
-		{
-			return false;
-		}
-		return std::find(fileVisible.begin(), fileVisible.end(), false) == fileVisible.end();
-	}
-
-	bool TabConfig::AnyVisible() const
-	{
-		for (const std::vector<bool>& fileVisible : m_visible)
-		{
-			if (std::find(fileVisible.begin(), fileVisible.end(), true) != fileVisible.end())
-			{
-				return true;
-			}
-		}
-		return false;
-	}
-
-	int TabConfig::VisibleCount() const
-	{
-		int count = 0;
-		for (const std::vector<bool>& fileVisible : m_visible)
-		{
-			count += static_cast<int>(std::count(fileVisible.begin(), fileVisible.end(), true));
-		}
-		return count;
-	}
-
-	void TabConfig::SetMode(LaneMode mode)
-	{
-		m_laneMode = mode;
-		SyncLanes();
-	}
-
-	void TabConfig::SyncLanes()
-	{
-		RebuildLanes(m_visible, m_lanes, m_laneMode);
-	}
-
-	int TabConfig::LaneOfSignal(const SignalRef& ref) const
-	{
-		for (std::size_t lane = 0; lane < m_lanes.size(); ++lane)
-		{
-			const std::vector<SignalRef>& refs = m_lanes[lane].signals;
-			if (std::find(refs.begin(), refs.end(), ref) != refs.end())
-			{
-				return static_cast<int>(lane);
-			}
-		}
-		return -1;
-	}
-
-	int TabConfig::MoveSignalToLane(const DataSet& dataSet, const SignalRef& ref, int laneIndex)
-	{
-		if (dataSet.Resolve(ref) == nullptr)
-		{
-			return -1;
-		}
-
-		const int sourceLane = LaneOfSignal(ref);
-		if (laneIndex >= 0 && laneIndex == sourceLane)
-		{
-			// 拖回原网格：无需变动，避免因网格回收导致顺序抖动。
-			return sourceLane;
-		}
-
-		// 先把目标网格的“锚信号”固定下来：移除信号后空网格会被回收，
-		// 下标随之变化，必须用不依赖下标的引用找回真正的目标网格
-		// （否则会变成“与原网格交换位置”而不是合并进去）。
-		SignalRef targetAnchor;
-		bool hasTarget = (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()));
-		if (hasTarget)
-		{
-			const std::vector<SignalRef>& targetSignals = m_lanes[static_cast<std::size_t>(laneIndex)].signals;
-			for (const SignalRef& candidate : targetSignals)
-			{
-				if (!(candidate == ref))
-				{
-					targetAnchor = candidate;
-					break;
-				}
-			}
-		}
-
-		// 手动指定归属意味着切换到自定义划分策略。
-		m_laneMode = LaneMode::CUSTOM;
-
-		for (Lane& lane : m_lanes)
-		{
-			std::vector<SignalRef>& refs = lane.signals;
-			refs.erase(std::remove(refs.begin(), refs.end(), ref), refs.end());
-		}
-		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
-		                             [](const Lane& lane) { return lane.signals.empty(); }),
-		              m_lanes.end());
-
-		int destination = -1;
-		if (hasTarget && targetAnchor.IsValid())
-		{
-			for (std::size_t index = 0; index < m_lanes.size(); ++index)
-			{
-				const std::vector<SignalRef>& refs = m_lanes[index].signals;
-				if (std::find(refs.begin(), refs.end(), targetAnchor) != refs.end())
-				{
-					destination = static_cast<int>(index);
-					break;
-				}
-			}
-		}
-
-		if (destination >= 0)
-		{
-			m_lanes[static_cast<std::size_t>(destination)].signals.push_back(ref);
-		}
-		else
-		{
-			Lane lane;
-			lane.autoRange = true;
-			lane.signals.push_back(ref);
-			m_lanes.push_back(std::move(lane));
-		}
-
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
-		}
-		return LaneOfSignal(ref);
-	}
-
-	int TabConfig::SplitLane(int laneIndex)
-	{
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			return -1;
-		}
-		const std::vector<SignalRef> signals = m_lanes[static_cast<std::size_t>(laneIndex)].signals;
-		if (signals.size() <= 1)
-		{
-			// 只有一条信号时无需拆分（本就独占一个网格）。
-			return -1;
-		}
-
-		// 手动排布 → 切换到自定义划分策略。
-		m_laneMode = LaneMode::CUSTOM;
-
-		// 用原网格的“网格自身状态”（Y 轴自适应/边沿计数等）作为每一份的初始状态，
-		// 这样拆分出来的网格保持原网格的显示设置。
-		const Lane source = m_lanes[static_cast<std::size_t>(laneIndex)];
-
-		std::vector<Lane> pieces;
-		pieces.reserve(signals.size());
-		for (const SignalRef& ref : signals)
-		{
-			Lane lane;
-			lane.autoRange = source.autoRange;
-			lane.yMin = source.yMin;
-			lane.yMax = source.yMax;
-			lane.fitYToSelection = source.fitYToSelection;
-			lane.edgeCount = source.edgeCount;
-			lane.edgeValue = source.edgeValue;
-			lane.edgeValueValid = source.edgeValueValid;
-			lane.edgePanelOpen = source.edgePanelOpen;
-			lane.edgePanelX = source.edgePanelX;
-			lane.edgePanelY = source.edgePanelY;
-			lane.edgeCenter = source.edgeCenter;
-			lane.edgeCenterPanelOpen = source.edgeCenterPanelOpen;
-			lane.edgeCenterPanelX = source.edgeCenterPanelX;
-			lane.edgeCenterPanelY = source.edgeCenterPanelY;
-			lane.weakPeak = source.weakPeak;
-			lane.weakPeakPanelOpen = source.weakPeakPanelOpen;
-			lane.weakPeakPanelX = source.weakPeakPanelX;
-			lane.weakPeakPanelY = source.weakPeakPanelY;
-			lane.meanFilter = source.meanFilter;
-			lane.meanFilterPanelOpen = source.meanFilterPanelOpen;
-			lane.meanFilterPanelX = source.meanFilterPanelX;
-			lane.meanFilterPanelY = source.meanFilterPanelY;
-			// 拆分后每个子网格只保留自己那个信号的均值滤波 / 中心轴 / 弱峰调整条目。
-			lane.meanFilterItems.clear();
-			lane.edgeCenterItems.clear();
-			lane.weakPeakItems.clear();
-			for (const Lane::MeanFilterItem& item : source.meanFilterItems)
-			{
-				if (item.ref == ref)
-				{
-					lane.meanFilterItems.push_back(item);
-				}
-			}
-			for (const Lane::EdgeCenterItem& item : source.edgeCenterItems)
-			{
-				if (item.ref == ref)
-				{
-					lane.edgeCenterItems.push_back(item);
-				}
-			}
-			for (const Lane::WeakPeakItem& item : source.weakPeakItems)
-			{
-				if (item.ref == ref)
-				{
-					lane.weakPeakItems.push_back(item);
-				}
-			}
-			lane.signals.push_back(ref);
-			pieces.push_back(std::move(lane));
-		}
-		// 用 pieces 替换原网格（插入到原位置，因此其后方的网格整体顺次后移）。
-		m_lanes.erase(m_lanes.begin() + laneIndex);
-		m_lanes.insert(m_lanes.begin() + laneIndex, pieces.begin(), pieces.end());
-
-		// 统一重命名，保证编号连续（GX 编号在各显示位置均由此位置推导）。
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
-		}
-		return laneIndex;
-	}
-
-	void TabConfig::RemapAfterSignalInsert(int groupIndex, int insertPos)
-	{
-		if (groupIndex < 0 || insertPos < 0)
-		{
-			return;
-		}
-
-		// 可见性表：在插入点补一列（新信号默认不可见，由调用方按需勾选）。
-		const std::size_t slot = static_cast<std::size_t>(groupIndex);
-		if (slot < m_visible.size() && static_cast<std::size_t>(insertPos) <= m_visible[slot].size())
-		{
-			m_visible[slot].insert(m_visible[slot].begin() + insertPos, false);
-		}
-
-		// 网格内的信号引用：同一文件中位于插入点之后的引用下标整体后移。
-		for (Lane& lane : m_lanes)
-		{
-			for (SignalRef& ref : lane.signals)
-			{
-				if (ref.groupIndex == groupIndex && ref.signalIndex >= insertPos)
-				{
-					++ref.signalIndex;
-				}
-			}
-			// 均值滤波 / 中心轴条目同样持有信号引用，必须一起后移。
-			for (Lane::MeanFilterItem& item : lane.meanFilterItems)
-			{
-				if (item.ref.groupIndex == groupIndex && item.ref.signalIndex >= insertPos)
-				{
-					++item.ref.signalIndex;
-				}
-			}
-			for (Lane::EdgeCenterItem& item : lane.edgeCenterItems)
-			{
-				if (item.ref.groupIndex == groupIndex && item.ref.signalIndex >= insertPos)
-				{
-					++item.ref.signalIndex;
-				}
-			}
-			for (Lane::WeakPeakItem& item : lane.weakPeakItems)
-			{
-				if (item.ref.groupIndex == groupIndex && item.ref.signalIndex >= insertPos)
-				{
-					++item.ref.signalIndex;
-				}
-			}
-		}
-	}
-
-	bool TabConfig::MoveLaneOfSignalBelow(const SignalRef& moved, const SignalRef& anchor)
-	{
-		const int from = LaneOfSignal(moved);
-		if (from < 0 || LaneOfSignal(anchor) < 0)
-		{
-			return false;
-		}
-
-		Lane lane = std::move(m_lanes[static_cast<std::size_t>(from)]);
-		m_lanes.erase(m_lanes.begin() + from);
-
-		// erase 之后锚点网格的下标可能变化，必须用信号引用重新定位。
-		const int target = LaneOfSignal(anchor);
-		if (target < 0)
-		{
-			m_lanes.push_back(std::move(lane));
-		}
-		else
-		{
-			m_lanes.insert(m_lanes.begin() + target + 1, std::move(lane));
-		}
-
-		// 手动排布 → 切换到自定义划分策略，避免后续重建网格时顺序被还原。
-		m_laneMode = LaneMode::CUSTOM;
-		RenameLanes();
-		return true;
-	}
-
-	bool TabConfig::MoveLane(int from, int target)
-	{
-		const int count = static_cast<int>(m_lanes.size());
-		if (from < 0 || from >= count || target < 0 || target > count)
-		{
-			return false;
-		}
-
-		// `target` 语义 = 「插入到该下标之前」；向后拖时扣除自身占位后再比较，
-		// 保证"拖到自己原来的位置"不会产生无意义的移动。
-		int destination = target;
-		if (destination > from)
-		{
-			--destination;
-		}
-		destination = std::max(0, std::min(destination, count - 1));
-		if (destination == from)
-		{
-			return false;
-		}
-
-		Lane moved = std::move(m_lanes[static_cast<std::size_t>(from)]);
-		m_lanes.erase(m_lanes.begin() + from);
-		m_lanes.insert(m_lanes.begin() + destination, std::move(moved));
-
-		// 手动排布 → 切换到自定义划分策略，避免后续重建网格时顺序被还原。
-		m_laneMode = LaneMode::CUSTOM;
-		RenameLanes();
-		return true;
-	}
-
-	void TabConfig::RenameLanes()
-	{
-		for (std::size_t index = 0; index < m_lanes.size(); ++index)
-		{
-			m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
-		}
-	}
-
-	bool TabConfig::IsCollapsed(int groupIndex) const
-	{
-		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_collapsed.size())
-		{
-			return false;
-		}
-		return m_collapsed[static_cast<std::size_t>(groupIndex)];
-	}
-
-	void TabConfig::ToggleCollapsed(int groupIndex)
-	{
-		if (groupIndex < 0)
-		{
-			return;
-		}
-		if (static_cast<std::size_t>(groupIndex) >= m_collapsed.size())
-		{
-			m_collapsed.resize(static_cast<std::size_t>(groupIndex) + 1, m_groupsCollapsedByDefault);
-		}
-		m_collapsed[static_cast<std::size_t>(groupIndex)] = !m_collapsed[static_cast<std::size_t>(groupIndex)];
-	}
-
-	void TabConfig::ComputeLaneRange(const DataSet& dataSet, int laneIndex, double& yMin, double& yMax) const
-	{
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
-		{
-			yMin = 0.0;
-			yMax = 1.0;
-			return;
-		}
-
-		const Lane& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
-		if (!lane.autoRange)
-		{
-			yMin = lane.yMin;
-			yMax = lane.yMax;
-			if (!(yMax > yMin))
-			{
-				yMin = 0.0;
-				yMax = 1.0;
-			}
-			return;
-		}
-
-		double low = std::numeric_limits<double>::infinity();
-		double high = -std::numeric_limits<double>::infinity();
-		for (const SignalRef& ref : lane.signals)
-		{
-			if (!IsVisible(ref))
-			{
-				continue;
-			}
-			const SignalData* signal = dataSet.Resolve(ref);
-			if (signal == nullptr || signal->finiteCount == 0)
-			{
-				continue;
-			}
-			// ⚠️ 自适应必须基于**画出来的曲线**：先按绘制变换（系数 → 绝对值 → 镜像）把该信号的
-			// 原始值域映射成显示值域，否则调整系数/镜像后自适应范围仍按原始数据算（范围错误）。
-			const SignalStyle* style = dataSet.Style(ref);
-			double signalLow = signal->minValue;
-			double signalHigh = signal->maxValue;
-			if (style != nullptr)
-			{
-				TransformValueRange(*style, signalLow, signalHigh);
-			}
-			low = std::min(low, signalLow);
-			high = std::max(high, signalHigh);
-		}
-
-		if (!std::isfinite(low) || !std::isfinite(high))
-		{
-			low = 0.0;
-			high = 1.0;
-		}
-		PadRange(low, high);
-		yMin = low;
-		yMax = high;
-	}
-
-	bool TabConfig::ComputeVisibleTimeBounds(const DataSet& dataSet, double& minTime, double& maxTime) const
-	{
-		double low = std::numeric_limits<double>::infinity();
-		double high = -std::numeric_limits<double>::infinity();
-
-		for (std::size_t groupIndex = 0; groupIndex < m_visible.size(); ++groupIndex)
-		{
-			const std::vector<bool>& groupVisible = m_visible[groupIndex];
-			if (std::find(groupVisible.begin(), groupVisible.end(), true) == groupVisible.end())
-			{
-				continue;
-			}
-
-			const SignalGroup* group = dataSet.GroupAt(static_cast<int>(groupIndex));
-			if (group == nullptr)
-			{
-				continue;
-			}
-			// 只统计**可见信号**真正用到的时间轴：一个分组可能有多条时间轴
-			//（多 `time` 列 CSV / MF4 多通道组），把没显示的那些也算进来会让“适应视图”
-			// 拉出一个过宽的时间范围。
-			for (std::size_t signalIndex = 0; signalIndex < groupVisible.size() &&
-			                                      signalIndex < group->signals.size();
-			     ++signalIndex)
-			{
-				if (!groupVisible[signalIndex])
-				{
-					continue;
-				}
-				const TimeAxis& axis = group->AxisOf(group->signals[signalIndex]);
-				if (axis.finiteCount == 0)
-				{
-					continue;
-				}
-				low = std::min(low, axis.minTime);
-				high = std::max(high, axis.maxTime);
-			}
-		}
-
-		if (!std::isfinite(low) || !std::isfinite(high) || !(high > low))
-		{
-			return false;
-		}
-		minTime = low;
-		maxTime = high;
-		return true;
-	}
 
 } // namespace jdi
+
diff --git a/Utilities/Src/DataModelInternal.hpp b/Utilities/Src/DataModelInternal.hpp
new file mode 100644
index 0000000..a088325
--- /dev/null
+++ b/Utilities/Src/DataModelInternal.hpp
@@ -0,0 +1,352 @@
+#ifndef __DATAMODEL_INTERNAL_HPP__
+#define __DATAMODEL_INTERNAL_HPP__
+
+// DataModel 组件内部共享的常量与工具函数（私有头，仅本组件的 .cpp 使用）。
+//
+// 本组件的实现按功能拆成多个协作文件，它们共用这一份内部工具集。
+//
+// ⚠️ 为让多个翻译单元都能使用，原匿名命名空间改为**具名**命名空间 `dmdetail`，
+//    并把其中每个函数与常量标为 `inline` —— 单一定义、单一副本，不会产生代码重复。
+//    各实现文件在包含本头之后用 `using namespace dmdetail;` 引入这些工具，
+//    因此函数体里原有的非限定调用一行都不用改。
+
+#include <windows.h>
+#include <objidl.h>
+#include <gdiplus.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <cwctype>
+#include <deque>
+#include <limits>
+#include <new>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "DataModel.hpp"
+#include "Theme.hpp"
+#include "Utf8Util.hpp"
+
+namespace jdi
+{
+
+	namespace dmdetail
+	{
+	/**
+	 * @brief DataModel 内部工具集（常量与自由函数）。
+	 *
+	 * 全部符号都是 `inline` ⇒ 多个翻译单元共用同一个定义：既不重复符号，也不产生多份代码。
+	 * 不要把它们移回匿名命名空间（那样每个 .cpp 都会各自复制一份）。
+	 */
+		inline const double kMissing = std::numeric_limits<double>::quiet_NaN();	/**< 缺失值占位。 */
+		inline const double kDefaultLineWidth = 1.6;								/**< 默认线宽。 */
+
+		/**
+		 * @brief 为网格范围补充留白，避免波形紧贴边界。
+		 *
+		 * ⚠️ 实际规则实现在 `DataModel.hpp` 的 `PadValueRange()`：它同时被
+		 * 「选区 Y 轴自适应」使用，两处必须逐位一致（否则两种自适应会算出不同区间）。
+		 *
+		 * @param [IN, OUT] yMin 范围下限。
+		 * @param [IN, OUT] yMax 范围上限。
+		 */
+		inline void PadRange(double& yMin, double& yMax)
+		{
+			PadValueRange(yMin, yMax);
+		}
+
+		/**
+		 * @brief 依据全部可见信号重新生成网格划分。
+		 * @param [IN] visible 各信号的可见性（按 [分组][信号] 索引）。
+		 * @param [IN] lanes 网格集合（原地更新）。
+		 * @param [IN] mode 网格划分策略。
+		 */
+		inline void RebuildLanes(const std::vector<std::vector<bool>>& visible, std::vector<Lane>& lanes,
+		                  LaneMode mode)
+		{
+			// 随网格携带的“网格自身状态”（按信号继承）：重建网格时不能丢。
+			struct LaneCarry
+			{
+				bool matched = false;		/**< 是否找到该信号原本所在的网格（false = 新出现的信号）。 */
+				bool fitYToSelection = false;
+				bool edgeCount = false;
+				double edgeValue = 0.0;
+				bool edgeValueValid = false;
+				bool edgePanelOpen = true;
+				double edgePanelX = -1.0;
+				double edgePanelY = -1.0;
+				bool edgeCenter = false;
+				std::vector<Lane::EdgeCenterItem> edgeCenterItems;
+				bool edgeCenterPanelOpen = true;
+				double edgeCenterPanelX = -1.0;
+				double edgeCenterPanelY = -1.0;
+				bool meanFilter = false;
+				std::vector<Lane::MeanFilterItem> meanFilterItems;
+				bool meanFilterPanelOpen = true;
+				double meanFilterPanelX = -1.0;
+				double meanFilterPanelY = -1.0;
+				bool weakPeak = false;
+				std::vector<Lane::WeakPeakItem> weakPeakItems;
+				bool weakPeakPanelOpen = true;
+				double weakPeakPanelX = -1.0;
+				double weakPeakPanelY = -1.0;
+			};
+
+			// 先记下每个信号原来所在网格的网格自身状态：
+			// 勾选可见性会重建网格，若不携带，用户刚打开的开关会被悄悄清掉。
+			//
+			// ⚠️ 同时记下「重建之前是否**每个**网格都开着 `fitYToSelection`」：
+			// 那就是「全局 Y 轴自适应」的正式定义。新勾选信号产生的**新网格**必须继承它，
+			// 否则全局开关看着是开的、新网格却不按当前视界自适应（用户报告的缺陷）。
+			bool previousAllAutoFit = !lanes.empty();
+			for (const Lane& lane : lanes)
+			{
+				if (!lane.fitYToSelection)
+				{
+					previousAllAutoFit = false;
+					break;
+				}
+			}
+
+			std::vector<std::pair<SignalRef, LaneCarry>> previousCarry;
+			for (const Lane& lane : lanes)
+			{
+				LaneCarry carry;
+				carry.matched = true;
+				carry.fitYToSelection = lane.fitYToSelection;
+				carry.edgeCount = lane.edgeCount;
+				carry.edgeValue = lane.edgeValue;
+				carry.edgeValueValid = lane.edgeValueValid;
+				carry.edgePanelOpen = lane.edgePanelOpen;
+				carry.edgePanelX = lane.edgePanelX;
+				carry.edgePanelY = lane.edgePanelY;
+				carry.edgeCenter = lane.edgeCenter;
+				carry.edgeCenterItems = lane.edgeCenterItems;
+				carry.edgeCenterPanelOpen = lane.edgeCenterPanelOpen;
+				carry.edgeCenterPanelX = lane.edgeCenterPanelX;
+				carry.edgeCenterPanelY = lane.edgeCenterPanelY;
+				carry.meanFilter = lane.meanFilter;
+				carry.meanFilterItems = lane.meanFilterItems;
+				carry.meanFilterPanelOpen = lane.meanFilterPanelOpen;
+				carry.meanFilterPanelX = lane.meanFilterPanelX;
+				carry.meanFilterPanelY = lane.meanFilterPanelY;
+				carry.weakPeak = lane.weakPeak;
+				carry.weakPeakItems = lane.weakPeakItems;
+				carry.weakPeakPanelOpen = lane.weakPeakPanelOpen;
+				carry.weakPeakPanelX = lane.weakPeakPanelX;
+				carry.weakPeakPanelY = lane.weakPeakPanelY;
+				for (const SignalRef& ref : lane.signals)
+				{
+					previousCarry.emplace_back(ref, carry);
+				}
+			}
+			const auto inheritedCarry = [&previousCarry](const SignalRef& ref)
+			{
+				for (const std::pair<SignalRef, LaneCarry>& entry : previousCarry)
+				{
+					if (entry.first == ref)
+					{
+						return entry.second;
+					}
+				}
+				return LaneCarry();
+			};
+			const auto applyCarry = [&inheritedCarry, previousAllAutoFit](Lane& lane, const SignalRef& ref)
+			{
+				const LaneCarry carry = inheritedCarry(ref);
+				// 新出现的信号（之前没有网格）：继承「全局 Y 轴自适应」是否开启。
+				lane.fitYToSelection = carry.matched ? carry.fitYToSelection : previousAllAutoFit;
+				lane.edgeCount = carry.edgeCount;
+				lane.edgeValue = carry.edgeValue;
+				lane.edgeValueValid = carry.edgeValueValid;
+				lane.edgePanelOpen = carry.edgePanelOpen;
+				lane.edgePanelX = carry.edgePanelX;
+				lane.edgePanelY = carry.edgePanelY;
+				lane.edgeCenter = carry.edgeCenter;
+				lane.edgeCenterItems = carry.edgeCenterItems;
+				lane.edgeCenterPanelOpen = carry.edgeCenterPanelOpen;
+				lane.edgeCenterPanelX = carry.edgeCenterPanelX;
+				lane.edgeCenterPanelY = carry.edgeCenterPanelY;
+				lane.meanFilter = carry.meanFilter;
+				lane.meanFilterItems = carry.meanFilterItems;
+				lane.meanFilterPanelOpen = carry.meanFilterPanelOpen;
+				lane.meanFilterPanelX = carry.meanFilterPanelX;
+				lane.meanFilterPanelY = carry.meanFilterPanelY;
+				lane.weakPeak = carry.weakPeak;
+				lane.weakPeakItems = carry.weakPeakItems;
+				lane.weakPeakPanelOpen = carry.weakPeakPanelOpen;
+				lane.weakPeakPanelX = carry.weakPeakPanelX;
+				lane.weakPeakPanelY = carry.weakPeakPanelY;
+			};
+
+			// 收集全部可见信号引用。
+			std::vector<SignalRef> visibleRefs;
+			for (std::size_t groupIndex = 0; groupIndex < visible.size(); ++groupIndex)
+			{
+				for (std::size_t signalIndex = 0; signalIndex < visible[groupIndex].size(); ++signalIndex)
+				{
+					if (visible[groupIndex][signalIndex])
+					{
+						SignalRef ref;
+						ref.groupIndex = static_cast<int>(groupIndex);
+						ref.signalIndex = static_cast<int>(signalIndex);
+						visibleRefs.push_back(ref);
+					}
+				}
+			}
+
+			// 判断某引用对应的信号是否可见（越界视为不可见）。
+			const auto isVisibleRef = [&visible](const SignalRef& ref)
+			{
+				if (ref.groupIndex < 0 || static_cast<std::size_t>(ref.groupIndex) >= visible.size())
+				{
+					return false;
+				}
+				const std::vector<bool>& fileVisible = visible[static_cast<std::size_t>(ref.groupIndex)];
+				if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
+				{
+					return false;
+				}
+				return fileVisible[static_cast<std::size_t>(ref.signalIndex)];
+			};
+
+			// 某信号当前所属的网格下标（-1 表示尚未分配网格）。
+			const auto laneIndexOf = [&lanes](const SignalRef& ref)
+			{
+				for (std::size_t index = 0; index < lanes.size(); ++index)
+				{
+					const std::vector<SignalRef>& refs = lanes[index].signals;
+					if (std::find(refs.begin(), refs.end(), ref) != refs.end())
+					{
+						return static_cast<int>(index);
+					}
+				}
+				return -1;
+			};
+
+			if (mode == LaneMode::PER_SIGNAL)
+			{
+				// 每条可见信号独占一个网格：网格数量严格跟随可见信号数量。
+				// **顺序按"原有网格位置"优先**：已经分配过网格的信号保持其相对次序，
+				// 新勾选（此前没有网格）的信号统一追加到最下方。
+				// 若直接按 visibleRefs（文件/列序）重建，新勾选的信号会按其列序
+				// 插到中间，位置看起来"不确定"。
+				std::vector<SignalRef> ordered;
+				ordered.reserve(visibleRefs.size());
+				for (const SignalRef& ref : visibleRefs)
+				{
+					if (laneIndexOf(ref) >= 0)
+					{
+						ordered.push_back(ref);
+					}
+				}
+				std::stable_sort(ordered.begin(), ordered.end(),
+				                 [&laneIndexOf](const SignalRef& a, const SignalRef& b)
+				                 { return laneIndexOf(a) < laneIndexOf(b); });
+				for (const SignalRef& ref : visibleRefs)
+				{
+					if (laneIndexOf(ref) < 0)
+					{
+						ordered.push_back(ref);
+					}
+				}
+
+				lanes.clear();
+				lanes.reserve(ordered.size());
+				for (const SignalRef& ref : ordered)
+				{
+					Lane lane;
+					lane.autoRange = true;
+					applyCarry(lane, ref);
+					lane.signals.push_back(ref);
+					lanes.push_back(std::move(lane));
+				}
+			}
+			else if (mode == LaneMode::MERGED)
+			{
+				// 全部可见信号合并到同一网格；无可见信号时不保留空网格。
+				bool previousAutoRange = true;
+				double previousYMin = -1.0;
+				double previousYMax = 1.0;
+				if (lanes.size() == 1)
+				{
+					previousAutoRange = lanes[0].autoRange;
+					previousYMin = lanes[0].yMin;
+					previousYMax = lanes[0].yMax;
+				}
+
+				lanes.clear();
+				if (!visibleRefs.empty())
+				{
+					Lane lane;
+					lane.autoRange = previousAutoRange;
+					lane.yMin = previousYMin;
+					lane.yMax = previousYMax;
+					applyCarry(lane, visibleRefs.front());
+					lane.signals = visibleRefs;
+					lanes.push_back(std::move(lane));
+				}
+			}
+			else
+			{
+				// 自定义划分：仅移除不可见信号与由此产生的空网格，保持用户排布。
+				for (Lane& lane : lanes)
+				{
+					std::vector<SignalRef>& refs = lane.signals;
+					refs.erase(std::remove_if(refs.begin(), refs.end(),
+					                          [&isVisibleRef](const SignalRef& ref)
+					                          { return !isVisibleRef(ref); }),
+					            refs.end());
+				}
+
+				lanes.erase(std::remove_if(lanes.begin(), lanes.end(),
+				                           [](const Lane& lane) { return lane.signals.empty(); }),
+				            lanes.end());
+
+				// 未分配网格的可见信号各自独占一个新网格。
+				// 注意：不能把它们塞进已有的第一个网格——那会导致“拖拽合并后新勾选的信号
+				// 被悄悄并入合并网格”，用户看不到新增的独立泳道。
+				for (const SignalRef& ref : visibleRefs)
+				{
+					bool placed = false;
+					for (const Lane& lane : lanes)
+					{
+						if (std::find(lane.signals.begin(), lane.signals.end(), ref) != lane.signals.end())
+						{
+							placed = true;
+							break;
+						}
+					}
+					if (placed)
+					{
+						continue;
+					}
+
+					Lane lane;
+					lane.autoRange = true;
+					applyCarry(lane, ref);
+					lane.signals.push_back(ref);
+					lanes.push_back(std::move(lane));
+				}
+			}
+
+			// 统一重命名，保证编号连续。
+			for (std::size_t index = 0; index < lanes.size(); ++index)
+			{
+				lanes[index].name = L"网格 " + std::to_wstring(index + 1);
+			}
+		}
+	} // namespace dmdetail
+
+	using namespace dmdetail;
+
+} // namespace jdi
+
+#endif // __DATAMODEL_INTERNAL_HPP__
+
diff --git a/Utilities/Src/DataModelTab.cpp b/Utilities/Src/DataModelTab.cpp
new file mode 100644
index 0000000..8d37bfe
--- /dev/null
+++ b/Utilities/Src/DataModelTab.cpp
@@ -0,0 +1,732 @@
+// DataModel 实现分片 —— 本文件只包含 DataModel 的**成员函数定义**（纯代码搬移，行为与拆分前完全一致）。
+//
+// 共用的常量与自由函数在 DataModelInternal.hpp（命名空间 `dmdetail`，全部 inline）。
+// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
+#include "DataModelInternal.hpp"
+
+namespace jdi
+{
+
+	TabConfig::TabConfig()
+	    : m_name(L"视图 1")
+	{
+	}
+
+	void TabConfig::SyncToDataSet(const DataSet& dataSet)
+	{
+		const std::size_t groupCount = dataSet.GroupCount();
+		m_visible.resize(groupCount);
+		// ⚠️ 只对**新出现的**分组应用默认折叠状态：已存在的分组保持用户当前的展开/折叠选择。
+		m_collapsed.resize(groupCount, m_groupsCollapsedByDefault);
+
+		for (std::size_t groupIndex = 0; groupIndex < groupCount; ++groupIndex)
+		{
+			const SignalGroup* group = dataSet.GroupAt(static_cast<int>(groupIndex));
+			if (group == nullptr)
+			{
+				continue;
+			}
+
+			// 新增信号默认为未勾选（由用户自行决定查看哪些信号），
+			// 其显示外观已在 DataSet 中初始化完毕。
+			m_visible[groupIndex].resize(group->signals.size(), false);
+		}
+
+		// 清理已失效的网格引用（选中状态由 DataSet 统一维护）。
+		for (Lane& lane : m_lanes)
+		{
+			std::vector<SignalRef>& refs = lane.signals;
+			refs.erase(std::remove_if(refs.begin(), refs.end(),
+			                          [&dataSet](const SignalRef& ref) { return dataSet.Resolve(ref) == nullptr; }),
+			           refs.end());
+		}
+		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
+		                             [](const Lane& lane) { return lane.signals.empty(); }),
+		              m_lanes.end());
+
+		SyncLanes();
+	}
+
+	void TabConfig::RemapAfterGroupRemoval(int groupIndex)
+	{
+		if (groupIndex < 0)
+		{
+			return;
+		}
+
+		const std::size_t slot = static_cast<std::size_t>(groupIndex);
+		if (slot < m_visible.size())
+		{
+			m_visible.erase(m_visible.begin() + groupIndex);
+		}
+		if (slot < m_collapsed.size())
+		{
+			m_collapsed.erase(m_collapsed.begin() + groupIndex);
+		}
+
+		for (Lane& lane : m_lanes)
+		{
+			std::vector<SignalRef>& refs = lane.signals;
+			refs.erase(std::remove_if(refs.begin(), refs.end(),
+			                          [groupIndex](const SignalRef& ref)
+			                          { return ref.groupIndex == groupIndex; }),
+			           refs.end());
+			for (SignalRef& ref : refs)
+			{
+				if (ref.groupIndex > groupIndex)
+				{
+					--ref.groupIndex;
+				}
+			}
+		}
+		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
+		                             [](const Lane& lane) { return lane.signals.empty(); }),
+		              m_lanes.end());
+	}
+
+	void TabConfig::RemapAfterSignalRemoval(int groupIndex, int signalIndex)
+	{
+		if (groupIndex < 0 || signalIndex < 0)
+		{
+			return;
+		}
+
+		// 可见性表：删掉该信号对应的那一列。
+		const std::size_t slot = static_cast<std::size_t>(groupIndex);
+		if (slot < m_visible.size())
+		{
+			std::vector<bool>& fileVisible = m_visible[slot];
+			if (static_cast<std::size_t>(signalIndex) < fileVisible.size())
+			{
+				fileVisible.erase(fileVisible.begin() + signalIndex);
+			}
+		}
+
+		// 网格归属：删掉该信号本身，并把同一分组内位于其后的引用下标前移一位。
+		for (Lane& lane : m_lanes)
+		{
+			std::vector<SignalRef>& refs = lane.signals;
+			refs.erase(std::remove_if(refs.begin(), refs.end(),
+			                          [groupIndex, signalIndex](const SignalRef& ref)
+			                          {
+				                          return ref.groupIndex == groupIndex &&
+				                                 ref.signalIndex == signalIndex;
+			                          }),
+			           refs.end());
+			for (SignalRef& ref : refs)
+			{
+				if (ref.groupIndex == groupIndex && ref.signalIndex > signalIndex)
+				{
+					--ref.signalIndex;
+				}
+			}
+
+			// 均值滤波 / 中心轴边沿计数 / 弱峰调整的条目同样持有信号引用，必须一起删除/前移。
+			// 三类条目都是「带 `ref` 的结构体」，因此用泛型 lambda 统一处理
+			//（弱峰调整的参数与均值滤波不同，不能再共用同一个具体类型）。
+			const auto purgeRefs = [groupIndex, signalIndex](auto& items)
+			{
+				using ItemType = typename std::decay_t<decltype(items)>::value_type;
+				items.erase(std::remove_if(items.begin(), items.end(),
+				                           [groupIndex, signalIndex](const ItemType& item)
+				                           {
+					                           return item.ref.groupIndex == groupIndex &&
+					                                  item.ref.signalIndex == signalIndex;
+				                           }),
+				            items.end());
+				for (ItemType& item : items)
+				{
+					if (item.ref.groupIndex == groupIndex && item.ref.signalIndex > signalIndex)
+					{
+						--item.ref.signalIndex;
+					}
+				}
+			};
+			purgeRefs(lane.meanFilterItems);
+			purgeRefs(lane.edgeCenterItems);
+			purgeRefs(lane.weakPeakItems);
+		}
+		// 被移除信号若独占了某个网格，该网格随之消失（与取消勾选的行为一致）。
+		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
+		                             [](const Lane& lane) { return lane.signals.empty(); }),
+		              m_lanes.end());
+	}
+
+	bool TabConfig::IsVisible(const SignalRef& ref) const
+	{
+		if (ref.groupIndex < 0 || static_cast<std::size_t>(ref.groupIndex) >= m_visible.size())
+		{
+			return false;
+		}
+		const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(ref.groupIndex)];
+		if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
+		{
+			return false;
+		}
+		return fileVisible[static_cast<std::size_t>(ref.signalIndex)];
+	}
+
+	void TabConfig::SetVisible(const SignalRef& ref, bool visible)
+	{
+		if (ref.groupIndex < 0 || static_cast<std::size_t>(ref.groupIndex) >= m_visible.size())
+		{
+			return;
+		}
+		std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(ref.groupIndex)];
+		if (ref.signalIndex < 0 || static_cast<std::size_t>(ref.signalIndex) >= fileVisible.size())
+		{
+			return;
+		}
+		if (fileVisible[static_cast<std::size_t>(ref.signalIndex)] == visible)
+		{
+			return;
+		}
+		fileVisible[static_cast<std::size_t>(ref.signalIndex)] = visible;
+
+		// 合并模式下新勾选的信号独占一个新网格：切到自定义划分后，
+		// RebuildLanes 会把尚未分配网格的可见信号各自放入新网格。
+		if (visible && m_laneMode == LaneMode::MERGED)
+		{
+			m_laneMode = LaneMode::CUSTOM;
+		}
+
+		SyncLanes();
+	}
+
+	void TabConfig::ToggleVisible(const SignalRef& ref)
+	{
+		SetVisible(ref, !IsVisible(ref));
+	}
+
+	void TabConfig::SetGroupVisible(int groupIndex, bool visible)
+	{
+		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_visible.size())
+		{
+			return;
+		}
+		std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(groupIndex)];
+		// 合并模式下“新增”的信号同样应各自独占网格（与 SetVisible 一致）：
+		// 先切到自定义划分，RebuildLanes 会把尚未分配网格的可见信号追加到最下方。
+		// 只有确实存在“原本不可见”的信号时才切模式，避免重复点击默默改掉划分策略。
+		const bool anyHidden =
+		    std::find(fileVisible.begin(), fileVisible.end(), false) != fileVisible.end();
+		if (visible && anyHidden && m_laneMode == LaneMode::MERGED)
+		{
+			m_laneMode = LaneMode::CUSTOM;
+		}
+		std::fill(fileVisible.begin(), fileVisible.end(), visible);
+		SyncLanes();
+	}
+
+	void TabConfig::SetAllVisible(bool visible)
+	{
+		bool anyHidden = false;
+		for (const std::vector<bool>& fileVisible : m_visible)
+		{
+			if (std::find(fileVisible.begin(), fileVisible.end(), false) != fileVisible.end())
+			{
+				anyHidden = true;
+				break;
+			}
+		}
+		// 同上：合并模式下新增的信号各自独占网格，且排列在最下方。
+		if (visible && anyHidden && m_laneMode == LaneMode::MERGED)
+		{
+			m_laneMode = LaneMode::CUSTOM;
+		}
+		for (std::vector<bool>& fileVisible : m_visible)
+		{
+			std::fill(fileVisible.begin(), fileVisible.end(), visible);
+		}
+		SyncLanes();
+	}
+
+	void TabConfig::SoloSignal(const SignalRef& ref)
+	{
+		for (std::vector<bool>& fileVisible : m_visible)
+		{
+			std::fill(fileVisible.begin(), fileVisible.end(), false);
+		}
+		SetVisible(ref, true);
+	}
+
+	bool TabConfig::GroupHasVisible(int groupIndex) const
+	{
+		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_visible.size())
+		{
+			return false;
+		}
+		const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(groupIndex)];
+		return std::find(fileVisible.begin(), fileVisible.end(), true) != fileVisible.end();
+	}
+
+	bool TabConfig::GroupAllVisible(int groupIndex) const
+	{
+		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_visible.size())
+		{
+			return false;
+		}
+		const std::vector<bool>& fileVisible = m_visible[static_cast<std::size_t>(groupIndex)];
+		if (fileVisible.empty())
+		{
+			return false;
+		}
+		return std::find(fileVisible.begin(), fileVisible.end(), false) == fileVisible.end();
+	}
+
+	bool TabConfig::AnyVisible() const
+	{
+		for (const std::vector<bool>& fileVisible : m_visible)
+		{
+			if (std::find(fileVisible.begin(), fileVisible.end(), true) != fileVisible.end())
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	int TabConfig::VisibleCount() const
+	{
+		int count = 0;
+		for (const std::vector<bool>& fileVisible : m_visible)
+		{
+			count += static_cast<int>(std::count(fileVisible.begin(), fileVisible.end(), true));
+		}
+		return count;
+	}
+
+	void TabConfig::SetMode(LaneMode mode)
+	{
+		m_laneMode = mode;
+		SyncLanes();
+	}
+
+	void TabConfig::SyncLanes()
+	{
+		RebuildLanes(m_visible, m_lanes, m_laneMode);
+	}
+
+	int TabConfig::LaneOfSignal(const SignalRef& ref) const
+	{
+		for (std::size_t lane = 0; lane < m_lanes.size(); ++lane)
+		{
+			const std::vector<SignalRef>& refs = m_lanes[lane].signals;
+			if (std::find(refs.begin(), refs.end(), ref) != refs.end())
+			{
+				return static_cast<int>(lane);
+			}
+		}
+		return -1;
+	}
+
+	int TabConfig::MoveSignalToLane(const DataSet& dataSet, const SignalRef& ref, int laneIndex)
+	{
+		if (dataSet.Resolve(ref) == nullptr)
+		{
+			return -1;
+		}
+
+		const int sourceLane = LaneOfSignal(ref);
+		if (laneIndex >= 0 && laneIndex == sourceLane)
+		{
+			// 拖回原网格：无需变动，避免因网格回收导致顺序抖动。
+			return sourceLane;
+		}
+
+		// 先把目标网格的“锚信号”固定下来：移除信号后空网格会被回收，
+		// 下标随之变化，必须用不依赖下标的引用找回真正的目标网格
+		// （否则会变成“与原网格交换位置”而不是合并进去）。
+		SignalRef targetAnchor;
+		bool hasTarget = (laneIndex >= 0 && laneIndex < static_cast<int>(m_lanes.size()));
+		if (hasTarget)
+		{
+			const std::vector<SignalRef>& targetSignals = m_lanes[static_cast<std::size_t>(laneIndex)].signals;
+			for (const SignalRef& candidate : targetSignals)
+			{
+				if (!(candidate == ref))
+				{
+					targetAnchor = candidate;
+					break;
+				}
+			}
+		}
+
+		// 手动指定归属意味着切换到自定义划分策略。
+		m_laneMode = LaneMode::CUSTOM;
+
+		for (Lane& lane : m_lanes)
+		{
+			std::vector<SignalRef>& refs = lane.signals;
+			refs.erase(std::remove(refs.begin(), refs.end(), ref), refs.end());
+		}
+		m_lanes.erase(std::remove_if(m_lanes.begin(), m_lanes.end(),
+		                             [](const Lane& lane) { return lane.signals.empty(); }),
+		              m_lanes.end());
+
+		int destination = -1;
+		if (hasTarget && targetAnchor.IsValid())
+		{
+			for (std::size_t index = 0; index < m_lanes.size(); ++index)
+			{
+				const std::vector<SignalRef>& refs = m_lanes[index].signals;
+				if (std::find(refs.begin(), refs.end(), targetAnchor) != refs.end())
+				{
+					destination = static_cast<int>(index);
+					break;
+				}
+			}
+		}
+
+		if (destination >= 0)
+		{
+			m_lanes[static_cast<std::size_t>(destination)].signals.push_back(ref);
+		}
+		else
+		{
+			Lane lane;
+			lane.autoRange = true;
+			lane.signals.push_back(ref);
+			m_lanes.push_back(std::move(lane));
+		}
+
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
+		}
+		return LaneOfSignal(ref);
+	}
+
+	int TabConfig::SplitLane(int laneIndex)
+	{
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			return -1;
+		}
+		const std::vector<SignalRef> signals = m_lanes[static_cast<std::size_t>(laneIndex)].signals;
+		if (signals.size() <= 1)
+		{
+			// 只有一条信号时无需拆分（本就独占一个网格）。
+			return -1;
+		}
+
+		// 手动排布 → 切换到自定义划分策略。
+		m_laneMode = LaneMode::CUSTOM;
+
+		// 用原网格的“网格自身状态”（Y 轴自适应/边沿计数等）作为每一份的初始状态，
+		// 这样拆分出来的网格保持原网格的显示设置。
+		const Lane source = m_lanes[static_cast<std::size_t>(laneIndex)];
+
+		std::vector<Lane> pieces;
+		pieces.reserve(signals.size());
+		for (const SignalRef& ref : signals)
+		{
+			Lane lane;
+			lane.autoRange = source.autoRange;
+			lane.yMin = source.yMin;
+			lane.yMax = source.yMax;
+			lane.fitYToSelection = source.fitYToSelection;
+			lane.edgeCount = source.edgeCount;
+			lane.edgeValue = source.edgeValue;
+			lane.edgeValueValid = source.edgeValueValid;
+			lane.edgePanelOpen = source.edgePanelOpen;
+			lane.edgePanelX = source.edgePanelX;
+			lane.edgePanelY = source.edgePanelY;
+			lane.edgeCenter = source.edgeCenter;
+			lane.edgeCenterPanelOpen = source.edgeCenterPanelOpen;
+			lane.edgeCenterPanelX = source.edgeCenterPanelX;
+			lane.edgeCenterPanelY = source.edgeCenterPanelY;
+			lane.weakPeak = source.weakPeak;
+			lane.weakPeakPanelOpen = source.weakPeakPanelOpen;
+			lane.weakPeakPanelX = source.weakPeakPanelX;
+			lane.weakPeakPanelY = source.weakPeakPanelY;
+			lane.meanFilter = source.meanFilter;
+			lane.meanFilterPanelOpen = source.meanFilterPanelOpen;
+			lane.meanFilterPanelX = source.meanFilterPanelX;
+			lane.meanFilterPanelY = source.meanFilterPanelY;
+			// 拆分后每个子网格只保留自己那个信号的均值滤波 / 中心轴 / 弱峰调整条目。
+			lane.meanFilterItems.clear();
+			lane.edgeCenterItems.clear();
+			lane.weakPeakItems.clear();
+			for (const Lane::MeanFilterItem& item : source.meanFilterItems)
+			{
+				if (item.ref == ref)
+				{
+					lane.meanFilterItems.push_back(item);
+				}
+			}
+			for (const Lane::EdgeCenterItem& item : source.edgeCenterItems)
+			{
+				if (item.ref == ref)
+				{
+					lane.edgeCenterItems.push_back(item);
+				}
+			}
+			for (const Lane::WeakPeakItem& item : source.weakPeakItems)
+			{
+				if (item.ref == ref)
+				{
+					lane.weakPeakItems.push_back(item);
+				}
+			}
+			lane.signals.push_back(ref);
+			pieces.push_back(std::move(lane));
+		}
+		// 用 pieces 替换原网格（插入到原位置，因此其后方的网格整体顺次后移）。
+		m_lanes.erase(m_lanes.begin() + laneIndex);
+		m_lanes.insert(m_lanes.begin() + laneIndex, pieces.begin(), pieces.end());
+
+		// 统一重命名，保证编号连续（GX 编号在各显示位置均由此位置推导）。
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
+		}
+		return laneIndex;
+	}
+
+	void TabConfig::RemapAfterSignalInsert(int groupIndex, int insertPos)
+	{
+		if (groupIndex < 0 || insertPos < 0)
+		{
+			return;
+		}
+
+		// 可见性表：在插入点补一列（新信号默认不可见，由调用方按需勾选）。
+		const std::size_t slot = static_cast<std::size_t>(groupIndex);
+		if (slot < m_visible.size() && static_cast<std::size_t>(insertPos) <= m_visible[slot].size())
+		{
+			m_visible[slot].insert(m_visible[slot].begin() + insertPos, false);
+		}
+
+		// 网格内的信号引用：同一文件中位于插入点之后的引用下标整体后移。
+		for (Lane& lane : m_lanes)
+		{
+			for (SignalRef& ref : lane.signals)
+			{
+				if (ref.groupIndex == groupIndex && ref.signalIndex >= insertPos)
+				{
+					++ref.signalIndex;
+				}
+			}
+			// 均值滤波 / 中心轴条目同样持有信号引用，必须一起后移。
+			for (Lane::MeanFilterItem& item : lane.meanFilterItems)
+			{
+				if (item.ref.groupIndex == groupIndex && item.ref.signalIndex >= insertPos)
+				{
+					++item.ref.signalIndex;
+				}
+			}
+			for (Lane::EdgeCenterItem& item : lane.edgeCenterItems)
+			{
+				if (item.ref.groupIndex == groupIndex && item.ref.signalIndex >= insertPos)
+				{
+					++item.ref.signalIndex;
+				}
+			}
+			for (Lane::WeakPeakItem& item : lane.weakPeakItems)
+			{
+				if (item.ref.groupIndex == groupIndex && item.ref.signalIndex >= insertPos)
+				{
+					++item.ref.signalIndex;
+				}
+			}
+		}
+	}
+
+	bool TabConfig::MoveLaneOfSignalBelow(const SignalRef& moved, const SignalRef& anchor)
+	{
+		const int from = LaneOfSignal(moved);
+		if (from < 0 || LaneOfSignal(anchor) < 0)
+		{
+			return false;
+		}
+
+		Lane lane = std::move(m_lanes[static_cast<std::size_t>(from)]);
+		m_lanes.erase(m_lanes.begin() + from);
+
+		// erase 之后锚点网格的下标可能变化，必须用信号引用重新定位。
+		const int target = LaneOfSignal(anchor);
+		if (target < 0)
+		{
+			m_lanes.push_back(std::move(lane));
+		}
+		else
+		{
+			m_lanes.insert(m_lanes.begin() + target + 1, std::move(lane));
+		}
+
+		// 手动排布 → 切换到自定义划分策略，避免后续重建网格时顺序被还原。
+		m_laneMode = LaneMode::CUSTOM;
+		RenameLanes();
+		return true;
+	}
+
+	bool TabConfig::MoveLane(int from, int target)
+	{
+		const int count = static_cast<int>(m_lanes.size());
+		if (from < 0 || from >= count || target < 0 || target > count)
+		{
+			return false;
+		}
+
+		// `target` 语义 = 「插入到该下标之前」；向后拖时扣除自身占位后再比较，
+		// 保证"拖到自己原来的位置"不会产生无意义的移动。
+		int destination = target;
+		if (destination > from)
+		{
+			--destination;
+		}
+		destination = std::max(0, std::min(destination, count - 1));
+		if (destination == from)
+		{
+			return false;
+		}
+
+		Lane moved = std::move(m_lanes[static_cast<std::size_t>(from)]);
+		m_lanes.erase(m_lanes.begin() + from);
+		m_lanes.insert(m_lanes.begin() + destination, std::move(moved));
+
+		// 手动排布 → 切换到自定义划分策略，避免后续重建网格时顺序被还原。
+		m_laneMode = LaneMode::CUSTOM;
+		RenameLanes();
+		return true;
+	}
+
+	void TabConfig::RenameLanes()
+	{
+		for (std::size_t index = 0; index < m_lanes.size(); ++index)
+		{
+			m_lanes[index].name = L"网格 " + std::to_wstring(index + 1);
+		}
+	}
+
+	bool TabConfig::IsCollapsed(int groupIndex) const
+	{
+		if (groupIndex < 0 || static_cast<std::size_t>(groupIndex) >= m_collapsed.size())
+		{
+			return false;
+		}
+		return m_collapsed[static_cast<std::size_t>(groupIndex)];
+	}
+
+	void TabConfig::ToggleCollapsed(int groupIndex)
+	{
+		if (groupIndex < 0)
+		{
+			return;
+		}
+		if (static_cast<std::size_t>(groupIndex) >= m_collapsed.size())
+		{
+			m_collapsed.resize(static_cast<std::size_t>(groupIndex) + 1, m_groupsCollapsedByDefault);
+		}
+		m_collapsed[static_cast<std::size_t>(groupIndex)] = !m_collapsed[static_cast<std::size_t>(groupIndex)];
+	}
+
+	void TabConfig::ComputeLaneRange(const DataSet& dataSet, int laneIndex, double& yMin, double& yMax) const
+	{
+		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		{
+			yMin = 0.0;
+			yMax = 1.0;
+			return;
+		}
+
+		const Lane& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
+		if (!lane.autoRange)
+		{
+			yMin = lane.yMin;
+			yMax = lane.yMax;
+			if (!(yMax > yMin))
+			{
+				yMin = 0.0;
+				yMax = 1.0;
+			}
+			return;
+		}
+
+		double low = std::numeric_limits<double>::infinity();
+		double high = -std::numeric_limits<double>::infinity();
+		for (const SignalRef& ref : lane.signals)
+		{
+			if (!IsVisible(ref))
+			{
+				continue;
+			}
+			const SignalData* signal = dataSet.Resolve(ref);
+			if (signal == nullptr || signal->finiteCount == 0)
+			{
+				continue;
+			}
+			// ⚠️ 自适应必须基于**画出来的曲线**：先按绘制变换（系数 → 绝对值 → 镜像）把该信号的
+			// 原始值域映射成显示值域，否则调整系数/镜像后自适应范围仍按原始数据算（范围错误）。
+			const SignalStyle* style = dataSet.Style(ref);
+			double signalLow = signal->minValue;
+			double signalHigh = signal->maxValue;
+			if (style != nullptr)
+			{
+				TransformValueRange(*style, signalLow, signalHigh);
+			}
+			low = std::min(low, signalLow);
+			high = std::max(high, signalHigh);
+		}
+
+		if (!std::isfinite(low) || !std::isfinite(high))
+		{
+			low = 0.0;
+			high = 1.0;
+		}
+		PadRange(low, high);
+		yMin = low;
+		yMax = high;
+	}
+
+	bool TabConfig::ComputeVisibleTimeBounds(const DataSet& dataSet, double& minTime, double& maxTime) const
+	{
+		double low = std::numeric_limits<double>::infinity();
+		double high = -std::numeric_limits<double>::infinity();
+
+		for (std::size_t groupIndex = 0; groupIndex < m_visible.size(); ++groupIndex)
+		{
+			const std::vector<bool>& groupVisible = m_visible[groupIndex];
+			if (std::find(groupVisible.begin(), groupVisible.end(), true) == groupVisible.end())
+			{
+				continue;
+			}
+
+			const SignalGroup* group = dataSet.GroupAt(static_cast<int>(groupIndex));
+			if (group == nullptr)
+			{
+				continue;
+			}
+			// 只统计**可见信号**真正用到的时间轴：一个分组可能有多条时间轴
+			//（多 `time` 列 CSV / MF4 多通道组），把没显示的那些也算进来会让“适应视图”
+			// 拉出一个过宽的时间范围。
+			for (std::size_t signalIndex = 0; signalIndex < groupVisible.size() &&
+			                                      signalIndex < group->signals.size();
+			     ++signalIndex)
+			{
+				if (!groupVisible[signalIndex])
+				{
+					continue;
+				}
+				const TimeAxis& axis = group->AxisOf(group->signals[signalIndex]);
+				if (axis.finiteCount == 0)
+				{
+					continue;
+				}
+				low = std::min(low, axis.minTime);
+				high = std::max(high, axis.maxTime);
+			}
+		}
+
+		if (!std::isfinite(low) || !std::isfinite(high) || !(high > low))
+		{
+			return false;
+		}
+		minTime = low;
+		maxTime = high;
+		return true;
+	}
+
+} // namespace jdi
+