fix: 统一输入框编辑能力、修复拖拽合并网格并支持光标吸附数据点

统一文本输入（新增 Utilities/Inc/TextEdit.hpp + TextEdit.cpp）
- 一个共享的编辑模型，提供光标/选区/过滤/限长，接入全部输入框：
  样式区数值与信号名/分组名、波形图例改名、视图标签页改名、
  拾色器 R/G/B 与色号、光标时间与网格上下限。
- 新增能力：Ctrl+A/C/X/V（含剪贴板清洗）、Shift+方向键与 Home/End 选区、
  退格与删除清除选区、代理对安全的光标步进。
- 渲染改为选区高亮 + 插入符，文本超出框宽时水平滚动并让插入符始终可见；
  初始态为整段选中，首字符键入即整体替换（保持"登录框"式交互）。
- 新增 Utf8Util::PasteTextFromClipboard（换行/制表符折叠为空格）。

修复网格合并（Utilities/Src/DataModel.cpp）
- 拖拽信号到其它网格时先固定目标网格的锚信号，再移除源信号并按引用找回目标，
  避免空网格回收导致下标错位，从"与原网格交换位置"改为真正合并。
- 自定义划分下未分配网格的可见信号改为各自独占一个新网格，
  修复"拖拽合并后再勾选新信号被并入该合并网格"的问题。

绘图区（Components/PlotView）
- 网格右键菜单新增"时间轴自适应（匹配本网格）"，把时间轴对齐到该网格信号范围。
- 时间轴放大到采样点在屏幕上可分辨（>=6 逻辑像素）时，拖动光标吸附到最近数据点；
  缩小到无法分辨时保持自由移动，避免光标"跳格"。

验证：真实输入脚本逐项核对——拖拽合并后单网格含两条曲线、拖拽合并再勾选新信号得 G2 独立网格、
Shift 选区 + Delete 清除、Ctrl+A/C/V 复制粘贴、46 字符文本水平滚动、拾色器色号 1E90FF、
标签页改名 A1、光标时间框复制粘贴、全视图拖动得 0.522213（不吸附）而放大后得 0.28125（= 225 × 0.00125，已吸附）。

Utilities/Src/ColorPickerPopup.cpp

@@ -213,7 +213,8 @@ namespace jdi
 		case EditField::B:
 		{
 			const int index = static_cast<int>(field) - 1;
-			m_editText = std::to_wstring(ToByte(m_channels[static_cast<std::size_t>(index)]));
+			m_edit.Begin(std::to_wstring(ToByte(m_channels[static_cast<std::size_t>(index)])), true,
+			             EditFilter::BYTE, 3);
 			break;
 		}
 		case EditField::HEX:
@@ -222,7 +223,7 @@ namespace jdi
 			wchar_t buffer[16];
 			swprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), L"%02X%02X%02X", (color >> 16) & 0xFFu,
 			         (color >> 8) & 0xFFu, color & 0xFFu);
-			m_editText = std::wstring(buffer);
+			m_edit.Begin(std::wstring(buffer), true, EditFilter::HEX, 7);
 			break;
 		}
 		default:
@@ -231,7 +232,6 @@ namespace jdi
 
 		m_draggingSlider = -1;
 		m_editField = field;
-		m_editFresh = true;
 		return true;
 	}
 
@@ -243,10 +243,9 @@ namespace jdi
 		}
 
 		const EditField field = m_editField;
-		const std::wstring text = m_editText;
+		const std::wstring text = m_edit.Text();
 		m_editField = EditField::NONE;
-		m_editFresh = false;
-		m_editText.clear();
+		m_edit.End();
 
 		if (!commit)
 		{
@@ -336,11 +335,21 @@ namespace jdi
 			return false;
 		}
 
-		// Ctrl+C：把当前文本复制到剪贴板。
-		if (character == 0x03)
+		// 剪贴板与全选快捷键经 WM_CHAR 送达（Ctrl+C/X/V/A 分别对应 3/24/22/1）。
+		switch (character)
 		{
-			CopyTextToClipboard(nullptr, m_editText);
+		case 0x03: // Ctrl+C
+			m_edit.CopyToClipboard(m_owner);
 			return false;
+		case 0x18: // Ctrl+X
+			return m_edit.CutToClipboard(m_owner);
+		case 0x16: // Ctrl+V
+			return m_edit.PasteFromClipboard(m_owner);
+		case 0x01: // Ctrl+A
+			m_edit.SelectAll();
+			return true;
+		default:
+			break;
 		}
 
 		if (character == L'\r' || character == L'\n')
