怎样实现一个可视化的文字编辑器（C语言版）？

一、软件安装

Visual Studio 2022

Visual Studio 2022 是微软提供的强大集成开发情况（IDE），广泛用于C/C++、C#、Python等多种编程语言的开发。它提供了很多强大的工具，资助开发者编写、调试和优化代码。
1.下载 Visual Studio 2022：访问Visual Studio 官网
2.点击 Download Visual Studio，选择 Community Edition（免费）或其他版本，根据需求选择。

2.安装 Visual Studio：运行下载的安装步伐，启动 Visual Studio 安装步伐。
在安装界面选择 Desktop development with C++，开发 C++ 步伐所需的工作负载。
可以根据必要选择其他组件，好比 Windows 10 SDK、C++ CMake tools 等，资助进行图形和图像处置惩罚的开发，完成安装后，启动 Visual Studio 2022，选择 Create a new project 来创建新的C++项目。（不会安装的可以搜一下干系教程）
安装 EasyX 图形库 

1.下载 EasyX 图形库：EasyX官网，根据必要选择符合版本。

2.安装 EasyX：

 
二、结果演示

1.界面样式

2.读入文件

3.查找

4.插入文字

5.更换

三、代码实现

Text.h:该文件是 Text.cpp 的头文件，声明了文本操作干系的结构体和函数接口。

• Node 结构体：表现链表中的一个字符节点。包含字符内容、字符在屏幕上的位置、是否为平凡字符、是否被选中等信息。
  
• Text 结构体：表现文本内容，包含头指针、尾指针和当前光标位置。
  
• File 结构体：表现文件，包含文件路径和文本内容。
  
• 函数声明：如 readFile()、writeFile()、insertText()、deleteCharacter() 等。
  

1. #pragma once
2. /*
3. 该模块用于文本的操作
4. */
6. #include <stdio.h>
7. #include <stdlib.h>
8. #include <string.h>
9. #include <stdbool.h>
11. // 该结构体表示链表结点
12. typedef struct Node Node;
13. struct Node {
14.         char content[3]; // 表示一个普通字符或中午字符
15.         int rect[4]; // 字符在屏幕上所占的区域
16.         bool normal; // 是否是普通字符
17.         bool selected; // 是否被选中
18.         Node* next;
19.         Node* prev;
20. };
22. // 该结构体表示文本
23. typedef struct Text Text;
24. struct Text {
25.         Node* head; // 头指针
26.         Node* tail; // 尾指针
27.         Node* cursor; // 当前指针位置
28. };
30. // 该结构体表示文件
31. typedef struct File File;
32. struct File {
33.         char path[256]; // 文件的路径
34.         Text* text; // 文件的内容
35. };
37. // 读入文件
38. bool readFile(char* path);
40. // 写入文件
41. void writeFile();
43. // 新建文件
44. bool createFile(char* path);
46. // 保存文件
47. bool saveFile(char* path);
49. // 获取当前文件
50. File* getCurrentFile();
52. // 释放相关内存
53. void freeResources();
55. // 插入文字
56. void insertText(char* mContent);
58. // 删除字符
59. void deleteCharacter(bool isAfter);
61. // 重置选中标志
62. void resetSelected();
64. // 查找字符串
65. void findString(char* searchText);
67. // 替换字符串
68. void replaceString(char* srcText, char* dstText);

复制代码

Text.cpp:实现了文本内容的管理与操作，包罗文件的读取、生存、文本的插入、删除、查找和更换等。它利用了链表结构来构造文本内容。

• readFile()：
  
  
  
  • 读取指定路径的文件，并将文件内容分析为字符。读取的字符根据其字节数判定是平凡字符还是中文字符，并将其存储到链表中。
    
  • 利用 fread() 函数按字节读取文件内容，若字符为平凡字符，则将其存储在 content[] 中，若为中文字符，则按两个字节读取。
    
  
  
• writeFile()：
  
  
  
  • 将当前内存中的文本内容（链表结构）生存到文件中。通过 fopen() 打开文件，并逐个节点将文本内容写入。
    
  
  
• createFile()：
  
  
  
  • 创建新文件并为其分配内存。调用 writeFile() 生存当前文件内容，释放内存，创建新文件，并初始化新的文本结构。
    
  
  
• insertText()：
  
  
  
  • 在当前光标位置插入文本。通过 appendString() 函数将新的文本插入到链表的对应位置。
    
  
  
• deleteCharacter()：
  
  
  
  • 删除当前光标位置的字符。通过检查光标的位置（isAfter 参数决定删除前或后字符）来删除指定的字符节点。
    
  
  
• findString()：
  
  
  
  • 查找指定的字符串，并将找到的部门高亮表现。通过遍历链表中的节点，并检查每个节点的 content 是否与目的字符串匹配。
    
  
  
• replaceString()：
  
  
  
  • 查找并更换文本中的指定字符串。通过遍历链表查找目的字符串，若找到则更换为指定的新字符串。
    
  
  

