CMapView类与CMapData类数据

最新推荐文章于 2024-09-16 17:46:36 发布

春妮秀大炮

最新推荐文章于 2024-09-16 17:46:36 发布

阅读量49

点赞数

文章标签： c++ mfc

本文链接：https://blog.csdn.net/weixin_43600679/article/details/133973169

版权

CMapView类代码：

#pragma once
#include
#include
#include “MapFileParse.h”
#include “AerialView.h”
#include
#include “MapData.h”
#include
#include
#include “MapData.h”

绘制单元格表，每个小单无格包括：背景色、边框、符号
背景色：通过算法分配
边框：通过Rabio标记分配
符号：元地图文件中的符号
放大，缩小
右击拖动截取小方格（类似截图）
左单击选中方格，
单方格或多方格选中后进行高亮或加粗边框，只为区别开来
元地图数据结构，标志数据结构，符号颜色数据结构

*/
class CWaferMapViewDlg;// 前向声明
class CMapView : public CView, public CMapObserver
{
DECLARE_DYNAMIC(CMapView);
public:

//struct Cell {
//	int row, col;
//	Cell(int r, int c) : row(r), col(c) {}
//};

//struct ColorSymbol { 
//	char symbol; // 把结构体放在这个类可以减少开销，如果之后代码复杂了可以考虑放到单独的数据文件中
//	int symbolNum; // 但放在CMapFileParse可能会出现数据不一致的情况
//	COLORREF color; };

//单元格的状态
enum CellState {
	NORMAL,     // 正常
	HIGHLIGHT,  // 高亮
};

struct BorderInfo {
	COLORREF color; // 边框颜色
	int width;      // 边框宽度
};
// 单元格的信息：符号、背景色、边框，选中状态
struct CellInfo
{
	ColorSymbol CSInfo; // 符号，color，符号数量信息
	CellState stateInfo; // 单元格状态
	BorderInfo border; // 单元格边框
};
CMapView();
virtual ~CMapView();
// 常用的值作为类成员变量存储
void SetDialog(CWaferMapViewDlg* pDlg);// 实例关联指针
int m_rows, m_cols; // 表格的行数，表格的列数

template<class T> // 模板函数， 用于将一个值限制在范围内（偏移）
const T& custom_clamp(const T& v, const T& lo, const T& hi); // 一个模板函数，用于将一个值限制在范围内

private:
CWaferMapViewDlg* m_pDlg; // 指向 CWaferMapViewDlg 实例的指针
CMapFileParse m_mapFileParse; // 地图文件解析对象实例的指针
int m_cellSize; // 单元格的大小
CPoint m_offset = CPoint(0, 0); // 存储视图的偏移量，初始化为(0, 0)来表示没有偏移
double m_zoomLevel; // 初始化为1.0来表示100%的，当前缩放级别
bool m_isDragging; // 标识当前是否正在拖动视图
std::vector m_selectedCells; // 存储被选中的单元格
// std::set m_selectedCells;

COLORREF m_gridColor;	// 网格颜色
int cellWidth = 15, cellHeight = 10;	// 单元格的宽度和高度

CPoint m_origin; // 跟踪视图的原点
CPoint m_selectedCell = CPoint(-1, -1);  // 初始化为无效值来表示没有选中的单元格
CPoint m_dragStartPoint, m_lastDragPoint;  // 开始拖动的位置/最后拖动的位置
//CPoint m_selectionStart, m_selectionEnd; // 拖动开始时的点/结束时的点
CPoint m_prevMousePos, m_lastMousePos;  // 上一个鼠标位置/最后鼠标位置
//bool m_isDragging = false;  // 标识当前是否正在拖动视图
CSliderCtrl m_zoomSlider;
CRect m_selectionRect; // 存储当前选择区域的矩形
bool m_isSelecting = false; // 是否处于选择模式
float m_zoomFactor = 1.1f; // 每次缩放时使用的缩放因子
int gap = 1;  // 间隙大小
int m_offsetX, m_offsetY; // 地图的水平偏移量/地图的垂直偏移量
//CRect m_highlightedRect; // 存储高亮区域的矩形
//bool m_isHighlighting; // 是否正在进行高亮操作



std::vector<std::vector<CellInfo>> m_cells; // 存储每个单元格的信息
std::vector<Marker> m_markers;// 标记的位置

// 鸟瞰图
//CStatic m_aerialViewCtrl; // 鸟瞰图控件
//std::function<void()> m_viewChangedCallback;
private:
// 绘制函数
virtual void OnDraw(CDC* pDC); // 重写绘制函数，负责绘制视图，包括单元格、标记、选择区域等
void DrawGrid(CDC* pDC); // 绘制
void DrawHorizontalLines(CDC* pDC, int rowIndex); // 绘制水平线
void DrawVerticalLines(CDC* pDC, int colIndex); // 绘制垂直线
void DrawCells(CDC* pDC);
void DrawCell(CDC* pDC, int row, int col);

void DrawSelectionRect(CDC* pDC); // 绘制选择矩形
void HighlightSelectedCells(CDC* pDC); // 执行填充，绘制边框的操作
//CRect GetVisibleRange() const; // 当前单元格可见区域
void DrawMarkers(CDC* pDC); // 画标记
void DrawPath(CDC* pDC); // 画出路径
void DrawUIElements(CDC* pDC); // 绘制UI元素

public:
void InitializeCells(); // 初始化单元格数据
void SetZoomLevel(int zoomLevel); // 设置缩放级别
void clampOffset(); // 限制偏移量，使地图正确的移动或缩放拖动
CPoint GetCellFromPoint(CPoint point); // 获取给定点下的单元格
bool IsValidCell(int row, int col); // 检查给定的行和列是否是有效的
void Zoom(double factor); // 缩放
void CalculateSelectedCells(const CPoint* pClickPoint = nullptr); // 计算被选择的单元格

// 各事件方法的拆分方法
void UpdateZoomLevel(short zDelta, CPoint pt); // 更新缩放级别
// OnLButtonDown
void StartSelection(CPoint point); // 开始选择
void StartDrag(CPoint point); // 开始拖动
void HandleClickAt(CPoint point); // 处理单击事件
// OnMouseMove
void UpdateSelectionOnMove(UINT nFlags, CPoint point); // 更新选择
void UpdateDragOnMove(CPoint point); // 更新拖动
// OnLButtonUp
void /*CMapView::*/EndSelection(); // 结束选择
// 键盘事件处理函数
void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags); 