@@ -349,54 +358,17 @@ namespace jdi
 		}
 		if (character == L'\b')
 		{
-			m_editFresh = false;
-			if (!m_editText.empty())
-			{
-				m_editText.pop_back();
-			}
-			return true;
+			return m_edit.Backspace();
 		}
-		if (character < 0x20 || character == 0x7F)
+		if (character == 0x7F)
 		{
-			return true;
+			return m_edit.DeleteForward();
 		}
-
-		if (m_editField == EditField::HEX)
+		if (character < 0x20)
 		{
-			const bool hexDigit = (character >= L'0' && character <= L'9') ||
-			                      (character >= L'a' && character <= L'f') ||
-			                      (character >= L'A' && character <= L'F') || (character == L'#');
-			if (!hexDigit)
-			{
-				return true;
-			}
-			if (m_editFresh)
-			{
-				m_editText.clear();
-				m_editFresh = false;
-			}
-			if (m_editText.size() < 7)
-			{
-				m_editText.push_back(character);
-			}
-			return true;
+			return false;
 		}
-
-		const bool digit = (character >= L'0' && character <= L'9');
-		if (!digit)
-		{
-			return true;
-		}
-		if (m_editFresh)
-		{
-			m_editText.clear();
-			m_editFresh = false;
-		}
-		if (m_editText.size() < 3)
-		{
-			m_editText.push_back(character);
-		}
-		return true;
+		return m_edit.Insert(character);
 	}
 
 	bool ColorPickerPopup::ContainsPoint(int x, int y) const
@@ -548,6 +520,9 @@ namespace jdi
 		}
 		if (m_editField != EditField::NONE)
 		{
+			const bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
+			const bool control = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
+
 			switch (key)
 			{
 			case VK_RETURN:
@@ -557,10 +532,27 @@ namespace jdi
 				EndEdit(false);
 				return true;
 			case VK_BACK:
-				m_editFresh = false;
-				if (!m_editText.empty())
+				m_edit.Backspace();
+				return true;
+			case VK_DELETE:
+				m_edit.DeleteForward();
+				return true;
+			case VK_LEFT:
+				m_edit.MoveCaret(-1, shift);
+				return true;
+			case VK_RIGHT:
+				m_edit.MoveCaret(1, shift);
+				return true;
+			case VK_HOME:
+				m_edit.MoveHome(shift);
+				return true;
+			case VK_END:
+				m_edit.MoveEnd(shift);
+				return true;
+			case 'A':
+				if (control)
 				{
-					m_editText.pop_back();
+					m_edit.SelectAll();
 				}
 				return true;
 			default:
@@ -609,7 +601,7 @@ namespace jdi
 
 			if (m_editField == static_cast<EditField>(index + 1))
 			{
-				UiDrawEditField(g, m_values[slot], m_editText, m_editFresh, m_fonts->monoSmall, m_scale);
+				UiDrawEditField(g, m_values[slot], m_edit, m_fonts->monoSmall, m_scale);
 			}
 			else
 			{
@@ -625,7 +617,7 @@ namespace jdi
 
 		if (m_editField == EditField::HEX)
 		{
-			UiDrawEditField(g, m_hexRect, m_editText, m_editFresh, m_fonts->monoSmall, m_scale);
+			UiDrawEditField(g, m_hexRect, m_edit, m_fonts->monoSmall, m_scale);
 		}
 		else
 		{

Utilities/Src/DataModel.cpp

@@ -210,7 +210,9 @@ namespace jdi
 				                           [](const Lane& lane) { return lane.signals.empty(); }),
 				            lanes.end());
 
-				// 未分配网格的可见信号统一追加到第一个网格。
+				// 未分配网格的可见信号各自独占一个新网格。
+				// 注意：不能把它们塞进已有的第一个网格——那会导致“拖拽合并后新勾选的信号
+				// 被悄悄并入合并网格”，用户看不到新增的独立泳道。
 				for (const SignalRef& ref : visible)
 				{
 					bool placed = false;
@@ -227,13 +229,10 @@ namespace jdi
 						continue;
 					}
 
-					if (lanes.empty())
-					{
-						Lane lane;
-						lane.autoRange = true;
-						lanes.push_back(std::move(lane));
-					}
-					lanes[0].signals.push_back(ref);
+					Lane lane;
+					lane.autoRange = true;
+					lane.signals.push_back(ref);
+					lanes.push_back(std::move(lane));
 				}
 			}
 