1. #include "Text.h"
3. // 在某个节点后添加字符串
4. void appendString(Node** beforeNode, char* mContent, bool modifyBeforeNode);
6. // 当前的文件
7. static File* curFile = NULL;
9. // 为新文件分配内容
10. static void initFile(File* file, char* path) {
11.         strcpy(curFile->path, path);
12.         curFile->text = (Text*)calloc(1, sizeof(Text));
13.         curFile->text->head = (Node*)calloc(1, sizeof(Node));
14.         curFile->text->tail = (Node*)calloc(1, sizeof(Node));
15.         curFile->text->head->next = curFile->text->tail;
16.         curFile->text->tail->prev = curFile->text->head;
17.         curFile->text->cursor = curFile->text->head;
18. }
20. // 释放文件占用的内存
21. static void destroyFile(File** file) {
22.         while ((*file)->text->head->next != (*file)->text->tail) {
23.                 Node* node = (*file)->text->head->next;
24.                 (*file)->text->head->next = node->next;
25.                 free(node);
26.         }
27.         free((*file)->text->head);
28.         free((*file)->text->tail);
29.         free(*file);
30.         *file = NULL;
31. }
33. // 在Text中添加一个Node
34. static void insertNode(Node* beforeNode, char content[], bool normal) {
35.         Node* node = (Node*)calloc(1, sizeof(Node));
36.         strcpy(node->content, content);
37.         node->normal = normal;
38.         node->selected = false;
39.         node->next = beforeNode->next;
40.         node->prev = beforeNode;
41.         beforeNode->next->prev = node;
42.         beforeNode->next = node;
43. }
45. // 读入文件
46. bool readFile(char* path) {
47.         // 确保文件存在
48.         FILE* file = fopen(path, "rb");
49.         if (!file) {
50.                 return false;
51.         }
52.        
53.         // 保存当前文件
54.         writeFile();
56.         // 释放内存
57.         if (curFile) {
58.                 destroyFile(&curFile);
59.         }
61.         // 为新文件分配内存
62.         curFile = (File*)calloc(1, sizeof(File));
63.         initFile(curFile, path);
65.         // 读取新的文件
66.         char byte;
67.         char content[3] = {0};
68.         bool normal;
69.         while (fread(&byte, 1, 1, file) == 1) {
70.                 if (byte >= 0) {
71.                         // 这是普通字符
72.                         content[0] = byte;
73.                         if (byte == '\r') {
74.                                 char nextByte;
75.                                 fread(&nextByte, 1, 1, file);
76.                                 content[1] = nextByte;
77.                                 normal = false;
78.                         }
79.                         else {
80.                                 content[1] = '\0';
81.                                 normal = true;
82.                         }
83.                 }
84.                 else {
85.                         // 这是中文，其占2个字节
86.                         char nextByte;
87.                         fread(&nextByte, 1, 1, file);
88.                         content[0] = byte;
89.                         content[1] = nextByte;
90.                         normal = false;
91.                 }
93.                 // 添加当前普通字符或者中文字符到文件的文本中
94.                 insertNode(curFile->text->tail->prev, content, normal);
95.         }
96.         fclose(file);
98.         return true;
99. }
101. // 写入文件
102. void writeFile() {
103.         if (!curFile) return;
104.        
105.         // 把新内容写入文件
106.         FILE* fp = fopen(curFile->path, "w");
108.         Node* node = curFile->text->head->next;
109.         while (node != curFile->text->tail) {
110.                 fprintf(fp, "%s", node->content);
111.                 node = node->next;
112.         }
114.         fclose(fp);
115. }
117. // 新建文件
118. bool createFile(char* path) {
119.         // 保存当前文件
120.         writeFile();
122.         // 释放内存
123.         if (curFile) {
124.                 destroyFile(&curFile);
125.         }
127.         FILE* fp = fopen(path, "w");
128.         if (!fp) return false;
129.         fclose(fp);
131.         // 为新文件分配内存
132.         curFile = (File*)calloc(1, sizeof(File));
133.         initFile(curFile, path);
135.         return true;
136. }
138. // 保存文件
139. bool saveFile(char* path) {
140.         if (!curFile) return false;
142.         // 把内容写入新的文件
143.         FILE* fp = fopen(path, "w");
144.         if (!fp) return false;
146.         Node* node = curFile->text->head->next;
147.         while (node != curFile->text->tail) {
148.                 fprintf(fp, "%s", node->content);
149.                 node = node->next;
150.         }
152.         fclose(fp);
153.         return true;
154. }
156. // 获取当前文件
157. File* getCurrentFile() {
158.         return curFile;
159. }
161. // 释放相关内存
162. void freeResources() {
163.         if (curFile) {
164.                 destroyFile(&curFile);
165.         }
166. }
168. // 插入文字
169. void insertText(char* mContent) {
170.         if (!curFile || !mContent || strlen(mContent) == 0) return;
172.         // 添加字符串到当前指针后面
173.         appendString(&curFile->text->cursor, mContent, true);
174. }
176. // 删除当前字符
177. void deleteCharacter(bool isAfter) {
178.         if (curFile) {
179.                 if (isAfter) {
180.                         // 删除指针后面的字符
181.                         Node* node = curFile->text->cursor->next;
182.                         if (node != curFile->text->tail) {
183.                                 curFile->text->cursor->next = node->next;
184.                                 node->next->prev = curFile->text->cursor;
185.                                 free(node);
186.                         }
187.                 }
188.                 else {
189.                         // 删除指针指向的字符
190.                         Node* node = curFile->text->cursor;
191.                         if (node != curFile->text->head) {
192.                                 curFile->text->cursor = node->prev;
193.                                 curFile->text->cursor->next = node->next;
194.                                 node->next->prev = curFile->text->cursor;
195.                                 free(node);
196.                         }
197.                 }
198.         }
199. }
201. // 重置选中标志
202. void resetSelected() {
203.         if (!curFile) return;
204.         Node* node = curFile->text->head->next;
205.         while (node != curFile->text->tail) {
206.                 node->selected = false;
207.                 node = node->next;
208.         }
209. }
211. // 查找字符串
212. void findString(char* searchText) {
213.         if (!curFile) return;
215.         char content[3] = { 0 };
216.         char byte;
217.         size_t len = strlen(searchText);
218.         Node* curNode = curFile->text->head->next;
219.         while (curNode != curFile->text->tail) {
220.                 Node* tmpNode = curNode;
221.                 bool isFound = true;
222.                 // 查找子串
223.                 for (int i = 0; i < len && tmpNode != curFile->text->tail; i++) {
224.                         byte = searchText[i];
225.                         if (byte >= 0) {
226.                                 // 这是普通字符
227.                                 content[0] = byte;
228.                                 if (byte == '\r') {
229.                                         char nextByte = searchText[++i];
230.                                         content[1] = nextByte;
231.                                 }
232.                                 else {
233.                                         content[1] = '\0';
234.                                 }
235.                         }
236.                         else {
237.                                 // 这是中文，其占2个字节
238.                                 char nextByte = searchText[++i];
239.                                 content[0] = byte;
240.                                 content[1] = nextByte;
241.                         }
242.                         // 判断两个字符是否相同
243.                         if (strcmp(tmpNode->content, content) != 0) {
244.                                 isFound = false;
245.                                 break;
246.                         }
247.                         tmpNode = tmpNode->next;
248.                 }
249.                 if (isFound) {
250.                         // 设置对应的字符序列为选中
251.                         Node* node = curNode;
252.                         while (node != tmpNode) {
253.                                 node->selected = true;
254.                                 node = node->next;
255.                         }
256.                 }
257.                 curNode = curNode->next;
258.         }
259. }
261. // 在某个节点后添加字符串
262. void appendString(Node** beforeNode, char* mContent, bool modifyBeforeNode) {
263.         int i = 0;
264.         char byte;
265.         bool normal;
266.         char content[3] = { 0 };
267.         size_t len = strlen(mContent);
268.         Node* prev = *beforeNode;
269.         while (i < len) {
270.                 byte = mContent[i];
271.                 if (byte >= 0) {
272.                         // 这是普通字符
273.                         content[0] = byte;
274.                         if (byte == '\r') {
275.                                 char nextByte = mContent[++i];
276.                                 content[1] = nextByte;
277.                                 normal = false;
278.                         }
279.                         else {
280.                                 content[1] = '\0';
281.                                 normal = true;
282.                         }
283.                 }
284.                 else {
285.                         // 这是中文，其占2个字节
286.                         char nextByte = mContent[++i];
287.                         content[0] = byte;
288.                         content[1] = nextByte;
289.                         normal = false;
290.                 }
292.                 // 添加当前普通字符或者中文字符到该指针后面
293.                 insertNode(prev, content, normal);
294.                 prev = prev->next;
295.                 if (modifyBeforeNode) {
296.                         *beforeNode = prev;
297.                 }
299.                 i++;
300.         }
301. }
303. // 替换字符串
304. void replaceString(char* srcText, char* dstText) {
305.         if (!curFile) return;
307.         char content[3] = { 0 };
308.         char byte;
309.         size_t len = strlen(srcText);
310.         Node* curNode = curFile->text->head->next;
311.         while (curNode != curFile->text->tail) {
312.                 Node* tmpNode = curNode;
313.                 bool isFound = true;
314.                 // 查找子串
315.                 for (int i = 0; i < len && tmpNode != curFile->text->tail; i++) {
316.                         byte = srcText[i];
317.                         if (byte >= 0) {
318.                                 // 这是普通字符
319.                                 content[0] = byte;
320.                                 if (byte == '\r') {
321.                                         char nextByte = srcText[++i];
322.                                         content[1] = nextByte;
323.                                 }
324.                                 else {
325.                                         content[1] = '\0';
326.                                 }
327.                         }
328.                         else {
329.                                 // 这是中文，其占2个字节
330.                                 char nextByte = srcText[++i];
331.                                 content[0] = byte;
332.                                 content[1] = nextByte;
333.                         }
334.                         // 判断两个字符是否相同
335.                         if (strcmp(tmpNode->content, content) != 0) {
336.                                 isFound = false;
337.                                 break;
338.                         }
339.                         tmpNode = tmpNode->next;
340.                 }
341.                 if (isFound) {
342.                         // 首先删除原字符串
343.                         Node* beforeNode = curNode->prev;
344.                         while (beforeNode->next != tmpNode) {
345.                                 Node* node = beforeNode->next;
346.                                 beforeNode->next = node->next;
347.                                 node->next->prev = beforeNode;
348.                                 free(node);
349.                         }
350.                         curNode = tmpNode;
352.                         // 添加替换字符串
353.                         appendString(&beforeNode, dstText, false);
354.                 }
355.                 else {
356.                         curNode = curNode->next;
357.                 }
358.         }
359. }

