#include "Resource.h"
#include "windows.h"
IDD_DIALOG1 DIALOGEX 0, 0, 200, 100
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "登录"
FONT 9, "宋体"
BEGIN
LTEXT "用户ID:", IDC_STATIC1, 10, 10, 30, 12
EDITTEXT IDC_EDIT1, 50, 20, 100, 20
LTEXT "密码:", IDC_STATIC2, 10, 40, 30, 12
EDITTEXT IDC_EDIT2, 50, 50, 100, 20, ES_PASSWORD
DEFPUSHBUTTON "确定", IDOK, 50, 80, 50, 15
PUSHBUTTON "取消", IDCANCEL, 110, 80, 50, 15
END
IDD_DIALOG2 DIALOGEX 0, 0, 300, 200
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "主界面"
FONT 8, "MS Shell Dlg", 0, 0, 0x1
BEGIN
LTEXT "登录成功!欢迎来到南京工业职业技术大学校园导航系统。", IDC_STATIC, 10, 10, 280, 20
DEFPUSHBUTTON "确定", IDOK, 120, 160, 80, 25
CONTROL "哈夫曼编码", IDC_BTN_HUFFMAN_ENCODE, "Button", BS_PUSHBUTTON, 10, 100, 80, 20
CONTROL "哈夫曼解码", IDC_BTN_HUFFMAN_DECODE, "Button", BS_PUSHBUTTON, 100, 100, 80, 20
CONTROL "DFS走迷宫", IDC_BTN_MAZE_DFS, "Button", BS_PUSHBUTTON, 10, 130, 80, 20
CONTROL "BFS走迷宫", IDC_BTN_MAZE_BFS, "Button", BS_PUSHBUTTON, 100, 130, 80, 20
PUSHBUTTON "查询最短路径", IDC_BTN_OPEN_NAVI, 100, 200, 80, 14
END
// 第三个对话框:校园导航界面
IDD_DIALOG3 DIALOGEX 0, 0, 400, 300
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "仙林校区导航"
FONT 8, "MS Shell Dlg", 0, 0, 0x1
BEGIN
// 起点标签
LTEXT "起点:", IDC_STATIC, 10, 20, 30, 15
// 起点下拉框(ID:IDC_COMBO_START)
COMBOBOX IDC_COMBO_START, 45, 20, 150, 100, CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
// 终点标签
LTEXT "终点:", IDC_STATIC, 210, 20, 30, 15
// 终点下拉框(ID:IDC_COMBO_END)
COMBOBOX IDC_COMBO_END, 245, 20, 150, 100, CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
// 查询路径按钮(ID:IDC_BTN_QUERY)
PUSHBUTTON "查询最短路径", IDC_BTN_QUERY, 150, 60, 100, 25
// 路径显示区域(多行编辑框,ID:IDC_EDIT_PATH)
EDITTEXT IDC_EDIT_PATH, 10, 100, 380, 180, ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_TABSTOP
END这是资源文件 #include <Windows.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <queue>
#include <climits>
#include <sstream>
#include "Resource.h"
#include <map>
#include <stack>
#include <deque>
#include <functional>
// 登录对话框的消息处理函数
INT_PTR CALLBACK LoginDlgProc(HWND hDlg, UINT msg, WPARAM wp, LPARAM lp) {
switch (msg) {
case WM_COMMAND:
if (wp == IDOK || wp == IDCANCEL) {
EndDialog(hDlg, wp);
return TRUE;
}
break;
case WM_CLOSE:
EndDialog(hDlg, IDCANCEL);
return TRUE;
}
return FALSE;
}
// 定义校园地点(顶点)
enum CampusPlace {
PLACE_BEI_DAMEN, // 北大门
PLACE_XI_DAMEN, // 西大门
PLACE_NAN_DAMEN, // 南大门
PLACE_SONGSHAN_HU, // 松山湖
PLACE_XIN_TIYU_CHANG, // 新体育场
PLACE_OLD_TIYU_CHANG, // 老体育场
PLACE_LEQUN_LOU, // 乐群楼
PLACE_QIUZHEN_LOU, // 求真楼
PLACE_JINGYE_LOU, // 敬业楼
PLACE_HOU_CUN_G1, // 乐业楼
PLACE_HAI_TANG_YUAN, // 海棠苑
PLACE_WU_TONG_YUAN, // 梧桐苑
PLACE_XUE_SHU_JIAO_LIU_ZHONG_XIN ,// 学术交流中心
PLACE_SHUANG_CHUANG_LOU, //双创大楼
PLACE_GONG_YE_ZHONG_XIN, //工业中心
PLACE_XING_ZHEN_LOU, //行政楼
PLACE_JUN_ZHU_YUAN, //筠竹苑
PLACE_XIANG_ZHANG_YUN, //香樟苑
PLACE_SAN_SI_SHI_TANG, //第二食堂
PLACE_YI_ER_SHI_TANG, //第一食堂
};
// 地点名称映射
const std::unordered_map<CampusPlace, std::wstring> PlaceNames = {
{PLACE_BEI_DAMEN, L"北大门"},
{PLACE_XI_DAMEN, L"西大门"},
{PLACE_NAN_DAMEN, L"南大门"},
{PLACE_SONGSHAN_HU, L"松山湖"},
{PLACE_XIN_TIYU_CHANG, L"新体育场"},
{PLACE_OLD_TIYU_CHANG, L"老体育场"},
{PLACE_LEQUN_LOU, L"乐群楼"},
{PLACE_QIUZHEN_LOU, L"求真楼"},
{PLACE_JINGYE_LOU, L"敬业楼"},
{PLACE_HOU_CUN_G1, L"乐业楼"},
{PLACE_HAI_TANG_YUAN, L"海棠苑"},
{PLACE_WU_TONG_YUAN, L"梧桐苑"},
{PLACE_XUE_SHU_JIAO_LIU_ZHONG_XIN, L"学术交流中心"},
{PLACE_SHUANG_CHUANG_LOU, L"双创大楼"},
{PLACE_GONG_YE_ZHONG_XIN,L"工业中心"},
{PLACE_XING_ZHEN_LOU,L"行政楼"},
{PLACE_JUN_ZHU_YUAN,L"筠竹苑"},
{PLACE_XIANG_ZHANG_YUN,L"香樟苑"},
{PLACE_SAN_SI_SHI_TANG,L"第二食堂"},
{PLACE_YI_ER_SHI_TANG,L"第一食堂"}
};
// 优化后的校园地图邻接表
std::unordered_map<CampusPlace, std::vector<std::pair<CampusPlace, int>>> CampusGraph = {
// 北大门
{PLACE_BEI_DAMEN, {
{PLACE_HOU_CUN_G1, 8}, // 北大门 → 乐业楼 (8分钟)
{PLACE_XIN_TIYU_CHANG, 8}, // 北大门 → 新体育场 (8分钟)
{PLACE_QIUZHEN_LOU, 15}, // 北大门 → 求真楼 (15分钟,直达)
{ PLACE_SHUANG_CHUANG_LOU, 3},
{PLACE_GONG_YE_ZHONG_XIN,2},
{PLACE_SAN_SI_SHI_TANG,10},
}},
// 西大门
{PLACE_XI_DAMEN, {
{PLACE_WU_TONG_YUAN, 3}, // 西大门 → 梧桐苑 (3分钟)
{PLACE_HAI_TANG_YUAN, 5}, // 西大门 → 海棠苑 (5分钟)
{PLACE_LEQUN_LOU, 10} // 西大门 → 乐群楼 (10分钟)
}},
// 南大门
{PLACE_NAN_DAMEN, {
{PLACE_XUE_SHU_JIAO_LIU_ZHONG_XIN, 3}, // 南大门 → 学术交流中心 (3分钟)
{PLACE_JINGYE_LOU, 12}, // 南大门 → 敬业楼 (12分钟)
{PLACE_SONGSHAN_HU, 15} // 南大门 → 松山湖 (15分钟)
}},
// 松山湖
{PLACE_SONGSHAN_HU, {
{PLACE_XIN_TIYU_CHANG, 3}, // 松山湖 → 新体育场 (3分钟)
{PLACE_OLD_TIYU_CHANG, 4}, // 松山湖 → 老体育场 (4分钟)
{PLACE_HAI_TANG_YUAN, 6}, // 松山湖 → 海棠苑 (6分钟)
{PLACE_NAN_DAMEN, 15} // 松山湖 → 南大门 (15分钟)
}},
// 新体育场
{PLACE_XIN_TIYU_CHANG, {
{PLACE_BEI_DAMEN, 8}, // 新体育场 → 北大门 (8分钟)
{PLACE_SONGSHAN_HU, 3}, // 新体育场 → 松山湖 (3分钟)
{PLACE_OLD_TIYU_CHANG, 5} // 新体育场 → 老体育场 (5分钟)
}},
// 老体育场
{PLACE_OLD_TIYU_CHANG, {
{PLACE_SONGSHAN_HU, 4}, // 老体育场 → 松山湖 (4分钟)
{PLACE_XIN_TIYU_CHANG, 5}, // 老体育场 → 新体育场 (5分钟)
{PLACE_LEQUN_LOU, 2} // 老体育场 → 乐群楼 (2分钟)
}},
// 乐群楼
{PLACE_LEQUN_LOU, {
{PLACE_OLD_TIYU_CHANG, 2}, // 乐群楼 → 老体育场 (2分钟)
{PLACE_QIUZHEN_LOU, 3}, // 乐群楼 → 求真楼 (3分钟)
{PLACE_JINGYE_LOU, 4}, // 乐群楼 → 敬业楼 (4分钟)
{PLACE_XI_DAMEN, 10} // 乐群楼 → 西大门 (10分钟)
}},
// 求真楼
{PLACE_QIUZHEN_LOU, {
{PLACE_LEQUN_LOU, 3}, // 求真楼 → 乐群楼 (3分钟)
{PLACE_BEI_DAMEN, 15}, // 求真楼 → 北大门 (15分钟)
{PLACE_JINGYE_LOU, 2} // 求真楼 → 敬业楼 (2分钟)
}},
// 敬业楼
{PLACE_JINGYE_LOU, {
{PLACE_LEQUN_LOU, 4}, // 敬业楼 → 乐群楼 (4分钟)
{PLACE_QIUZHEN_LOU, 2}, // 敬业楼 → 求真楼 (2分钟)
{PLACE_NAN_DAMEN, 12} // 敬业楼 → 南大门 (12分钟)
}},
// 乐业楼
{PLACE_HOU_CUN_G1, {
{PLACE_BEI_DAMEN, 5}, // 航训楼G1 → 北大门 (5分钟)
{PLACE_XIN_TIYU_CHANG, 10}, // 航训楼G1 → 新体育场 (10分钟)
{PLACE_LEQUN_LOU, 4}
}},
// 海棠苑
{PLACE_HAI_TANG_YUAN, {
{PLACE_SONGSHAN_HU, 6}, // 海棠苑 → 松山湖 (6分钟)
{PLACE_WU_TONG_YUAN, 2}, // 海棠苑 → 梧桐苑 (2分钟)
{PLACE_XI_DAMEN, 5} // 海棠苑 → 西大门 (5分钟)
}},
// 梧桐苑
{PLACE_WU_TONG_YUAN, {
{PLACE_HAI_TANG_YUAN, 2}, // 梧桐苑 → 海棠苑 (2分钟)
{PLACE_XI_DAMEN, 3} // 梧桐苑 → 西大门 (3分钟)
}},
// 学术交流中心
{PLACE_XUE_SHU_JIAO_LIU_ZHONG_XIN, {
{PLACE_NAN_DAMEN, 3}, // 学术交流中心 → 南大门 (3分钟)
{PLACE_JINGYE_LOU, 10} // 学术交流中心 → 敬业楼 (10分钟)
}}
};
// Dijkstra算法:计算起点到终点的最短路径
std::pair<std::vector<CampusPlace>, int> DijkstraShortestPath(CampusPlace start, CampusPlace end) {
// 距离数组:记录每个地点的最短距离
std::unordered_map<CampusPlace, int> dist;
// 前驱节点数组:记录路径
std::unordered_map<CampusPlace, CampusPlace> prev;
// 优先队列(小顶堆):存储 (当前距离, 地点)
std::priority_queue<std::pair<int, CampusPlace>,
std::vector<std::pair<int, CampusPlace>>,
std::greater<std::pair<int, CampusPlace>>> pq;
// 1. 初始化所有距离为无穷大
for (const auto& entry : CampusGraph) {
dist[entry.first] = INT_MAX;
prev[entry.first] = (CampusPlace)-1;
}
// 起点到自身的距离为0
dist[start] = 0;
pq.push({0, start});
while (!pq.empty()) {
// 2. 取出当前距离最小的节点
auto current = pq.top().second;
pq.pop();
// 如果已经到达终点,可以提前退出以提高效率
if (current == end) {
break;
}
// 3. 遍历当前节点的所有邻居
for (const auto& neighbor_pair : CampusGraph[current]) {
CampusPlace next_place = neighbor_pair.first;
int weight = neighbor_pair.second;
// 4. 松弛操作:更新距离
if (dist[current] != INT_MAX && dist[next_place] > dist[current] + weight) {
dist[next_place] = dist[current] + weight;
prev[next_place] = current; // 更新前驱节点
pq.push({dist[next_place], next_place});
}
}
}
// 5. 从终点回溯到起点,重建路径
std::vector<CampusPlace> path;
if (dist[end] != INT_MAX) { // 只有当终点可达时才重建路径
for (CampusPlace p = end; p != (CampusPlace)-1; p = prev[p]) {
path.push_back(p);
}
std::reverse(path.begin(), path.end()); // 反转路径,使其从起点到终点
}
// 返回路径和总距离,如果不可达,总距离为-1
return {path, dist[end] == INT_MAX ? -1 : dist[end]};
}
// 导航对话框的消息处理函数
INT_PTR CALLBACK NaviDlgProc(HWND hDlg, UINT msg, WPARAM wp, LPARAM lp) {
switch (msg) {
case WM_INITDIALOG: {
// 初始化起点/终点下拉框
HWND hComboStart = GetDlgItem(hDlg, IDC_COMBO_START);
HWND hComboEnd = GetDlgItem(hDlg, IDC_COMBO_END);
// 向下拉框添加地点选项
for (const auto& entry : PlaceNames) {
SendMessage(hComboStart, CB_ADDSTRING, 0, (LPARAM)entry.second.c_str());
SendMessage(hComboEnd, CB_ADDSTRING, 0, (LPARAM)entry.second.c_str());
}
// 默认选择第一个选项
SendMessage(hComboStart, CB_SETCURSEL, 0, 0);
SendMessage(hComboEnd, CB_SETCURSEL, 1, 0);
return TRUE;
}
case WM_COMMAND: {
if (LOWORD(wp) == IDC_BTN_QUERY) {
// 点击“查询路径”按钮
HWND hComboStart = GetDlgItem(hDlg, IDC_COMBO_START);
HWND hComboEnd = GetDlgItem(hDlg, IDC_COMBO_END);
HWND hEditPath = GetDlgItem(hDlg, IDC_EDIT_PATH);
// 获取选择的起点/终点索引
int startIdx = SendMessage(hComboStart, CB_GETCURSEL, 0, 0);
int endIdx = SendMessage(hComboEnd, CB_GETCURSEL, 0, 0);
if (startIdx == CB_ERR || endIdx == CB_ERR) {
MessageBox(hDlg, L"请选择起点和终点!", L"提示", MB_ICONINFORMATION);
return TRUE;
}
// 转换为CampusPlace枚举
CampusPlace start = (CampusPlace)startIdx;
CampusPlace end = (CampusPlace)endIdx;
// 计算最短路径
auto [path, totalTime] = DijkstraShortestPath(start, end);
if (path.empty() || totalTime == INT_MAX) {
SetWindowText(hEditPath, L"无法到达该地点!");
return TRUE;
}
// 格式化路径文本
std::wstringstream ss;
ss << L"最短路径(步行约" << totalTime << L"分钟):\n";
for (size_t i = 0; i < path.size(); ++i) {
ss << PlaceNames.at(path[i]);
if (i != path.size() - 1) ss << L" → ";
}
SetWindowText(hEditPath, ss.str().c_str());
return TRUE;
}
// 处理关闭/取消按钮
else if (LOWORD(wp) == IDOK || LOWORD(wp) == IDCANCEL) {
EndDialog(hDlg, LOWORD(wp));
return TRUE;
}
break;
}
case WM_CLOSE: {
EndDialog(hDlg, IDCANCEL);
return TRUE;
}
}
return FALSE;
}
// ==================== Huffman 编码与解码 ====================
// 哈夫曼树节点
struct HuffmanNode {
wchar_t ch; // 字符
int freq; // 频率
HuffmanNode* left, * right; // 左右子树
HuffmanNode(wchar_t c, int f) : ch(c), freq(f), left(nullptr), right(nullptr) {}
};
// 比较函数,用于优先队列(最小堆)
struct Compare {
bool operator()(HuffmanNode* a, HuffmanNode* b) {
return a->freq > b->freq; // 小根堆
}
};
// 存储编码结果的映射表
std::map<wchar_t, std::wstring> huffmanCodeMap;
std::map<std::wstring, wchar_t> huffmanDecodeMap; // 反向映射用于解码
// 构建哈夫曼树并生成编码
void BuildHuffmanCodes(const std::map<wchar_t, int>& freqMap) {
std::priority_queue<HuffmanNode*, std::vector<HuffmanNode*>, Compare> pq;
// 创建叶子节点并加入优先队列
for (const auto& p : freqMap) {
pq.push(new HuffmanNode(p.first, p.second));
}
// 构造哈夫曼树
while (pq.size() > 1) {
HuffmanNode* left = pq.top(); pq.pop();
HuffmanNode* right = pq.top(); pq.pop();
HuffmanNode* merged = new HuffmanNode(L'\0', left->freq + right->freq);
merged->left = left;
merged->right = right;
pq.push(merged);
}
// 根节点
HuffmanNode* root = pq.top();
// 递归生成编码
std::function<void(HuffmanNode*, std::wstring)> generateCodes;
generateCodes = [&](HuffmanNode* node, std::wstring code) {
if (!node) return;
if (node->ch != L'\0') { // 叶子节点
huffmanCodeMap[node->ch] = code;
huffmanDecodeMap[code] = node->ch;
}
else {
generateCodes(node->left, code + L"0");
generateCodes(node->right, code + L"1");
}
};
generateCodes(root, L"");
// 清理内存(可选,实际应用中建议智能指针)
std::function<void(HuffmanNode*)> deleteTree;
deleteTree = [&](HuffmanNode* node) {
if (node) {
deleteTree(node->left);
deleteTree(node->right);
delete node;
}
};
deleteTree(root); // 删除动态分配的树
}
// 编码函数
std::wstring HuffmanEncode(const std::wstring& text) {
// 统计频率
std::map<wchar_t, int> freqMap;
for (wchar_t ch : text) {
freqMap[ch]++;
}
// 构建编码表
huffmanCodeMap.clear();
huffmanDecodeMap.clear();
BuildHuffmanCodes(freqMap);
// 编码
std::wstringstream ss;
for (wchar_t ch : text) {
ss << huffmanCodeMap[ch];
}
return ss.str();
}
// 解码函数
std::wstring HuffmanDecode(const std::wstring& encoded) {
std::wstring current = L"", result = L"";
for (wchar_t bit : encoded) {
current += bit;
auto it = huffmanDecodeMap.find(current);
if (it != huffmanDecodeMap.end()) {
result += it->second;
current = L"";
}
}
return result;
}
// ==================== 走迷宫(图的遍历) ====================
const int MAX_MAZE_SIZE = 10;
int maze[MAX_MAZE_SIZE][MAX_MAZE_SIZE] = {
{0, 1, 0, 0, 0},
{0, 1, 0, 1, 0},
{0, 0, 0, 1, 0},
{1, 1, 0, 0, 0},
{0, 0, 0, 1, 0}
};
int mazeRows = 5, mazeCols = 5;
struct Point {
int x, y;
std::wstring path; // 记录路径(例如 "→↓↓→")
Point(int x, int y, const std::wstring& p = L"") : x(x), y(y), path(p) {}
};
// 方向数组:上下左右
const int dx[4] = { -1, 1, 0, 0 };
const int dy[4] = { 0, 0, -1, 1 };
const wchar_t dirChar[4] = { L'↑', L'↓', L'←', L'→' };
// 检查是否越界或碰到墙
bool IsValid(int x, int y, bool visited[][MAX_MAZE_SIZE]) {
return x >= 0 && x < mazeRows && y >= 0 && y < mazeCols && !maze[x][y] && !visited[x][y];
}
// 使用 DFS 寻找一条可行路径
std::wstring MazeDFS() {
bool visited[MAX_MAZE_SIZE][MAX_MAZE_SIZE] = {};
std::stack<Point> stk;
stk.push(Point(0, 0, L"起点"));
while (!stk.empty()) {
Point curr = stk.top(); stk.pop();
int x = curr.x, y = curr.y;
if (x == mazeRows - 1 && y == mazeCols - 1) {
return curr.path + L" → 终点";
}
visited[x][y] = true;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (IsValid(nx, ny, visited)) {
std::wstring newPath = curr.path + L" → " + dirChar[i];
stk.push(Point(nx, ny, newPath));
}
}
}
return L"DFS:未找到路径";
}
// 使用 BFS 寻找最短路径(按步数最少)
std::wstring MazeBFS() {
bool visited[MAX_MAZE_SIZE][MAX_MAZE_SIZE] = {};
std::queue<Point> q;
q.push(Point(0, 0, L"起点"));
visited[0][0] = true;
while (!q.empty()) {
Point curr = q.front(); q.pop();
int x = curr.x, y = curr.y;
if (x == mazeRows - 1 && y == mazeCols - 1) {
return curr.path + L" → 终点";
}
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (IsValid(nx, ny, visited)) {
visited[nx][ny] = true;
std::wstring newPath = curr.path + L" → " + dirChar[i];
q.push(Point(nx, ny, newPath));
}
}
}
return L"BFS:未找到路径";
}
// 主界面对话框的消息处理函数(已增强:支持哈夫曼编码、解码、迷宫遍历)
INT_PTR CALLBACK MainDlgProc(HWND hDlg, UINT msg, WPARAM wp, LPARAM lp) {
switch (msg) {
case WM_COMMAND:
{
// 处理确定/取消关闭对话框
if (LOWORD(wp) == IDOK || LOWORD(wp) == IDCANCEL) {
EndDialog(hDlg, LOWORD(wp));
return TRUE;
}
// 处理新增的功能按钮
switch (LOWORD(wp)) {
case IDC_BTN_HUFFMAN_ENCODE: {
std::wstring encoded = HuffmanEncode(L"ABACCDA");
std::wstringstream ss;
ss << L"原文: ABACCDA\n";
ss << L"编码: " << encoded << L"\n\n";
ss << L"编码表:\n";
for (const auto& kv : huffmanCodeMap) {
ss << kv.first << L" → " << kv.second << L"\n";
}
// 实时更新编辑框内容
SetWindowText(GetDlgItem(hDlg, IDC_EDIT_OUTPUT), ss.str().c_str());
return TRUE; // 表示已处理,不关闭对话框
}
case IDC_BTN_HUFFMAN_DECODE: {
// 先确保编码表已生成
std::wstring input = L"ABACCDA";
HuffmanEncode(input); // 构建编码表
std::wstring encoded = HuffmanEncode(input);
std::wstring decoded = HuffmanDecode(encoded);
std::wstringstream ss;
ss << L"编码串:" << encoded << L"\n";
ss << L"解码结果:" << decoded << L"\n";
ss << L"是否一致:" << (input == decoded ? L"是" : L"否");
SetWindowText(GetDlgItem(hDlg, IDC_EDIT_OUTPUT), ss.str().c_str());
return TRUE;
}
case IDC_BTN_MAZE_DFS: {
std::wstring result = MazeDFS();
SetWindowText(GetDlgItem(hDlg, IDC_EDIT_OUTPUT), result.c_str());
return TRUE;
}
case IDC_BTN_MAZE_BFS: {
std::wstring result = MazeBFS();
SetWindowText(GetDlgItem(hDlg, IDC_EDIT_OUTPUT), result.c_str());
return TRUE;
}
case IDC_BTN_OPEN_NAVI: {
// 打开导航对话框(阻塞式)
DialogBox(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_DIALOG3), hDlg, NaviDlgProc);
return TRUE;
}
}
}
break;
case WM_CLOSE:
EndDialog(hDlg, IDCANCEL);
return TRUE;
}
return FALSE;
}
int APIENTRY wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, int) {
// 1. 显示登录对话框
INT_PTR nLoginResult = DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), nullptr, LoginDlgProc);
// 2. 如果登录成功(点击“确定”),显示主界面
if (nLoginResult == IDOK) {
INT_PTR nMainResult = DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG2), nullptr, MainDlgProc);
// 3. 如果主界面点击“确定”,显示导航界面
}
// 所有界面关闭后,程序退出
return 0;
}