@@ -809,17 +808,11 @@ namespace jdi
 		}
 		style->visible = visible;
 
-		// 合并模式下新勾选的信号独占一个新网格：避免「先合并已有信号、再加入新信号」
-		// 时新信号被悄悄塞进那个唯一的合并网格里，导致用户看不到新增的独立泳道。
+		// 合并模式下新勾选的信号独占一个新网格：切到自定义划分后，
+		// RebuildLanes 会把尚未分配网格的可见信号各自放入新网格。
 		if (visible && m_laneMode == LaneMode::MERGED)
 		{
 			m_laneMode = LaneMode::CUSTOM;
-			Lane lane;
-			lane.autoRange = true;
-			lane.signals.push_back(ref);
-			m_lanes.push_back(std::move(lane));
-			SyncLanes(dataSet);
-			return;
 		}
 
 		SyncLanes(dataSet);
@@ -978,6 +971,31 @@ namespace jdi
 			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;
 
@@ -990,17 +1008,31 @@ namespace jdi
 		                             [](const Lane& lane) { return lane.signals.empty(); }),
 		              m_lanes.end());
 
-		if (laneIndex < 0 || laneIndex >= static_cast<int>(m_lanes.size()))
+		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));
 		}
-		else
-		{
-			m_lanes[static_cast<std::size_t>(laneIndex)].signals.push_back(ref);
-		}
 
 		for (std::size_t index = 0; index < m_lanes.size(); ++index)
 		{

Utilities/Src/PaintUtil.cpp

@@ -428,8 +428,7 @@ namespace jdi
 		              knobRadius * 2.0f);
 	}
 