复制代码

Editor.h:是 Editor.cpp 的头文件，声明了文本编辑器干系的函数接口，确保其他文件可以大概调用 Editor.cpp 中定义的函数。
声明了文本编辑器干系的函数，如：

• initTextEditor()：初始化编辑器。
  
• runTextEditor()：运行编辑器的主循环。
  
• destroyTextEditor()：烧毁编辑器。
  

1. #pragma once
2. /*
3. 该模块用于显示文本编辑器的界面和用户交互
4. */
6. // 初始化文本编辑器
7. void initTextEditor();
9. // 运行文本编辑器
10. void runTextEditor();
12. // 销毁文本编辑器
13. void destroyTextEditor();

复制代码

Editor.cpp：文本编辑器的核心，负责创建并表现图形界面，同时处置惩罚文件操作、文本编辑、用户输入变乱等。它利用 EasyX 图形库来绘制窗口和菜单，支持文件的读写操作、文本的插入与删除、文本的查找和更换。

• initTextEditor()：
  
  
  
  • 初始化文本编辑器，创建窗口并设置配景致。
    
  • 利用 initgraph() 函数来初始化窗口，setbkcolor() 设置配景致为白色，SetWindowText() 设置窗口的标题为 "文本编辑器"。
    
  • 还通过 readResources() 函数加载图像资源（如 editor.png），并设置图形界面的直线样式。
    
  
  
