DeepSeek V4.1 Flash
d2e6fdd085
一、Lane 的内聚性（上一轮建议 5，本轮完成）
- 新增 struct LanePanelState { bool open = true; double x = -1.0; double y = -1.0; }；
- Lane 的 12 个平铺面板字段（edgePanelOpen/X/Y 等 × 4 类实验性功能）
→ 4 个聚合成员 edgePanel / edgeCenterPanel / meanFilterPanel / weakPeakPanel；
- 访问点全部改为 lane.edgePanel.open 形式（DataModelTab.cpp 快照拷贝、
PlotViewInteraction.cpp 面板拖拽、PlotViewPaint.cpp 面板层序绘制）；
- RebuildLanes 内部的 LaneCarry 同步收敛为 4 个 LanePanelState，
12 行逐字段赋值简化为 4 行整体赋值。
- 教训：批量改名不能对“声明”和“使用”跑同一组替换对，
否则声明行会变成 `bool edgePanel.open = true;` 这类非法代码。
二、错误提示与模态阻塞解耦（上一轮建议 1，本轮完成）
- Application 新增 SetModalErrorsEnabled(bool) / ModalErrorsEnabled()，
成员 m_modalErrorsEnabled 默认 true（交互场景行为不变）；
- Initialize 最先执行 SetModalErrorsEnabled(showCommand != SW_HIDE)：
隐藏窗口（自动化/离屏）下没人能点掉模态框，等于把进程钉死；
- SetStatusMessage(text, isError=true)：允许模态时原样 MessageBoxW，
否则改走非模态通道 m_plot.ShowPersistentHint(text)（绘图区底部浮层）；
普通提示与空文本依旧被忽略；
- PlotView 新增公开接口 ShowPersistentHint(text)（内部转 SetHintSticky），
不向宿主暴露粘滞/淡出等内部细节。
三、顺带修掉一个真实缺陷
- PlotView::Paint 在 m_lanes.empty() 时提前 return，而提示浮层在其后的
叠加层绘制 ⇒ 一个信号都没勾选时任何错误都显示不出来，恰恰是
“文件加载失败”最需要提示的场景；该分支补一次 PaintHint(g)。
四、验证（全部离屏：SW_HIDE + 不注入输入 + BELOW_NORMAL）
- make release / make debug：通过，零警告；Build/Release/Target.exe = 764416 B；
- verify 49/49、datacheck 69/69、edgecheck 46/46、panelanim 156/156；
- 新增探针 .preflight/perf/errcheck 19/19：默认值 / 隐藏窗口自动降级 / 宿主显式开关；
工作线程 + 5s 超时判定“不阻塞”（旧行为会永久阻塞，判失败并 ExitProcess，
探针不会挂住）；EnumWindows 统计本进程 #32770 顶层窗口数量前后不变；
错误文本进入 m_hintText / m_hintSticky / HintNeedsAnimation / m_hintShownAt；
像素级：有提示帧与无提示帧在绘图区内的差异像素 3781，且全帧差异同为 3781
（证明差异只来自提示）。
五、文档
- Documents/agent_mem.md：§9.37 新增第八节（本轮补齐）、第九节（仅剩 MF4 项）、
§11.2 新增第 93–95 条硬约束、变更日志新增一行；
- Documents/refactor_report_2026-10-16.md：§7.3 / §7.4 标记完成，新增 §九 收尾补记
（含 9.1–9.5：聚合化、解耦、探针、验证结果、变更清单）。
733 lines
22 KiB
C++
733 lines
22 KiB
C++
// 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.edgePanel.open = source.edgePanel.open;
|
|
lane.edgePanel.x = source.edgePanel.x;
|
|
lane.edgePanel.y = source.edgePanel.y;
|
|
lane.edgeCenter = source.edgeCenter;
|
|
lane.edgeCenterPanel.open = source.edgeCenterPanel.open;
|
|
lane.edgeCenterPanel.x = source.edgeCenterPanel.x;
|
|
lane.edgeCenterPanel.y = source.edgeCenterPanel.y;
|
|
lane.weakPeak = source.weakPeak;
|
|
lane.weakPeakPanel.open = source.weakPeakPanel.open;
|
|
lane.weakPeakPanel.x = source.weakPeakPanel.x;
|
|
lane.weakPeakPanel.y = source.weakPeakPanel.y;
|
|
lane.meanFilter = source.meanFilter;
|
|
lane.meanFilterPanel.open = source.meanFilterPanel.open;
|
|
lane.meanFilterPanel.x = source.meanFilterPanel.x;
|
|
lane.meanFilterPanel.y = source.meanFilterPanel.y;
|
|
// 拆分后每个子网格只保留自己那个信号的均值滤波 / 中心轴 / 弱峰调整条目。
|
|
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
|
|
|