//void SetOffset(int offsetX, int offsetY);  // 设置地图的偏移量
//void ensureVisibleAreaInBounds();// 在放大或缩小时确保视图区域仍然在盒子的内部
//void OnZoomOrPan(); // 缩放或平移
//void UpdateAerialView();  // 更新鸟瞰图
//BOOL CreateAerialViewCtrl();  // 创建鸟瞰图控件
//void DrawAerialViewIndicator(CDC* pDC);  // 绘制鸟瞰图指示器
//void SetViewChangedCallback(std::function<void()> callback) { m_viewChangedCallback = callback; } // 设置视图更改时的回调函数

/* * * * * 观察者 colorSymbols, mapData, metaData

在这里更新视图
*/
public:
virtual void onMetadataChanged(const std::unordered_map<std::string, std::string>& newMetaData) {
Invalidate();
}
virtual void onMapDataChanged(const std::vector<std::vector>& newMapData) {
Invalidate();
}
virtual void onColorSymbolsChanged(const std::unordered_map<char, ColorSymbol>& newColorSymbols) {
Invalidate();
}
//virtual void onDefaultColorMappingChanged(const std::unordered_map<char, COLORREF>& newDefaultColorMapping) {
// Invalidate();
//}

protected:
DECLARE_MESSAGE_MAP()
//afx_msg void OnPaint();
afx_msg BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnRButtonDown(UINT nFlags, CPoint point);

// 鸟瞰图
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);

};

#include “pch.h”
#include “MapView.h”
#include “WaferMapViewDlg.h”
#include “resource.h”

template
const T& CMapView::custom_clamp(const T& v, const T& lo, const T& hi) {
// return std::max(lo, std::min(v, hi));
return (std::max)(lo, (std::min)(v, hi));

}

IMPLEMENT_DYNAMIC(CMapView, CStatic)
BEGIN_MESSAGE_MAP(CMapView, CStatic)
ON_WM_PAINT()
ON_WM_MOUSEWHEEL()
ON_WM_MOUSEMOVE()
ON_WM_LBUTTONDOWN()
ON_WM_RBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_SETCURSOR()