• runTextEditor()：
  
  
  
  • 启动文本编辑器的主循环。在这个循环中，步伐不绝更新窗口，扫除设备并重新绘制全部组件（如菜单和文当地域）。
    
  • 处置惩罚键盘变乱（如删除字符）和鼠标点击变乱（如选择菜单项）：
    
    
    
    • 键盘变乱：当按下删除键（VK_BACK）时，删除当前光标位置的字符。
      
    • 鼠标变乱：检测鼠标点击的地域，根据用户点击的菜单项执行不同操作，如读入文件、写入文件、新建文件等。
      
    
    
  
  
• drawWindow()：
  
  
  
  • 用于绘制编辑器窗口，包罗配景图像、菜单地域和文当地域。
    
  • 利用 putimage() 函数绘制配景图像，并调用 drawMenu() 和 drawText() 来绘制菜单和文当地域。
    
  
  
• drawMenu()：
  
  
  
  • 绘制顶部的菜单地域，包罗文件操作（如读入、写入、生存等）和文本编辑操作（如插入文本、查找、更换）。
    
  • 利用 outtextxy() 函数绘制菜单项文本，并用 roundrect() 绘制按钮。
    
  
  
• InsertText()：
  
  
  
  • 提示用户输入要插入的文字，并调用 insertText() 函数将文字插入到当前光标位置。
    
  
  
• FindString()：
  
  
  
  • 查找字符串。调用 findString() 函数查找指定的字符串并将找到的文本高亮表现。
    
  
  
• ReplaceString()：
  
  
  
  • 更换字符串。通过 replaceString() 函数，查找指定的原字符串并将其更换为新字符串。
    
  
  