-	void UiDrawEditField(gd::Graphics& g, const gd::RectF& rect, const std::wstring& text, bool fresh,
-	                     HFONT font, float scale)
+	void UiDrawEditField(gd::Graphics& g, const gd::RectF& rect, const TextEdit& edit, HFONT font, float scale)
 	{
 		if (rect.Width <= 0.0f || rect.Height <= 0.0f || font == nullptr)
 		{
@@ -442,29 +441,79 @@ namespace jdi
 		UiFillRoundRect(g, rect, corner, theme.cardBg);
 		UiDrawRoundRect(g, rect, corner, theme.accent, 1.6f);
 
-		const std::wstring shown = text.empty() ? std::wstring(L" ") : text;
-
-		if (fresh)
+		const std::wstring& text = edit.Text();
+		if (text.empty())
 		{
-			// 整段内容处于“将被覆盖”状态：以强调色底衬表示已全选。
-			const float textWidth = UiTextWidth(g, shown, font) + 8.0f * scale;
-			const gd::RectF highlight(rect.X + (rect.Width - textWidth) * 0.5f, rect.Y + 2.0f * scale,
-			                          textWidth, rect.Height - 4.0f * scale);
-			UiFillRoundRect(g, highlight, 2.0f * scale, theme.accent);
-			UiText(g, shown, font, highlight, theme.textOnAccent, TextAlign::CENTER);
+			// 空内容仍绘制插入符，保持焦点可见。
+			const float caretX = rect.X + 6.0f * scale;
+			UiDrawLine(g, caretX, rect.Y + 4.0f * scale, caretX, rect.Y + rect.Height - 4.0f * scale,
+			           theme.accent, 1.4f * scale);
 			return;
 		}
 
-		UiText(g, shown, font, rect, theme.textStrong, TextAlign::CENTER);
+		const float innerLeft = rect.X + 6.0f * scale;
+		const float innerWidth = std::max(4.0f, rect.Width - 12.0f * scale);
 
-		// 已开始键入：在文本末尾显示插入符。
-		const float textWidth = UiTextWidth(g, shown, font);
-		const float caretX = rect.X + (rect.Width + textWidth) * 0.5f + 1.0f * scale;
-		if (caretX < rect.X + rect.Width - 2.0f * scale)
+		// 光标与选区端点对应的像素位置（以文本左端为原点）。
+		const float caretX = UiTextWidth(g, text.substr(0, edit.Caret()), font);
+		const float selBeginX =
+		    edit.HasSelection() ? UiTextWidth(g, text.substr(0, edit.SelectionBegin()), font) : 0.0f;
+		const float selEndX =
+		    edit.HasSelection() ? UiTextWidth(g, text.substr(0, edit.SelectionEnd()), font) : 0.0f;
+		const float textWidth = UiTextWidth(g, text, font);
+
+		// 内容超出可视宽度时横向滚动，保证光标始终可见（向常规输入框靠齐）。
+		float scroll = 0.0f;
+		if (textWidth > innerWidth)
 		{
-			UiDrawLine(g, caretX, rect.Y + 4.0f * scale, caretX, rect.Y + rect.Height - 4.0f * scale,
-			           theme.accent, 1.4f * scale);
+			if (caretX > innerWidth)
+			{
+				scroll = caretX - innerWidth;
+			}
+			const float maximum = textWidth - innerWidth;
+			scroll = std::max(0.0f, std::min(scroll, maximum));
 		}
+
+		const gd::RectF clipRect(innerLeft, rect.Y + 1.0f * scale, innerWidth, rect.Height - 2.0f * scale);
+		const int saveState = g.Save();
+		g.SetClip(clipRect, gd::CombineModeIntersect);
+
+		const float textLeft = innerLeft - scroll;
+
+		// 选区高亮绘制在文本之下，整段选中时呈现“已全选”观感。
+		const bool fullSelection = edit.HasSelection() && edit.SelectionBegin() == 0 &&
+		                           edit.SelectionEnd() == text.size();
+		if (edit.HasSelection() && selEndX > selBeginX)
+		{
+			const gd::RectF highlight(textLeft + selBeginX, rect.Y + 3.0f * scale,
+			                          selEndX - selBeginX, rect.Height - 6.0f * scale);
+			UiFillRect(g, highlight, theme.accent);
+		}
+
+		UiText(g, text, font, gd::RectF(textLeft, rect.Y, std::max(textWidth, innerWidth), rect.Height),
+		       theme.textStrong, TextAlign::LEFT);
+
+		if (edit.HasSelection() && !fullSelection && selEndX > selBeginX)
+		{
+			// 局部选区：在反白底衬上重绘被选中的片段，其余文字保持常规颜色。
+			const std::wstring selected =
+			    text.substr(edit.SelectionBegin(), edit.SelectionEnd() - edit.SelectionBegin());
+			UiText(g, selected, font,
+			       gd::RectF(textLeft + selBeginX, rect.Y, selEndX - selBeginX, rect.Height),
+			       theme.textOnAccent, TextAlign::LEFT);
+		}
+		else if (fullSelection)
+		{
+			UiText(g, text, font, gd::RectF(textLeft, rect.Y, std::max(textWidth, innerWidth), rect.Height),
+			       theme.textOnAccent, TextAlign::LEFT);
+		}
+
+		// 插入符。
+		const float caretDrawX = textLeft + caretX;
+		UiDrawLine(g, caretDrawX, rect.Y + 4.0f * scale, caretDrawX, rect.Y + rect.Height - 4.0f * scale,
+		           theme.textStrong, 1.4f * scale);
+
+		g.Restore(saveState);
 	}
 
 	bool UiSwatchNeedsOutline(float opacity)

Utilities/Src/TextEdit.cpp

@@ -0,0 +1,340 @@
+#include "TextEdit.hpp"
+
+#include <algorithm>
+
+#include "Utf8Util.hpp"
+
+namespace jdi
+{
+
+	namespace
+	{
+		/** @brief 判断字符是否为 UTF-16 高位代理。 */
+		bool IsHighSurrogate(wchar_t c)
+		{
+			return c >= 0xD800 && c <= 0xDBFF;
+		}
+
+		/** @brief 判断字符是否为 UTF-16 低位代理。 */
+		bool IsLowSurrogate(wchar_t c)
+		{
+			return c >= 0xDC00 && c <= 0xDFFF;
+		}
+
+		/** @brief 判断字符是否符合数值输入（数字与科学计数法符号）。 */
+		bool IsNumberChar(wchar_t c)
+		{
+			return (c >= L'0' && c <= L'9') || c == L'.' || c == L'-' || c == L'+' || c == L'e' || c == L'E';
+		}
+
+		/** @brief 判断字符是否为十六进制数字。 */
+		bool IsHexDigit(wchar_t c)
+		{
+			return (c >= L'0' && c <= L'9') || (c >= L'a' && c <= L'f') || (c >= L'A' && c <= L'F');
+		}
+
+		/** @brief 判断字符是否为十进制数字。 */
+		bool IsDigit(wchar_t c)
+		{
+			return c >= L'0' && c <= L'9';
+		}
+	}
+
+	bool TextEdit::AcceptsCharacter(EditFilter filter, wchar_t character)
+	{
+		switch (filter)
+		{
+		case EditFilter::NUMBER:
+			return IsNumberChar(character);
+		case EditFilter::HEX:
+			return IsHexDigit(character) || character == L'#';
+		case EditFilter::BYTE:
+			return IsDigit(character);
+		case EditFilter::ANY:
+		default:
+			return character >= L' ' && character != 0x7F;
+		}
+	}
+
+	void TextEdit::Begin(const std::wstring& text, bool selectAll, EditFilter filter, std::size_t maxLength)
+	{
+		m_active = true;
+		m_text = text;
+		m_filter = filter;
+		m_maxLength = maxLength;
+		m_caret = m_text.size();
+		m_anchor = selectAll ? 0 : m_text.size();
+		m_fresh = selectAll && !m_text.empty();
+	}
+
+	void TextEdit::End()
+	{
+		m_active = false;
+		m_fresh = false;
+		m_text.clear();
+		m_caret = 0;
+		m_anchor = 0;
+		m_filter = EditFilter::ANY;
+		m_maxLength = 0;
+	}
+
+	std::size_t TextEdit::ClampOffset(std::size_t offset) const
+	{
+		if (offset > m_text.size())
+		{
+			offset = m_text.size();
+		}
+		// 避免光标落在代理对中间（否则渲染与删除都会错位）。
+		if (offset > 0 && offset < m_text.size() && IsLowSurrogate(m_text[offset]) &&
+		    IsHighSurrogate(m_text[offset - 1]))
+		{
+			--offset;
+		}
+		return offset;
+	}
+
+	std::size_t TextEdit::StepLeft(std::size_t offset) const
+	{
+		if (offset == 0)
+		{
+			return 0;
+		}
+		--offset;
+		if (offset > 0 && IsLowSurrogate(m_text[offset]) && IsHighSurrogate(m_text[offset - 1]))
+		{
+			--offset;
+		}
+		return offset;
+	}
+
+	std::size_t TextEdit::StepRight(std::size_t offset) const
+	{
+		if (offset >= m_text.size())
+		{
+			return m_text.size();
+		}
+		++offset;
+		if (offset < m_text.size() && IsLowSurrogate(m_text[offset]) && IsHighSurrogate(m_text[offset - 1]))
+		{
+			++offset;
+		}
+		return offset;
+	}
+
+	bool TextEdit::ReplaceSelection(const std::wstring& replacement)
+	{
+		const bool hadSelection = HasSelection();
+		const std::size_t begin = SelectionBegin();
+		const std::size_t end = SelectionEnd();
+
+		std::wstring merged = m_text.substr(0, begin) + replacement + m_text.substr(end);
+		if (m_maxLength > 0 && merged.size() > m_maxLength)
+		{
+			merged.resize(m_maxLength);
+		}
+
+		const bool changed = (merged != m_text) || hadSelection;
+		m_text = std::move(merged);
+		m_caret = ClampOffset(begin + replacement.size());
+		m_anchor = m_caret;
+		m_fresh = false;
+		return changed;
+	}
+
+	bool TextEdit::Insert(wchar_t character)
+	{
+		if (!m_active || character == 0)
+		{
+			return false;
+		}
+		if (!AcceptsCharacter(m_filter, character))
+		{
+			return true;
+		}
+		return ReplaceSelection(std::wstring(1, character));
+	}
+
+	bool TextEdit::Backspace()
+	{
+		if (!m_active)
+		{
+			return false;
+		}
+		if (HasSelection())
+		{
+			// 存在选区时退格清除整个选区。
+			return ReplaceSelection(std::wstring());
+		}
+		if (m_caret == 0)
+		{
+			m_fresh = false;
+			return false;
+		}
+
+		const std::size_t previous = StepLeft(m_caret);
+		const std::size_t removed = m_caret - previous;
+		m_text.erase(previous, removed);
+		m_caret = previous;
+		m_anchor = previous;
+		m_fresh = false;
+		return true;
+	}
+
+	bool TextEdit::DeleteForward()
+	{
+		if (!m_active)
+		{
+			return false;
+		}
+		if (HasSelection())
+		{
+			// 存在选区时删除键清除整个选区。
+			return ReplaceSelection(std::wstring());
+		}
+		if (m_caret >= m_text.size())
+		{
+			m_fresh = false;
+			return false;
+		}
+
+		const std::size_t next = StepRight(m_caret);
+		m_text.erase(m_caret, next - m_caret);
+		m_anchor = m_caret;
+		m_fresh = false;
+		return true;
+	}
+
+	bool TextEdit::MoveCaret(int delta, bool extendSelection)
+	{
+		if (!m_active || delta == 0)
+		{
+			return false;
+		}
+
+		std::size_t offset = m_caret;
+		const int steps = (delta > 0) ? delta : -delta;
+		for (int index = 0; index < steps; ++index)
+		{
+			offset = (delta > 0) ? StepRight(offset) : StepLeft(offset);
+		}
+		offset = ClampOffset(offset);
+
+		if (offset == m_caret)
+		{
+			return false;
+		}
+
+		m_caret = offset;
+		if (!extendSelection)
+		{
+			m_anchor = offset;
+			m_fresh = false;
+		}
+		else
+		{
+			m_fresh = false;
+		}
+		return true;
+	}
+
+	bool TextEdit::MoveHome(bool extendSelection)
+	{
+		if (!m_active || m_caret == 0)
+		{
+			return false;
+		}
+		m_caret = 0;
+		if (!extendSelection)
+		{
+			m_anchor = 0;
+		}
+		m_fresh = false;
+		return true;
+	}
+
+	bool TextEdit::MoveEnd(bool extendSelection)
+	{
+		if (!m_active || m_caret == m_text.size())
+		{
+			return false;
+		}
+		m_caret = m_text.size();
+		if (!extendSelection)
+		{
+			m_anchor = m_caret;
+		}
+		m_fresh = false;
+		return true;
+	}
+
+	void TextEdit::SelectAll()
+	{
+		m_anchor = 0;
+		m_caret = m_text.size();
+		m_fresh = !m_text.empty();
+	}
+
+	bool TextEdit::CopyToClipboard(HWND owner) const
+	{
+		if (m_text.empty())
+		{
+			return false;
+		}
+		const std::wstring payload =
+		    HasSelection() ? m_text.substr(SelectionBegin(), SelectionEnd() - SelectionBegin()) : m_text;
+		return CopyTextToClipboard(owner, payload);
+	}
+
+	bool TextEdit::CutToClipboard(HWND owner)
+	{
+		if (m_text.empty())
+		{
+			return false;
+		}
+		const bool copied = CopyToClipboard(owner);
+		if (!copied)
+		{
+			return false;
+		}
+		if (HasSelection())
+		{
+			return ReplaceSelection(std::wstring());
+		}
+		m_text.clear();
+		m_caret = 0;
+		m_anchor = 0;
+		m_fresh = false;
+		return true;
+	}
+
+	bool TextEdit::PasteFromClipboard(HWND owner)
+	{
+		if (!m_active)
+		{
+			return false;
+		}
+
+		std::wstring pasted;
+		if (!PasteTextFromClipboard(owner, pasted))
+		{
+			return false;
+		}
+
+		// 按当前过滤策略清洗粘贴内容，避免数值框被灌入非法字符。
+		std::wstring cleaned;
+		cleaned.reserve(pasted.size());
+		for (const wchar_t c : pasted)
+		{
+			if (AcceptsCharacter(m_filter, c))
+			{
+				cleaned.push_back(c);
+			}
+		}
+		if (cleaned.empty())
+		{
+			return false;
+		}
+		return ReplaceSelection(cleaned);
+	}
+
+} // namespace jdi

Utilities/Src/Utf8Util.cpp

@@ -411,4 +411,45 @@ namespace jdi
 		return success;
 	}
 
+	bool PasteTextFromClipboard(HWND owner, std::wstring& text)
+	{
+		text.clear();
+
+		if (OpenClipboard(owner) == FALSE)
+		{
+			return false;
+		}
+
+		bool success = false;
+		if (IsClipboardFormatAvailable(CF_UNICODETEXT) != FALSE)
+		{
+			HANDLE handle = GetClipboardData(CF_UNICODETEXT);
+			if (handle != nullptr)
+			{
+				const void* source = GlobalLock(handle);
+				if (source != nullptr)
+				{
+					const wchar_t* wide = static_cast<const wchar_t*>(source);
+					text.assign(wide);
+					GlobalUnlock(handle);
+					success = !text.empty();
+				}
+			}
+		}
+		CloseClipboard();
+
+		// 单行输入框：把换行与制表符折叠为空格，避免内容被截断显示。
+		if (success)
+		{
+			for (wchar_t& c : text)
+			{
+				if (c == L'\r' || c == L'\n' || c == L'\t')
+				{
+					c = L' ';
+				}
+			}
+		}
+		return success;
+	}
+
 } // namespace jdi