END_MESSAGE_MAP()

CMapView::CMapView()
:CView(), CMapObserver()
, m_rows(100) // 示例值，应从CMapFileParse类获取
, m_cols(100) // 示例值，应从CMapFileParse类获取
, m_cellSize(20) // 示例值
, m_gridColor(RGB(0, 0, 0)) // 黑色网格
, m_zoomLevel(1.0) // 默认缩放级别为1.0
, m_origin(0, 0)

, m_isDragging(false)

,m_lastMousePos(0, 0)
,m_offsetX(0)
,m_offsetY(0)
//,m_isHighlighting(false)

{
m_rows = m_mapFileParse.GetRowCount(); // 在MapFileParse中获取行数和列
m_cols = m_mapFileParse.GetColCount();

//ModifyStyle(0, SS_NOTIFY);	// 设置为自绘模式，否则无法显示自定义颜色		SS_OWNERDRAW

}

CMapView::~CMapView() {
//delete m_pDlg;
}

void CMapView::SetDialog(CWaferMapViewDlg* pDlg)
{
}

把控件的“通知”，改为：True。才能接收到消息映射，对控件进行控制
四、硬件加速，利用GPU进行更高效的渲染。
1.使用OpenGL或DirectX等图形API；
2.利用GPU进行图形渲染，释放CPU资源。
/
void CMapView::OnDraw(CDC pDC)
{
// 如果需要，准备绘图上下文

DrawGrid(pDC);
DrawMarkers(pDC);
DrawPath(pDC);
DrawUIElements(pDC);
DrawCells(pDC);
HighlightSelectedCells(pDC);

// 不要修改以下代码！
CView::OnDraw(pDC);
}

void CMapView::InitializeCells()
{
CMapFileParse mapFileParse;
int rows = mapFileParse.GetRowCount(); // 用实际的方法来获取行数
int cols = mapFileParse.GetColCount(); // 用实际的方法来获取列数

m_cells.resize(rows, std::vector<CellInfo>(cols));

for (int i = 0; i < rows; ++i)
{
	for (int j = 0; j < cols; ++j)
	{
		// 为简单起见，我们在这里设置一些默认值。实际上，你应该从mapFileParse获取这些值
		m_cells[i][j].CSInfo.color = RGB(255, 255, 255); // 默认为白色背景
		m_cells[i][j].border.color = RGB(0, 0, 0); // 默认为黑色边框
	}
}

}

//CPoint CMapView::GetCellFromPoint(CPoint point)
//{
// int col = static_cast((point.x - m_offsetX) / (m_cellSize * m_zoomLevel));
// int row = static_cast((point.y - m_offsetY) / (m_cellSize * m_zoomLevel));
// return CPoint(col, row); // 单元格的列和行索引
//}

// 在GetCellFromPoint之前调用此函数，以检查这个单元格是否实际存在
bool CMapView::IsValidCell(int row, int col)
{
return row >= 0 && row < m_rows && col >= 0 && col < m_cols;
}

// 改变缩放级别
void CMapView::Zoom(double factor)
{
m_zoomLevel *= factor;
Invalidate(); // 重新绘制视图来应用新的缩放级别
}

void CMapView::SetZoomLevel(int zoomLevel)
{
m_zoomLevel = zoomLevel / 50.0; // 转换滑块的值到一个合适的缩放级别
Invalidate(); // 重新绘制视图来应用新的缩放级别
}

// 鼠标滚轮事件
BOOL CMapView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
UpdateZoomLevel(zDelta, pt);

Invalidate();
return CView::OnMouseWheel(nFlags, zDelta, pt); // 调用基类的处理

//if (zDelta > 0 /*&& m_zoomLevel < m_maxZoomLevel*/)
//{
//	m_zoomLevel *= m_zoomFactor;// 向前滚动来放大，缩放10%
//	Zoom(1.1);  
//}
//else if (zDelta < 0 /* && m_zoomLevel > m_minZoomLevel*/)
//{
//	m_zoomLevel /= m_zoomFactor; // 向后滚动来缩小，缩放-10%
//	//Zoom(0.9);  
//}
 根据缩放级别更新偏移量
//float oldZoom = m_zoomLevel;
//clampOffset(); // 限制偏移量在合理范围内

}