1. #include "Editor.h"
2. #include <graphics.h>
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <string.h>
6. #include <stdbool.h>
7. #include <time.h>
8. #include <math.h>
9. #include "Text.h"
11. // 窗口大小
12. static int WINDOW_WIDTH = 1000;
13. static int WINDOW_HEIGHT = 700;
15. // 设置每帧的时间
16. static double FPS = 30;
17. static double PER_FRAME_TIME = 1000.0 / FPS;
19. // 查找字符串
20. static char searchText[256] = {0};
22. // 原字符串
23. static char sourceText[256] = { 0 };
25. // 替换字符串
26. static char replaceText[256] = { 0 };
28. // 设置菜单区域的位置
29. static int MENU_LEFT_TOP[] = { 10, 80 };
30. static int MENU_RIGHT_BOTTOM[] = { 900, 220 };
31. static int PADDING[] = {50, 16};
33. // 读入文件菜单位置
34. static int READ_FILE_MENU[] = { MENU_LEFT_TOP[0] + PADDING[0], MENU_LEFT_TOP[1] + PADDING[1],
35.                                                 MENU_LEFT_TOP[0] + PADDING[0] + 104, MENU_LEFT_TOP[1] + PADDING[1] + 25 };
36. // 写入文件菜单位置
37. static int WRITE_FILE_MENU[] = { READ_FILE_MENU[2] + PADDING[0], MENU_LEFT_TOP[1] + PADDING[1],
38.                                                 READ_FILE_MENU[2] + PADDING[0] + 104, MENU_LEFT_TOP[1] + PADDING[1] + 25 };
39. // 新建文件菜单位置
40. static int CREATE_FILE_MENU[] = { WRITE_FILE_MENU[2] + PADDING[0], MENU_LEFT_TOP[1] + PADDING[1],
41.                                                 WRITE_FILE_MENU[2] + PADDING[0] + 104, MENU_LEFT_TOP[1] + PADDING[1] + 25 };
42. // 保存文件菜单位置
43. static int SAVE_FILE_MENU[] = { CREATE_FILE_MENU[2] + PADDING[0], MENU_LEFT_TOP[1] + PADDING[1],
44.                                                 CREATE_FILE_MENU[2] + PADDING[0] + 104, MENU_LEFT_TOP[1] + PADDING[1] + 25 };
45. // 退出菜单位置
46. static int EXIT_MENU[] = { SAVE_FILE_MENU[2] + PADDING[0], MENU_LEFT_TOP[1] + PADDING[1],
47.                                                 SAVE_FILE_MENU[2] + PADDING[0] + 52, MENU_LEFT_TOP[1] + PADDING[1] + 25 };
48. // 编辑文件菜单位置
49. static int EDIT_FILE_MENU[] = { MENU_LEFT_TOP[0] + PADDING[0], READ_FILE_MENU[3] + PADDING[1],
50.                                                 MENU_LEFT_TOP[0] + PADDING[0] + 104, READ_FILE_MENU[3] + PADDING[1] + 25 };
51. // 插入菜单位置
52. static int INSERT_TEXT_MENU[] = { MENU_LEFT_TOP[0] + PADDING[0], EDIT_FILE_MENU[3] + PADDING[1],
53.                                                 MENU_LEFT_TOP[0] + PADDING[0] + 104, EDIT_FILE_MENU[3] + PADDING[1] + 25 };
54. // 查找文本位置
55. static int SEARCH_TEXT[] = { EDIT_FILE_MENU[2] + PADDING[0], READ_FILE_MENU[3] + PADDING[1],
56.                                                 EDIT_FILE_MENU[2] + PADDING[0] + 208, READ_FILE_MENU[3] + PADDING[1] + 25 };
57. // 查找菜单位置
58. static int FIND_MENU[] = { SEARCH_TEXT[2] + PADDING[0], READ_FILE_MENU[3] + PADDING[1],
59.                                                 SEARCH_TEXT[2] + PADDING[0] + 52, READ_FILE_MENU[3] + PADDING[1] + 25 };
60. // 清除高亮菜单位置
61. static int CLEAR_MENU[] = { FIND_MENU[2] + PADDING[0], READ_FILE_MENU[3] + PADDING[1],
62.                                                 FIND_MENU[2] + PADDING[0] + 104, READ_FILE_MENU[3] + PADDING[1] + 25 };
63. // 原文本位置
64. static int SOURCE_TEXT[] = { EDIT_FILE_MENU[2] + PADDING[0], FIND_MENU[3] + PADDING[1],
65.                                                 EDIT_FILE_MENU[2] + PADDING[0] + 208, FIND_MENU[3] + PADDING[1] + 25 };
66. // 替换文本位置
67. static int REPLACE_TEXT[] = { SOURCE_TEXT[2] + PADDING[0], FIND_MENU[3] + PADDING[1],
68.                                                 SOURCE_TEXT[2] + PADDING[0] + 208, FIND_MENU[3] + PADDING[1] + 25 };
69. // 替换菜单位置
70. static int REPLACE_MENU[] = { REPLACE_TEXT[2] + PADDING[0], FIND_MENU[3] + PADDING[1],
71.                                                 REPLACE_TEXT[2] + PADDING[0] + 52, FIND_MENU[3] + PADDING[1] + 25 };
72. // 文本区域位置
73. static int TEXT_AREA[] = { 10, MENU_RIGHT_BOTTOM[1] + PADDING[1],
74.                                                 WINDOW_WIDTH-20, WINDOW_HEIGHT - 20 };
76. // 图片资源
77. static IMAGE editorImage;
79. // 读取图片资源
80. static void readResources();
82. // 绘制窗口
83. static void drawWindow();
85. // 绘制菜单区域
86. static void drawMenu();
88. // 绘制文本区域
89. static void drawText();
91. // 读入文件
92. static void ReadFile();
94. // 写入文件
95. static void WriteFile();
97. // 新建文件
98. static void CreateNewFile();
100. // 保存文件
101. static void SaveFile();
103. // 插入文字
104. static void InsertText();
106. // 查找
107. static void FindString();
109. // 清除输入
110. static void ClearInput();
112. // 替换
113. static void ReplaceString();
115. // 更新文件指针位置
116. static void updateCursor(int x, int y);
118. // 初始化文本编辑器
119. void initTextEditor() {
120.         // 创建窗口
121.         initgraph(WINDOW_WIDTH, WINDOW_HEIGHT);
122.         setbkcolor(RGB(255, 255, 255));
124.         // 设置窗口名称
125.         HWND hWnd = GetHWnd();
126.         SetWindowText(hWnd, "文本编辑器");
128.         // 读取图片资源
129.         readResources();
131.         // 设置直线样式
132.         LINESTYLE style;
133.         style.thickness = 2;
134.         setlinestyle(&style);
135. }
137. // 运行文本编辑器
138. void runTextEditor() {
139.         bool exitCode = false;
140.         while (!exitCode) {
141.                 int startTime = clock();
143.                 // 双缓冲
144.                 BeginBatchDraw();
145.                 cleardevice();
147.                 // 绘制窗口
148.                 drawWindow();
150.                 EndBatchDraw();
152.                 // 处理消息
153.                 static ExMessage msg;
154.                 while (peekmessage(&msg, EM_KEY | EM_MOUSE)) {
155.                         // 键盘按下事件
156.                         if (msg.message == WM_KEYDOWN) {
157.                                 if (msg.vkcode == VK_BACK) {
158.                                         // 删除指针指向的字符
159.                                         deleteCharacter(false);
160.                                 }
161.                                 else if (msg.vkcode == VK_DELETE) {
162.                                         // 删除指针后面的字符
163.                                         deleteCharacter(true);
164.                                 }
165.                         }
166.                         // 鼠标左键按下事件
167.                         else if (msg.message == WM_LBUTTONDOWN) {
168.                                 int x = msg.x;
169.                                 int y = msg.y;
170.                                 // 点击了读入文件按钮
171.                                 if (x > READ_FILE_MENU[0] && x < READ_FILE_MENU[2] &&
172.                                         y > READ_FILE_MENU[1] && y < READ_FILE_MENU[3]) {
173.                                         ReadFile();
174.                                 }
175.                                 // 点击了写入文件按钮
176.                                 else if (x > WRITE_FILE_MENU[0] && x < WRITE_FILE_MENU[2] &&
177.                                         y > WRITE_FILE_MENU[1] && y < WRITE_FILE_MENU[3]) {
178.                                         WriteFile();
179.                                 }
180.                                 // 点击了创建文件按钮
181.                                 else if (x > CREATE_FILE_MENU[0] && x < CREATE_FILE_MENU[2] &&
182.                                         y > CREATE_FILE_MENU[1] && y < CREATE_FILE_MENU[3]) {
183.                                         CreateNewFile();
184.                                 }
185.                                 // 点击了保存文件按钮
186.                                 else if (x > SAVE_FILE_MENU[0] && x < SAVE_FILE_MENU[2] &&
187.                                         y > SAVE_FILE_MENU[1] && y < SAVE_FILE_MENU[3]) {
188.                                         SaveFile();
189.                                 }
190.                                 // 点击了退出按钮
191.                                 else if (x > EXIT_MENU[0] && x < EXIT_MENU[2] &&
192.                                         y > EXIT_MENU[1] && y < EXIT_MENU[3]) {
193.                                         // 释放相关内存
194.                                         freeResources();
195.                                         exitCode = true;
196.                                         break;
197.                                 }
198.                                 // 点击了插入文字按钮
199.                                 else if (x > INSERT_TEXT_MENU[0] && x < INSERT_TEXT_MENU[2] &&
200.                                         y > INSERT_TEXT_MENU[1] && y < INSERT_TEXT_MENU[3]) {
201.                                         InsertText();
202.                                 }
203.                                 // 点击了查找按钮
204.                                 else if (x > FIND_MENU[0] && x < FIND_MENU[2] &&
205.                                         y > FIND_MENU[1] && y < FIND_MENU[3]) {
206.                                         FindString();
207.                                 }
208.                                 // 点击了清楚高亮按钮
209.                                 else if (x > CLEAR_MENU[0] && x < CLEAR_MENU[2] &&
210.                                         y > CLEAR_MENU[1] && y < CLEAR_MENU[3]) {
211.                                         ClearInput();
212.                                 }
213.                                 // 点击了替换按钮
214.                                 else if (x > REPLACE_MENU[0] && x < REPLACE_MENU[2] &&
215.                                         y > REPLACE_MENU[1] && y < REPLACE_MENU[3]) {
216.                                         ReplaceString();
217.                                 }
218.                                 // 点击了文本区域
219.                                 else if (x > TEXT_AREA[0] && x < TEXT_AREA[2] &&
220.                                         y > TEXT_AREA[1] && y < TEXT_AREA[3]) {
221.                                         updateCursor(x, y);
222.                                 }
223.                                 // 输入查找字符串
224.                                 else if (x > SEARCH_TEXT[0] && x < SEARCH_TEXT[2] &&
225.                                         y > SEARCH_TEXT[1] && y < SEARCH_TEXT[3]) {
226.                                         InputBox(searchText, 255, "输入查找字符串:");
227.                                 }
228.                                 // 输入原字符串
229.                                 else if (x > SOURCE_TEXT[0] && x < SOURCE_TEXT[2] &&
230.                                         y > SOURCE_TEXT[1] && y < SOURCE_TEXT[3]) {
231.                                         InputBox(sourceText, 255, "输入原字符串:");
232.                                 }
233.                                 // 输入替换字符串
234.                                 else if (x > REPLACE_TEXT[0] && x < REPLACE_TEXT[2] &&
235.                                         y > REPLACE_TEXT[1] && y < REPLACE_TEXT[3]) {
236.                                         InputBox(replaceText, 255, "输入替换字符串:");
237.                                 }
238.                         }
239.                 }
241.                 // 控制每帧时间
242.                 int duration = clock() - startTime;
243.                 if (duration < PER_FRAME_TIME) {
244.                         Sleep(PER_FRAME_TIME - duration);
245.                 }
246.         }
247. }
249. // 销毁文本编辑器
250. void destroyTextEditor() {
251.         closegraph();
252. }
254. // 读取图片资源
255. static void readResources() {
256.         loadimage(&editorImage, "editor.png");
257. }
259. // 绘制窗口
260. static void drawWindow() {
261.         // 绘制编辑器图片
262.         putimage(0, 0, &editorImage);
264.         // 绘制菜单区域
265.         drawMenu();
267.         // 绘制文本区域
268.         drawText();
269. }
271. // 绘制菜单区域
272. static void drawMenu() {
273.         // 设置字体
274.         LOGFONT f;
275.         gettextstyle(&f);
276.         f.lfHeight = 25;
277.         _tcscpy(f.lfFaceName, _T("黑体"));
278.         f.lfQuality = ANTIALIASED_QUALITY;
279.         f.lfWeight = 800;
280.         settextstyle(&f);
281.         settextcolor(RGB(0, 0, 0));
283.         // 绘制文件编辑器的菜单
284.         setlinecolor(RGB(0, 0, 0));
285.         rectangle(MENU_LEFT_TOP[0], MENU_LEFT_TOP[1], MENU_RIGHT_BOTTOM[0], MENU_RIGHT_BOTTOM[1]);
287.         // 读入文件菜单
288.         outtextxy(READ_FILE_MENU[0], READ_FILE_MENU[1], "读入文件");
289.         roundrect(READ_FILE_MENU[0], READ_FILE_MENU[1], READ_FILE_MENU[2], READ_FILE_MENU[3], 5, 5);
291.         // 写入文件菜单
292.         outtextxy(WRITE_FILE_MENU[0], WRITE_FILE_MENU[1], "写入文件");
293.         roundrect(WRITE_FILE_MENU[0], WRITE_FILE_MENU[1], WRITE_FILE_MENU[2], WRITE_FILE_MENU[3], 5, 5);
295.         // 新建文件菜单
296.         outtextxy(CREATE_FILE_MENU[0], CREATE_FILE_MENU[1], "新建文件");
297.         roundrect(CREATE_FILE_MENU[0], CREATE_FILE_MENU[1], CREATE_FILE_MENU[2], CREATE_FILE_MENU[3], 5, 5);
299.         // 保存文件菜单
300.         outtextxy(SAVE_FILE_MENU[0], SAVE_FILE_MENU[1], "保存文件");
301.         roundrect(SAVE_FILE_MENU[0], SAVE_FILE_MENU[1], SAVE_FILE_MENU[2], SAVE_FILE_MENU[3], 5, 5);
303.         // 退出菜单
304.         outtextxy(EXIT_MENU[0], EXIT_MENU[1], "退出");
305.         roundrect(EXIT_MENU[0], EXIT_MENU[1], EXIT_MENU[2], EXIT_MENU[3], 5, 5);
307.         // 编辑文件菜单
308.         outtextxy(EDIT_FILE_MENU[0], EDIT_FILE_MENU[1], "编辑文件");
310.         // 插入菜单
311.         outtextxy(INSERT_TEXT_MENU[0], INSERT_TEXT_MENU[1], "插入文字");
312.         roundrect(INSERT_TEXT_MENU[0], INSERT_TEXT_MENU[1], INSERT_TEXT_MENU[2], INSERT_TEXT_MENU[3], 5, 5);
314.         // 查找菜单
315.         outtextxy(FIND_MENU[0], FIND_MENU[1], "查找");
316.         roundrect(FIND_MENU[0], FIND_MENU[1], FIND_MENU[2], FIND_MENU[3], 5, 5);
318.         // 清除输入菜单
319.         outtextxy(CLEAR_MENU[0], CLEAR_MENU[1], "清除输入");
320.         roundrect(CLEAR_MENU[0], CLEAR_MENU[1], CLEAR_MENU[2], CLEAR_MENU[3], 5, 5);
322.         // 替换菜单
323.         outtextxy(REPLACE_MENU[0], REPLACE_MENU[1], "替换");
324.         roundrect(REPLACE_MENU[0], REPLACE_MENU[1], REPLACE_MENU[2], REPLACE_MENU[3], 5, 5);
326.         // 设置字体
327.         gettextstyle(&f);
328.         f.lfHeight = 18;
329.         _tcscpy(f.lfFaceName, _T("宋体"));
330.         f.lfQuality = ANTIALIASED_QUALITY;
331.         f.lfWeight = 800;
332.         settextstyle(&f);
333.         settextcolor(RGB(0, 0, 0));
335.         // 查找文本
336.         if (strlen(searchText) > 0) {
337.                 outtextxy(SEARCH_TEXT[0], SEARCH_TEXT[1]+3, searchText);
338.         }
339.         roundrect(SEARCH_TEXT[0], SEARCH_TEXT[1], SEARCH_TEXT[2], SEARCH_TEXT[3], 5, 5);
341.         // 原文本
342.         if (strlen(sourceText) > 0) {
343.                 outtextxy(SOURCE_TEXT[0], SOURCE_TEXT[1] + 3, sourceText);
344.         }
345.         roundrect(SOURCE_TEXT[0], SOURCE_TEXT[1], SOURCE_TEXT[2], SOURCE_TEXT[3], 5, 5);
347.         // 替换文本
348.         if (strlen(replaceText) > 0) {
349.                 outtextxy(REPLACE_TEXT[0], REPLACE_TEXT[1] + 3, replaceText);
350.         }
351.         roundrect(REPLACE_TEXT[0], REPLACE_TEXT[1], REPLACE_TEXT[2], REPLACE_TEXT[3], 5, 5);
352. }
354. // 绘制文本区域
355. static void drawText() {
356.         // 设置字体
357.         LOGFONT f;
358.         gettextstyle(&f);
359.         f.lfHeight = 20;
360.         f.lfWeight = 600;
361.         _tcscpy(f.lfFaceName, _T("宋体"));
362.         f.lfQuality = ANTIALIASED_QUALITY;
363.         settextstyle(&f);
364.         settextcolor(RGB(0, 0, 0));
366.         // 显示文本区域框
367.         rectangle(TEXT_AREA[0], TEXT_AREA[1], TEXT_AREA[2], TEXT_AREA[3]);
369.         // 显示文件内容
370.         File* file = getCurrentFile();
371.         if (!file) return;
373.         int leftX = TEXT_AREA[0] + 5;
374.         int x = leftX;
375.         int y = TEXT_AREA[1] + 5;
376.         int w = textwidth("a");
377.         int h = f.lfHeight;
378.         Node* node = file->text->head->next;
380.         // 设置头指针的位置
381.         file->text->head->rect[0] = TEXT_AREA[0]+4;
382.         file->text->head->rect[1] = y;
383.         file->text->head->rect[2] = TEXT_AREA[0]+4;
384.         file->text->head->rect[3] = y;
386.         // 如果文件是空的，则在开头显示指针
387.         if (node == file->text->tail) {
388.                 line(node->prev->rect[2], node->prev->rect[1], node->prev->rect[2], node->prev->rect[1] + h);
389.                 return;
390.         }
392.         while (node != file->text->tail) {
393.                 // 设置字符所占的区域
394.                 node->rect[0] = x;
395.                 node->rect[1] = y;
396.                 node->rect[2] = x + (node->normal ? w : w*2);
397.                 node->rect[3] = y + h;
399.                 // 判断是否需要换行
400.                 if (strcmp(node->content, "\r\n") == 0 || strcmp(node->content, "\n") == 0
401.                         || node->rect[2] >= TEXT_AREA[2]) {
402.                         // 需要换行，更新位置
403.                         x = leftX;
404.                         y += f.lfHeight;
405.                         node->rect[0] = x;
406.                         node->rect[1] = y;
407.                         node->rect[2] = x + (node->normal ? w : w * 2);
408.                         node->rect[3] = y + h;
409.                 }
411.                 if (strcmp(node->content, "\r\n") != 0 && strcmp(node->content, "\n") != 0) {
412.                         // 如果字符被选中，则更改颜色
413.                         if (node->selected) {
414.                                 setcolor(RED);
415.                         }
416.                         else {
417.                                 setcolor(BLACK);
418.                         }
419.                         // 显示该字符
420.                         outtextxy(node->rect[0], node->rect[1], node->content);
421.                         // 更新x值
422.                         x = node->rect[2];
423.                 }
425.                 // 绘制当前位置指针
426.                 if (file->text->cursor == node->prev) {
427.                         line(node->prev->rect[2], node->prev->rect[1], node->prev->rect[2], node->prev->rect[1] + h);
428.                 }
429.                 else if (file->text->cursor == node && node->next == file->text->tail) {
430.                         line(node->rect[2], node->rect[1], node->rect[2], node->rect[1] + h);
431.                 }
433.                 node = node->next;
434.         }
435. }
437. // 更新文件指针位置
438. static void updateCursor(int x, int y) {
439.         File* file = getCurrentFile();
440.         if (!file) return;
442.         // 设置文件指针到最靠近鼠标的文字的位置（距离不能超过26）
443.         int minDistance = INT_MAX;
444.         Node* node = file->text->head->next;
445.         while (node != file->text->tail) {
446.                 if (x > node->rect[0] && x < node->rect[2] &&
447.                         y > node->rect[1] && y < node->rect[3]) {
448.                         file->text->cursor = node;
449.                         break;
450.                 }
451.                 else {
452.                         // 判断该文字是否更加靠近鼠标点击的位置
453.                         int dx = (node->rect[0] + node->rect[2]) / 2 - x;
454.                         int dy = (node->rect[1] + node->rect[3]) / 2 - y;
455.                         double dist = sqrt(dx * dx + dy * dy);
456.                         if (dist < 26 && dist < minDistance) {
457.                                 minDistance = dist;
458.                                 file->text->cursor = node;
459.                         }
460.                 }
461.                 node = node->next;
462.         }
463. }
465. // 读入文件
466. static void ReadFile() {
467.         // 提示用户输入文件路径
468.         char path[256];
469.         InputBox(path, 255, "输入文件路径:");
471.         // 读入文件内容
472.         if (!readFile(path)) {
473.                 MessageBox(GetHWnd(), "该文件不存在", "提示", MB_OK);
474.         }
475. }
477. // 写入文件
478. static void WriteFile() {
479.         if (getCurrentFile()) {
480.                 writeFile();
481.                 MessageBox(GetHWnd(), "内容已被写入文件", "提示", MB_OK);
482.         }
483. }
485. // 新建文件
486. static void CreateNewFile() {
487.         // 提示用户输入文件路径
488.         char path[256];
489.         InputBox(path, 255, "输入文件路径:");
491.         // 创建新的文件
492.         if (!createFile(path)) {
493.                 MessageBox(GetHWnd(), "创建文件失败", "提示", MB_OK);
494.         }
495. }
497. // 保存文件
498. static void SaveFile() {
499.         // 提示用户输入文件路径
500.         char path[256];
501.         InputBox(path, 255, "输入文件路径:");
503.         if (!saveFile(path)) {
504.                 MessageBox(GetHWnd(), "保存文件失败", "提示", MB_OK);
505.         }
506.         else {
507.                 MessageBox(GetHWnd(), "文件已被保存", "提示", MB_OK);
508.         }
509. }
511. // 插入文字
512. static void InsertText() {
513.         // 提示输入要插入的文字
514.         char content[256];
515.         InputBox(content, 255, "输入要插入的文字:");
517.         // 把该文字插入指针所在位置
518.         insertText(content);
519. }
521. // 查找
522. static void FindString() {
523.         resetSelected();
524.         if (strlen(searchText) > 0) {
525.                 findString(searchText);
526.         }
527. }
529. // 清除输入
530. static void ClearInput() {
531.         memset(searchText, 0, sizeof(searchText));
532.         memset(sourceText, 0, sizeof(sourceText));
533.         memset(replaceText, 0, sizeof(replaceText));
535.         // 重置选中标志
536.         resetSelected();
537. }
539. // 替换
540. static void ReplaceString() {
541.         if (strlen(sourceText) > 0 && strlen(replaceText) > 0) {
542.                 replaceString(sourceText, replaceText);
543.         }
544. }

复制代码

Main.cpp：步伐的入口文件，紧张用于启动文本编辑器的初始化、运行和烧毁。
main()：

• 步伐启动时起首调用 initTextEditor() 函数初始化文本编辑器。
  
• 接着调用 runTextEditor() 启动文本编辑器的主循环，答应用户进行各种操作（如文件操作、文本编辑等）。
  
• 末了通过 destroyTextEditor() 烧毁编辑器，释放资源。
  

1. #include "Editor.h"
3. int main() {
4.         // 初始化文本编辑器
5.         initTextEditor();
7.         // 运行文本编辑器
8.         runTextEditor();
10.         // 销毁文本编辑器
11.         destroyTextEditor();
12.         return 0;
13. }

复制代码