// 左键按下
void CMapView::OnLButtonDown(UINT nFlags, CPoint point)
{
SetCapture(); // 开始追踪鼠标

StartSelection(point); // 开始选择
StartDrag(point); // 开始拖动
HandleClickAt(point); // 处理单击事件


Invalidate();
CView::OnLButtonDown(nFlags, point);

}

// 鼠标移动事件
void CMapView::OnMouseMove(UINT nFlags, CPoint point)
{
if (nFlags & MK_LBUTTON)
{
UpdateSelectionOnMove(nFlags, point);
UpdateDragOnMove(point);
Invalidate();
}
CView::OnMouseMove(nFlags, point);
}

// 释放鼠标左键
void CMapView::OnLButtonUp(UINT nFlags, CPoint point)
{
EndSelection();
ReleaseCapture();
Invalidate();
CView::OnLButtonUp(nFlags, point);
}

// 释放鼠标右键
void CMapView::OnRButtonDown(UINT nFlags, CPoint point)
{
int x = (point.x - m_offsetX) / (m_cellSize * m_zoomLevel); // 计算标记点的坐标
int y = (point.y - m_offsetY) / (m_cellSize * m_zoomLevel);

// 创建标记点
Marker marker = { x, y, RGB(255, 0, 0) }; // 使用红色作为标记点颜色
m_markers.push_back(marker);// 将标记点添加到容器中

Invalidate();

}

// 更新缩放级别
void CMapView::UpdateZoomLevel(short zDelta, CPoint pt)
{
m_zoomLevel += zDelta / 1200.0f; // 更新缩放级别
m_zoomLevel = max(0.1f, min(m_zoomLevel, 10.0f)); // 保证缩放级别在一个合理的范围内

// 根据缩放级别更新偏移量
//float oldZoom = m_zoomLevel;
//float factor = m_zoomLevel / oldZoom;
float factor = (zDelta > 0) ? m_zoomFactor : 1.0f / m_zoomFactor;
m_offsetX = pt.x + (m_offsetX - pt.x) * factor;
m_offsetY = pt.y + (m_offsetY - pt.y) * factor;

clampOffset(); // 限制偏移量在合理范围内

}

// 限制偏移量，使地图正确的移动或缩放拖动
void CMapView::clampOffset() {
CRect clientRect; // 获取控件的尺寸
GetClientRect(&clientRect); // 获取当前视图控件的尺寸
float visibleWidth = clientRect.Width();
float visibleHeight = clientRect.Height();

if (!m_mapFileParse.getMetadata().empty() && !m_mapFileParse.getMetadata()/*[0]*/.empty())
{
	float maxOffsetX = m_cellSize * m_zoomLevel * m_mapFileParse.getMetadata()/*[0]*/.size() - visibleWidth;
	float maxOffsetY = m_cellSize * m_zoomLevel * m_mapFileParse.getMetadata().size() - visibleHeight;
	// 限制偏移量的值
	m_offsetX = custom_clamp(static_cast<float>(m_offsetX), 0.0f, maxOffsetX);
	m_offsetY = custom_clamp(static_cast<float>(m_offsetY), 0.0f, maxOffsetY);
}

}

// 开始选择
void CMapView::StartSelection(CPoint point)
{
m_selectionRect = CRect(point, point); // 设置初始选择矩形
m_dragStartPoint = point; // 保存当前点以便于拖动
m_isSelecting = true; // 开始选择
}

// 开始拖动
void CMapView::StartDrag(CPoint point)
{
m_dragStartPoint = point;
m_lastDragPoint = point;
}

// 处理单击事件
void CMapView::HandleClickAt(CPoint point)
{
int row = point.y / (cellHeight * m_zoomLevel);
int col = point.x / (cellWidth * m_zoomLevel);
m_selectedCells.emplace_back(col, row);
//m_selectedCells.insert(Cell{ row, col });
// 这里可以添加其他处理单击事件的代码，如获取单元格数据等。
}

// 更新选择
void CMapView::UpdateSelectionOnMove(UINT nFlags, CPoint point)
{
if (m_isSelecting)
{
m_lastDragPoint = point;
CalculateSelectedCells();
Invalidate();
}
else if (nFlags & MK_LBUTTON)
{
CPoint delta = point - m_dragStartPoint;
m_origin += delta;
m_dragStartPoint = point;
Invalidate();
}
}

// 更新拖动
void CMapView::UpdateDragOnMove(CPoint point)
{
if (m_isDragging)
{
int dx = point.x - m_dragStartPoint.x;
int dy = point.y - m_dragStartPoint.y;
m_origin.x += dx;
m_origin.y += dy;
m_dragStartPoint = point;
}
}

// 结束选择
void CMapView::EndSelection()
{
if (m_isSelecting)
{
m_isSelecting = false;
m_selectionRect.NormalizeRect();
CalculateSelectedCells();
}
}

/* 获取给定点下的单元格

将屏幕上的点（像素坐标）映射到单元格坐标。需考虑到缩放和偏移
col = point.x−offset.x / (cellWidth * m_zoomLevel);
row = point.y−offset.y / (cellHeight * m_zoomLevel);
point.x 和 point.y 是屏幕上点的坐标，offset.x 和 offset.y 是地图的偏移量，
cellSize 是单元格的大小（假设它是正方形的），并且 zoomLevel 是缩放级别。
返回：单元格的列和行索引
先调用“IsValidCell”，以确保坐标是否在合理的范围内
/
void CMapView::CalculateSelectedCells(const CPoint pClickPoint)
{
m_selectedCells.clear(); // 清除先前的选择

// 如果传递了点击点，将其添加到选中的单元格中
if (pClickPoint)
{
int col = pClickPoint->x / (m_cellSize * m_zoomLevel);
int row = pClickPoint->y / (m_cellSize * m_zoomLevel);
m_selectedCells.emplace_back(col, row);
}

// 计算被选择的单元格 四叉树算法
// 仅检查选择矩形范围内的单元格
for (int row = 0; row < m_rows; ++row)
{
for (int col = 0; col < m_cols; ++col)
{
CRect cellRect(col * m_cellSize * m_zoomLevel, row * m_cellSize * m_zoomLevel, (col + 1) * m_cellSize * m_zoomLevel, (row + 1) * m_cellSize * m_zoomLevel);
if (m_selectionRect.PtInRect(cellRect.TopLeft()) || m_selectionRect.PtInRect(cellRect.BottomRight()))
{
m_selectedCells.emplace_back(col, row);
}
}
}
}
void CMapView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// 检查是否按下了 “Delete” 键
if (nChar == VK_DELETE)
{
// 逻辑来删除或清除选中的单元格
}

// 其他键盘事件的处理逻辑…

// 触发地图重绘CalculateSelectedCells
Invalidate();
}

// 绘制
void CMapView::DrawGrid(CDC* pDC) {
for (int i = 0; i < m_rows; ++i) {
DrawHorizontalLines(pDC, i);
}
for (int j = 0; j < m_cols; ++j) {
DrawVerticalLines(pDC, j);
}
// 绘制表格，表格线，缩放级别，新的缩放级别来绘制表格
// 绘制了两条线，但看起来它们没有使用循环变量i。如果它们是固定的线，可能它们应该被移动到另一个函数中
pDC->MoveTo(m_cols * m_cellSize * m_zoomLevel + m_offset.x, m_rows * m_cellSize * m_zoomLevel + m_offset.y);
pDC->LineTo(m_cols * m_cellSize * m_zoomLevel + m_offset.x, m_rows * m_cellSize * m_zoomLevel + m_offset.y);
pDC->MoveTo(m_cols * m_cellSize * m_zoomLevel + m_offset.x, m_rows * m_cellSize * m_zoomLevel + m_offset.y);
pDC->LineTo(m_cols * m_cellSize * m_zoomLevel + m_offset.x, m_rows * m_cellSize * m_zoomLevel + m_offset.y);

}

// 绘制水平线垂直线
void CMapView::DrawHorizontalLines(CDC* pDC, int rowIndex) {
// 使用 rowIndex 来确定线的Y坐标

}
// 垂直线
void CMapView::DrawVerticalLines(CDC* pDC, int colIndex) {
// 使用 colIndex 来确定线的X坐标

}

// 多个单元格
void CMapView::DrawCells(CDC* pDC/, int row, int col/) {
// 获取当前可见区域的行列范围
//int startRow, endRow, startCol, endCol;
//GetVisibleRange(startRow, endRow, startCol, endCol);

CMapFileParse mapFileParse;
int m_rowCount = mapFileParse.GetRowCount();
int m_colCount = mapFileParse.GetColCount();
for (int row = 0; row < m_rowCount; ++row) {
	for (int col = 0; col < m_colCount; ++col) {
		DrawCell(pDC, row, col);
	}
}

}

// 表格
void CMapView::DrawCell(CDC* pDC, int row, int col) {
CellInfo& cell = m_cells[row][col];
int x = col * m_cellSize * m_zoomLevel + m_origin.x;
int y = row * m_cellSize * m_zoomLevel + m_origin.y;
int width = m_cellSize * m_zoomLevel;
int height = m_cellSize * m_zoomLevel;
CRect rect(x, y, x + width, y + height);

// 绘制单元格的背景和边框
pDC->FillSolidRect(&rect, RGB(255, 255, 255)); // 设置背景色为白色
pDC->Rectangle(&rect); // 绘制边框

// 绘制符号
char symbol = cell.CSInfo.symbol;
if (symbol != '\0') // 使用 '\0' 检查是否为空，CString数型才特有判断为空
{
	pDC->SetTextColor(cell.CSInfo.color); // 设置文字颜色
	CString strSymbol(symbol); // 将 char 转换为 CString
	pDC->TextOutW(x + (width / 2), y + (height / 2), strSymbol);
}

}

// 执行填充，绘制边框的操作
void CMapView::HighlightSelectedCells(CDC* pDC) {
// 绘制选中的单元格
for (const auto& cell : m_selectedCells)
{
int x = cell.x * m_cellSize * m_zoomLevel + m_origin.x;
int y = cell.y * m_cellSize * m_zoomLevel + m_origin.y;
int width = m_cellSize * m_zoomLevel;
int height = m_cellSize * m_zoomLevel;
CRect rect(x, y, x + width, y + height);

	// 使用红色来填充选中的单元格
	pDC->FillSolidRect(&rect, RGB(255, 0, 0));
	// 使用红色来高亮显示选中的单元格的边框
	CPen pen(PS_SOLID, 2, RGB(255, 0, 0));  // 2为边框宽度，可以根据需要调整
	CPen* pOldPen = pDC->SelectObject(&pen); // 绘制边框
	pDC->Rectangle(&rect);
	pDC->SelectObject(pOldPen); // 恢复原来的画笔
}

}

// 绘制选择矩形
void CMapView::DrawSelectionRect(CDC* pDC)
{
if (m_isSelecting)
{
CPen pen(PS_SOLID, 1, RGB(0, 0, 255)); // 使用蓝色来绘制选择矩形
CPen* pOldPen = pDC->SelectObject(&pen);
CBrush* pOldBrush = static_cast<CBrush*>(pDC->SelectStockObject(NULL_BRUSH)); // 使用空刷子来避免填充矩形
pDC->Rectangle(CRect(m_dragStartPoint, m_lastDragPoint));
pDC->SelectObject(pOldBrush);
pDC->SelectObject(pOldPen);
}
}

// 画标记
void CMapView::DrawMarkers(CDC* pDC) {
}

// 画出路径
void CMapView::DrawPath(CDC* pDC) {
}

// 绘制UI元素
void CMapView::DrawUIElements(CDC* pDC) {
}

//CRect CMapView::GetVisibleRange() const {
// // 计算并返回一个矩形，该矩形包含当前可见的单元格的范围。
// // 这将依赖于当前的滚动位置和视图的大小。
//}

BOOL CMapView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
if (nHitTest == HTCLIENT) {
// 设置鼠标样式。您可以选择其他的鼠标样式。
//::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_HAND)); // 手形
::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS)); // 十字形
return TRUE; // 表示已经处理此消息
}
return CView::OnSetCursor(pWnd, nHitTest, message);
}

/* * * * * 鸟瞰图
*
*/
//void CMapView::OnZoomOrPan()
//{ // 执行缩放或平移操作
//
// // 调用回调以通知视图已更改
// if (m_viewChangedCallback) {
// m_viewChangedCallback();
// }
//}
//void CMapView::UpdateAerialView() // 需要在放大/缩小地图或更改偏移量时调用UpdateAerialView方法。
//{
//}
//void CMapView::SetOffset(int offsetX, int offsetY)
//{
//
// // std::vectorstd::string m_mapData;
// // int mapWidth = m_mapData[0].size() * m_cellSize * m_zoomLevel;
// //int mapWidth = m_pDlg->GetMapData()[0].size() * m_cellSize * m_zoomLevel;
// //int mapHeight = m_pDlg->GetMapData()[0].size() * m_cellSize * m_zoomLevel;
// int mapWidth = m_pDlg->GetMapData()[0].size() * m_cellSize * m_zoomLevel;// 获取地图的尺寸
// int mapHeight = m_pDlg->GetMapData().size() * m_cellSize * m_zoomLevel;
//
//
// // 获取窗口的大小
// CRect clientRect;
// GetClientRect(&clientRect);
//
// // 限制偏移量的范围
// m_offsetX = max(0, min(offsetX, mapWidth - clientRect.Width()));
// m_offsetY = max(0, min(offsetY, mapHeight - clientRect.Height()));
// //m_offsetX = std::max(0, std::min(offsetX, mapWidth - clientRect.Width()));
// //m_offsetX = offsetX;
// //if (m_offsetX < 0) m_offsetX = 0;
// //if (m_offsetX > mapWidth - clientRect.Width()) m_offsetX = mapWidth - clientRect.Width();
// //m_offsetY = std::max(0, std::min(offsetY, mapHeight - clientRect.Height()));
// //m_offsetY = offsetY;
// //if (m_offsetY < 0) m_offsetY = 0;
// //if (m_offsetY > mapWidth - clientRect.Width()) m_offsetY = mapWidth - clientRect.Width();
//
// Invalidate();
//}
在放大或缩小时确保视图区域仍然在盒子的内部
//void CMapView::ensureVisibleAreaInBounds() {
// CRect clientRect;// 获取控件的尺寸
// GetClientRect(&clientRect);
//
// // 如果放大镜的右侧或下侧超出了盒子的边界，调整偏移量
// if (m_offsetX + clientRect.Width() > m_pDlg->GetMapData()[0].size() * m_cellSize * m_zoomLevel) {
// m_offsetX = m_pDlg->GetMapData()[0].size() * m_cellSize * m_zoomLevel - clientRect.Width();
// }
// if (m_offsetY + clientRect.Height() > m_pDlg->GetMapData().size() * m_cellSize * m_zoomLevel) {
// m_offsetY = m_pDlg->GetMapData().size() * m_cellSize * m_zoomLevel - clientRect.Height();
// }
//}

CMapData类代码：
#pragma once

//CMapFileParse
#include
#include
#include
#include “WaferMapViewDlg.h”

// // 类定义
class CMapData {
public:
/// 数据处理
/// /
///
struct ColorSymbol {// 存储符号和对应的颜色
int id;
char symbol;
int symbolNum;
COLORREF color;
//ChipType chipType;
};
// 用于优化colorSymbols
enum ChipType {
EDGE_CHIP, // 边缘芯片
WORKING_CHIP, // 工作芯片
TAKE_CHIP, // 取芯片
SKIP_CHIP, // 跳过芯片
INVALID_CHIP, // 无效芯片
OTHER_CHIP, // 添加其他类型的芯片
CHIP_TYPE_COUNT // 芯片类型数量
};

/// <summary>  表格绘图
/// /	
/// </summary>
// 单元格的信息：符号、背景色、边框，选中状态
// struct 嵌套struct，struct 嵌套enum

struct oneCell {
	CString content; // 单元格内容
	COLORREF backgroundColor; // 背景颜色
	COLORREF borderColor; // 边框颜色
};

// 标志的操作类型
enum operType {
	START_POS,		// 开始位置
	END_POS,		// 结束位置
	ROABIO1,		// 良品
	BAD,			// 次品
	SKIP,			// 跳过
	REFERENCE1,		// 参考点1
	REFERENCE2,		// 参考点2
	REFERENCE3,		// 参考点3
	CENTRAL_POS,	// 中心位
	OPER_POS,		// 操作位
};

// 单表格的标志信息
struct fiagInfo {
	ColorSymbol colorSymbol; 
	operType fiagType;
	int x;
	int y;
	COLORREF color;
};
// 每个表格的内容

// static中显示的表格

// 表格

};