feat: add a new awesome feature

CHANGELOG.en.md

@@ -7,9 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [中文文档](CHANGELOG.md)
 
+## [v2.3.2] - 2025 - 12 - 20
+
+### ✨ Added
+
+- **Table: runtime reset for headers and data:** added `Table::clearHeaders()`, `Table::clearData()`, and `Table::resetTable()`. This allows a single `Table` instance to dynamically update its headers/data at runtime, and triggers the required recalculation (cell sizing / pagination info) and redraw.
+- **TextBox: password mode:** added `PASSWORD_MODE` to `TextBoxmode`. User input is stored internally, while the render layer displays masked characters (e.g., `*`). The real text can be retrieved via `TextBox::getText()`.
+
+### ⚙️ Changed
+
+- **TabControl: clarified default active page semantics:**
+  - Calling `TabControl::setActiveIndex()` **before the first draw** now only records the default active index; it no longer immediately triggers the tab button click callback.
+  - **After the first draw completes**, if a default active index was set, the active state is applied and the active page is drawn (if the index is out of range, the last page is activated by default).
+  - Calling `TabControl::setActiveIndex()` **during runtime (non-first draw)** switches the active page immediately when the index is valid; out-of-range indices are ignored.
+
+### ✅ Fixed
+
+- **TabControl::setActiveIndex crash when called before drawing:** fixed a null-pointer access caused by triggering the tab button click callback before initialization. The default activation is now applied after the first draw completes, preventing crashes and ensuring the active page is rendered on first draw.
+- **TabControl rendering glitches when toggling visibility (hidden -> visible):** fixed multi-page overlap/ghosting caused by non-active pages being incorrectly drawn after `setIsVisible(false) -> setIsVisible(true)`. Now, when TabControl is visible, only the active page is visible/drawable; if there is no active page, nothing is drawn.
+
 ## [v2.3.1] - 2025-11-30
 
-## 🙏 Acknowledgements
+### 🙏 Acknowledgements
 
 - Special thanks to user [@To-KongBai](https://github.com/To-KongBai) for providing stable reproduction steps and key phenomenon comparisons (container nested child control coordinate transformation issue), which helped us quickly identify and fix the control coordinate transformation problem in deeply nested containers. ([Issues#6](https://github.com/Ysm-04/StellarX/issues/6))
 - In the upcoming website (currently undergoing ICP filing), we plan to add a contributors' wall to acknowledge users. We welcome everyone to report bugs or share interfaces created with StellarX, and we will carefully read and include acknowledgements.

CHANGELOG.md

@@ -7,9 +7,28 @@ StellarX 项目所有显著的变化都将被记录在这个文件中。
 
 [English document](CHANGELOG.en.md)
 
+## [v2.3.2] - 2025 - 12 - 20
+
+### ✨ 新增
+
+- **Table 支持运行期重置表头与数据：**新增 `Table::clearHeaders()`、`Table::clearData()`、`Table::resetTable()`，允许同一 `Table` 在运行过程中动态切换表头与数据，并触发必要的单元格尺寸/分页信息重算与重绘。
+- **TextBox 新增密码模式：**`TextBoxmode` 新增 `PASSWORD_MODE`；输入内容内部保存，绘制层面使用掩码字符（如 `*`）替代显示，真实文本可通过 `TextBox::getText()` 获取。
+
+### ⚙️ 变更
+
+- **TabControl 默认激活页语义明确化：**
+  - 首次绘制前调用 `TabControl::setActiveIndex()`：仅记录默认激活索引，不再立即触发页签按钮点击回调；
+  - 首次绘制完成后：若设置了默认激活索引则应用激活状态并绘制激活页（索引越界时默认激活最后一个页）；
+  - 程序运行过程中调用 `TabControl::setActiveIndex()`：索引合法则立即切换激活页并绘制；索引越界则不做处理。
+
+### ✅ 修复
+
+- **TabControl::setActiveIndex 绘制前调用导致程序中断：**修复绘制前设置默认激活索引时触发空指针访问的问题；现在默认激活逻辑延后到首次绘制完成后再生效，避免崩溃并保证首次绘制即可绘制激活页。
+- **TabControl 由不可见设置为可见时绘制错乱：**修复 `setIsVisible(false) -> setIsVisible(true)` 后非激活页被错误绘制导致的多页重叠/残影；现在 TabControl 可见时仅激活页可见/可绘制，无激活页则不绘制任何页。
+
 ## [v2.3.1] - 2025 - 11 - 30
 
-## 🙏 鸣谢
+### 🙏 鸣谢
 
 - 感谢用户 [@To-KongBai](https://github.com/To-KongBai) 提供稳定复现步骤与关键现象对比（容器嵌套孙控件坐标转换问题），帮助我们快速确认多容器嵌套时的控件坐标转换问题并修复。（[Issues#6](https://github.com/Ysm-04/StellarX/issues/6)）
 - 在即将上线的官网中（ICP备案中）我们计划加入一个贡献者鸣谢墙，欢迎各位用户反馈BUG或者分享自己用星垣做的界面，我们将认真阅读并收录鸣谢

README.en.md

@@ -7,8 +7,8 @@
 ![GitHub all releases](https://img.shields.io/github/downloads/Ysm-04/StellarX/total)
  [![Star GitHub Repo](https://img.shields.io/github/stars/Ysm-04/StellarX.svg?style=social&label=Star%20This%20Repo)](https://github.com/Ysm-04/StellarX)
 
-![Version](https://img.shields.io/badge/Version-2.3.0-brightgreen.svg)
- ![Download](https://img.shields.io/badge/Download-2.3.0_Release-blue.svg)
+![Version](https://img.shields.io/badge/Version-2.3.2-brightgreen.svg)
+ ![Download](https://img.shields.io/badge/Download-2.3.2_Release-blue.svg)
 
 ![C++](https://img.shields.io/badge/C++-17+-00599C?logo=cplusplus&logoColor=white)
  ![Windows](https://img.shields.io/badge/Platform-Windows-0078D6?logo=windows)
@@ -25,30 +25,6 @@ This is a **teaching-grade and tooling-grade** framework that helps developers u
 
 ------
 
-## 🆕 V2.3.0 - Major Update
-
-**This version represents a significant milestone, introducing a responsive layout system that transitions from static to dynamic layout management, and comprehensively resolves the previously encountered random rendering corruption issues caused by reentrant drawing operations.**
-
-- **Optimized Window Resizing Mechanism**: Refactored `WndProcThunk`, `runEventLoop`, and `pumpResizeIfNeeded` to uniformly record size changes and perform centralized repainting at the end of the event loop, eliminating jitter and sequencing confusion caused by repeated redraws.
-
-- **New Dialog Size Scheduling Interface**: Introduced the combination of `Window::scheduleResizeFromModal()` and `pumpResizeIfNeeded()`, enabling modal dialogs to notify the parent window of size updates even during resizing operations. Underlying controls are relayout during unified finalization while dialogs maintain their original dimensions.
-
-- **Enhanced Adaptive Layout System**: Internally added the `adaptiveLayout()` function to recalculate control positions and sizes based on anchor points, allowing dual-anchored controls (left-right or top-bottom) to adaptively stretch with window resizing.
-
-- **Fixed Modal Dialog Resizing Issues**: Resolved the problem where window resizing while modal dialogs were open prevented underlying controls from updating their positions and sizes according to anchor points; simultaneously eliminated ghosting artifacts caused by repeated dialog redraws.
-
-- **Further Resolved Drawing Sequence Confusion**: Replaced `InvalidateRect` with `ValidateRect` during resizing operations, ensuring the window is marked as valid only after a single unified drawing pass, preventing system-triggered `WM_PAINT` messages from causing reentrancy.
-
-- **Additional Fixes**: Corrected delayed background snapshot updates in tables and dialogs under certain edge cases.
-
-![](image/1.png)
-
-![](image/2.png)
-
-For details, please refer to the [CHANGELOG.en](CHANGELOG.en.md).
-
-------
-
 ## 📦 Project Structure & Design Philosophy
 
 StellarX adopts classic **OOP** and **modular** design with a clear structure:

README.md

@@ -2,6 +2,8 @@
 
 [English document](README.en.md)
 
+官网地址：https://stellarx-gui.top
+
 > 本仓库为 **StellarX** 主仓：开发与 Issue/PR 均在 GitHub 进行。  
 > GitCode 仅为只读镜像：如需反馈请到 GitHub:https://github.com/Ysm-04/StellarX
 
@@ -12,8 +14,8 @@
 ![GitHub all releases](https://img.shields.io/github/downloads/Ysm-04/StellarX/total)
 [![Star GitHub Repo](https://img.shields.io/github/stars/Ysm-04/StellarX.svg?style=social&label=Star%20This%20Repo)](https://github.com/Ysm-04/StellarX)
 
-![Version](https://img.shields.io/badge/Version-2.3.1-brightgreen.svg)
-![Download](https://img.shields.io/badge/Download-2.3.1_Release-blue.svg)
+![Version](https://img.shields.io/badge/Version-2.3.2-brightgreen.svg)
+![Download](https://img.shields.io/badge/Download-2.3.2_Release-blue.svg)
 
 ![C++](https://img.shields.io/badge/C++-17+-00599C?logo=cplusplus&logoColor=white)
 ![Windows](https://img.shields.io/badge/Platform-Windows-0078D6?logo=windows)
@@ -30,30 +32,26 @@
 
 ---
 
-## ==公告==
 
-## 🙏 鸣谢
 
-- 感谢用户 [@To-KongBai](https://github.com/To-KongBai) 提供稳定复现步骤与关键现象对比（容器嵌套孙控件坐标转换问题），帮助我们快速确认多容器嵌套时的控件坐标转换问题并修复。（[Issues#6](https://github.com/Ysm-04/StellarX/issues/6)）
-- 在即将上线的官网中（ICP备案中）我们计划加入一个贡献者鸣谢墙，欢迎各位用户反馈BUG或者分享自己用星垣做的界面，我们将认真阅读并收录鸣谢
-- 真诚的感谢每一位反馈BUG的用户，你们的反馈将使星垣更加稳定和健壮
+## 🆕V2.3.2——重要更新
 
----
+### 新增
 
-## 🆕V2.3.1——重要更新
-
-### ✨ 新增
-
-新增一个登录界面Demo在主仓库**examples/**目录下
+- **Table 支持运行期重置表头与数据：**新增 `Table::clearHeaders()`、`Table::clearData()`、`Table::resetTable()`，允许同一 `Table` 在运行过程中动态切换表头与数据，并触发必要的单元格尺寸/分页信息重算与重绘。
+- **TextBox 新增密码模式：**`TextBoxmode` 新增 `PASSWORD_MODE`；输入内容内部保存，绘制层面使用掩码字符（如 `*`）替代显示，真实文本可通过 `TextBox::getText()` 获取。
 
 ### ⚙️ 变更
 
-- **Dialog背景快照机制：**`Dialog`不在自己抓取和销毁快照，**删除**重载的抓取和恢复快照的方法，完全交由基类`Canvas`处理，`Dialog`的`draw`方法中不在处理快照
-- **窗口变化重绘时控件和窗口重绘的时机调整：**主事件循环中窗口大小发生变化时先处理控件尺寸，并回贴和释放旧快照，然后再重绘新尺寸窗口，最后绘制控件
+- **TabControl 默认激活页语义明确化：**
+  - 首次绘制前调用 `TabControl::setActiveIndex()`：仅记录默认激活索引，不再立即触发页签按钮点击回调；
+  - 首次绘制完成后：若设置了默认激活索引则应用激活状态并绘制激活页（索引越界时默认激活最后一个页）；
+  - 程序运行过程中调用 `TabControl::setActiveIndex()`：索引合法则立即切换激活页并绘制；索引越界则不做处理。
 
-本次针对用户反馈和已知内容进行了一些修复……
+### ✅ 修复
 
-详细变更请参阅[更新日志](CHANGELOG.md)
+- **TabControl::setActiveIndex 绘制前调用导致程序中断：**修复绘制前设置默认激活索引时触发空指针访问的问题；现在默认激活逻辑延后到首次绘制完成后再生效，避免崩溃并保证首次绘制即可绘制激活页。
+- **TabControl 由不可见设置为可见时绘制错乱：**修复 `setIsVisible(false) -> setIsVisible(true)` 后非激活页被错误绘制导致的多页重叠/残影；现在 TabControl 可见时仅激活页可见/可绘制，无激活页则不绘制任何页。
 
 ---
 

examples/demo.cpp

@@ -24,7 +24,7 @@ int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _
 	// 3. 为按钮设置点击事件（使用Lambda表达式）
 	myButton->setOnClickListener([&mainWindow]() {
 		// 使用消息框工厂创建模态对话框
-		auto result = StellarX::MessageBox::ShowModal(
+		auto result = StellarX::MessageBox::showModal(
 			mainWindow,
 			"欢迎使用星垣GUI\r\n作者：我在人间做废物",
 			"问候",

include/StellarX/Button.h

@@ -21,177 +21,170 @@
 #include "Control.h"
 #include"label.h"
 
-
 #define DISABLEDCOLOUR RGB(96, 96, 96) //禁用状态颜色
 #define TEXTMARGINS_X 6
 #define TEXTMARGINS_Y 4
 constexpr int bordWith = 1; //边框宽度，用于快照恢复时的偏移计算
 constexpr int bordHeight = 1; //边框高度，用于快照恢复时的偏移计算
 
-
 class Button : public Control
 {
+	std::string text;             // 按钮上的文字
+	bool        click;            // 是否被点击
+	bool        hover;            // 是否被悬停
 
-    std::string text;             // 按钮上的文字
-    bool        click;            // 是否被点击
-    bool        hover;            // 是否被悬停
+	std::string cutText;       // 切割后的文本
+	bool needCutText = true;   // 是否需要切割文本
+	bool isUseCutText = false; // 是否使用切割文本
+	int  padX = TEXTMARGINS_X; // 文本最小左右内边距
+	int  padY = TEXTMARGINS_Y; // 文本最小上下内边距
 
-    std::string cutText;       // 切割后的文本
-    bool needCutText = true;   // 是否需要切割文本
-    bool isUseCutText = false; // 是否使用切割文本
-    int  padX = TEXTMARGINS_X; // 文本最小左右内边距
-    int  padY = TEXTMARGINS_Y; // 文本最小上下内边距
+	COLORREF         buttonTrueColor;                    // 按钮被点击后的颜色
+	COLORREF         buttonFalseColor;                   // 按钮未被点击的颜色
+	COLORREF         buttonHoverColor;                   // 按钮被鼠标悬停的颜色
+	COLORREF         buttonBorderColor = RGB(0, 0, 0);// 按钮边框颜色
 
-    COLORREF         buttonTrueColor;                    // 按钮被点击后的颜色
-    COLORREF         buttonFalseColor;                   // 按钮未被点击的颜色
-    COLORREF         buttonHoverColor;                   // 按钮被鼠标悬停的颜色
-    COLORREF         buttonBorderColor = RGB(0,0,0);// 按钮边框颜色
+	StellarX::ButtonMode  mode;	    // 按钮模式
+	StellarX::ControlShape shape;     // 按钮形状
 
-    StellarX::ButtonMode  mode;	    // 按钮模式
-    StellarX::ControlShape shape;     // 按钮形状
+	StellarX::FillMode    buttonFillMode = StellarX::FillMode::Solid;   //按钮填充模式
+	StellarX::FillStyle   buttonFillIma = StellarX::FillStyle::BDiagonal;        //按钮填充图案
+	IMAGE* buttonFileIMAGE = nullptr;      //按钮填充图像
 
-    StellarX::FillMode    buttonFillMode = StellarX::FillMode::Solid;   //按钮填充模式
-    StellarX::FillStyle   buttonFillIma  = StellarX::FillStyle::BDiagonal;        //按钮填充图案
-    IMAGE*      buttonFileIMAGE = nullptr;      //按钮填充图像
+	std::function<void()> onClickCallback;      //回调函数
+	std::function<void()> onToggleOnCallback;   //TOGGLE模式下的回调函数
+	std::function<void()> onToggleOffCallback;  //TOGGLE模式下的回调函数
 
+	StellarX::ControlText oldStyle = textStyle;   // 按钮文字样式
+	int oldtext_width = -1;
+	int oldtext_height = -1;
+	int text_width = 0;
+	int text_height = 0;
 
+	// === Tooltip ===
+	bool        tipEnabled = false;           // 是否启用
+	bool        tipVisible = false;          // 当前是否显示
+	bool        tipFollowCursor = false;      // 是否跟随鼠标
+	bool        tipUserOverride = false;     // 是否用户自定义了tip文本
+	int         tipDelayMs = 1000;            // 延时(毫秒)
+	int         tipOffsetX = 12;             // 相对鼠标偏移
+	int         tipOffsetY = 18;
+	ULONGLONG   tipHoverTick = 0;            // 开始悬停的时间戳
+	int         lastMouseX = 0;              // 最新鼠标位置(用于定位)
+	int         lastMouseY = 0;
 
-    std::function<void()> onClickCallback;      //回调函数
-    std::function<void()> onToggleOnCallback;   //TOGGLE模式下的回调函数
-    std::function<void()> onToggleOffCallback;  //TOGGLE模式下的回调函数
-
-    StellarX::ControlText oldStyle = textStyle;   // 按钮文字样式
-    int oldtext_width = -1;
-    int oldtext_height = -1;
-    int text_width = 0;
-    int text_height = 0;
-
-    // === Tooltip ===
-    bool        tipEnabled = false;           // 是否启用
-    bool        tipVisible = false;          // 当前是否显示
-    bool        tipFollowCursor = false;      // 是否跟随鼠标
-    bool        tipUserOverride = false;     // 是否用户自定义了tip文本
-    int         tipDelayMs = 1000;            // 延时(毫秒)
-    int         tipOffsetX = 12;             // 相对鼠标偏移
-    int         tipOffsetY = 18;
-    ULONGLONG   tipHoverTick = 0;            // 开始悬停的时间戳
-    int         lastMouseX = 0;              // 最新鼠标位置(用于定位)
-    int         lastMouseY = 0;
-
-    std::string tipTextClick;  //NORMAL 模式下用
-    std::string tipTextOn;    // click==true 时用
-    std::string tipTextOff;   // click==false 时用
-    Label       tipLabel;                    // 直接复用Label作为提示
+	std::string tipTextClick;  //NORMAL 模式下用
+	std::string tipTextOn;    // click==true 时用
+	std::string tipTextOff;   // click==false 时用
+	Label       tipLabel;                    // 直接复用Label作为提示
 
 public:
-    StellarX::ControlText textStyle;  // 按钮文字样式
+	StellarX::ControlText textStyle;  // 按钮文字样式
 
 public:
 
-    //默认按钮颜色
-    Button(int x, int y, int width, int height, const std::string text,
-        StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
-    //自定义按钮未被点击和被点击颜色
-    Button(int x, int y, int width, int height, const std::string text,
-           COLORREF ct, COLORREF cf, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL,
-        StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
-    //自定义按钮颜色和悬停颜色
-    Button(int x, int y, int width, int height, const std::string text,
-             COLORREF ct, COLORREF cf,COLORREF ch,
-        StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
-    //析构函数 释放图形指针内存
-    ~Button();
+	//默认按钮颜色
+	Button(int x, int y, int width, int height, const std::string text,
+		StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
+	//自定义按钮未被点击和被点击颜色
+	Button(int x, int y, int width, int height, const std::string text,
+		COLORREF ct, COLORREF cf, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL,
+		StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
+	//自定义按钮颜色和悬停颜色
+	Button(int x, int y, int width, int height, const std::string text,
+		COLORREF ct, COLORREF cf, COLORREF ch,
+		StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
+	//析构函数 释放图形指针内存
+	~Button();
 
-    //绘制按钮
-    void draw() override;
-    //按钮事件处理
-    bool handleEvent(const ExMessage& msg) override;
+	//绘制按钮
+	void draw() override;
+	//按钮事件处理
+	bool handleEvent(const ExMessage& msg) override;
 
-    //设置回调函数
-    void setOnClickListener(const std::function<void()>&& callback);
-    //设置TOGGLE模式下被点击的回调函数
-    void setOnToggleOnListener(const std::function<void()>&& callback);
-    //设置TOGGLE模式下取消点击的回调函数
-    void setOnToggleOffListener(const std::function<void()>&& callback);
-    //设置按钮模式
-    void setbuttonMode(StellarX::ButtonMode mode);
-    //设置圆角矩形椭圆宽度
-    void setROUND_RECTANGLEwidth(int width);
-    //设置圆角矩形椭圆高度
-    void setROUND_RECTANGLEheight(int height);
-    //设置按钮填充模式
-    void setFillMode(StellarX::FillMode mode);
-    //设置按钮填充图案
-    void setFillIma(StellarX::FillStyle ima);
-    //设置按钮填充图像
-    void setFillIma(std::string imaName);
-    //设置按钮边框颜色
-    void setButtonBorder(COLORREF Border);
-    //设置按钮未被点击颜色
-    void setButtonFalseColor(COLORREF color);
-    //设置按钮文本
-    void setButtonText(const char* text);
-    void setButtonText(std::string text);
-    //设置按钮形状
-    void setButtonShape(StellarX::ControlShape shape);
-    //设置按钮点击状态
-    void setButtonClick(BOOL click);
+	//设置回调函数
+	void setOnClickListener(const std::function<void()>&& callback);
+	//设置TOGGLE模式下被点击的回调函数
+	void setOnToggleOnListener(const std::function<void()>&& callback);
+	//设置TOGGLE模式下取消点击的回调函数
+	void setOnToggleOffListener(const std::function<void()>&& callback);
+	//设置按钮模式
+	void setbuttonMode(StellarX::ButtonMode mode);
+	//设置圆角矩形椭圆宽度
+	void setROUND_RECTANGLEwidth(int width);
+	//设置圆角矩形椭圆高度
+	void setROUND_RECTANGLEheight(int height);
+	//设置按钮填充模式
+	void setFillMode(StellarX::FillMode mode);
+	//设置按钮填充图案
+	void setFillIma(StellarX::FillStyle ima);
+	//设置按钮填充图像
+	void setFillIma(std::string imaName);
+	//设置按钮边框颜色
+	void setButtonBorder(COLORREF Border);
+	//设置按钮未被点击颜色
+	void setButtonFalseColor(COLORREF color);
+	//设置按钮文本
+	void setButtonText(const char* text);
+	void setButtonText(std::string text);
+	//设置按钮形状
+	void setButtonShape(StellarX::ControlShape shape);
+	//设置按钮点击状态
+	void setButtonClick(BOOL click);
 
-    //判断按钮是否被点击
-    bool isClicked() const;
+	//判断按钮是否被点击
+	bool isClicked() const;
 
-    //获取按钮文字
-    std::string getButtonText() const;
-    const char* getButtonText_c() const;
-    //获取按钮模式
-    StellarX::ButtonMode getButtonMode() const;
-    //获取按钮形状
-    StellarX::ControlShape getButtonShape() const;
-    //获取按钮填充模式
-    StellarX::FillMode getFillMode() const;
+	//获取按钮文字
+	std::string getButtonText() const;
+	const char* getButtonText_c() const;
+	//获取按钮模式
+	StellarX::ButtonMode getButtonMode() const;
+	//获取按钮形状
+	StellarX::ControlShape getButtonShape() const;
+	//获取按钮填充模式
+	StellarX::FillMode getFillMode() const;
 	//获取按钮填充图案
-    StellarX::FillStyle getFillIma() const;
+	StellarX::FillStyle getFillIma() const;
 	//获取按钮填充图像
 	IMAGE* getFillImaImage() const;
 	//获取按钮边框颜色
-    COLORREF getButtonBorder() const;
+	COLORREF getButtonBorder() const;
 	//获取按钮文字颜色
-    COLORREF getButtonTextColor() const;
+	COLORREF getButtonTextColor() const;
 	//获取按钮文字样式
-    StellarX::ControlText getButtonTextStyle() const;
-    //获取按钮宽度
-    int getButtonWidth() const;
-    //获取按钮高度
-    int getButtonHeight() const;
+	StellarX::ControlText getButtonTextStyle() const;
+	//获取按钮宽度
+	int getButtonWidth() const;
+	//获取按钮高度
+	int getButtonHeight() const;
 public:
-    // === Tooltip API===
-    //设置是否启用提示框
-    void enableTooltip(bool on) { tipEnabled = on; if (!on) tipVisible = false; }
-    //设置提示框延时
-    void setTooltipDelay(int ms) { tipDelayMs = (ms < 0 ? 0 : ms); }
-    //设置提示框是否跟随鼠标
-    void setTooltipFollowCursor(bool on) { tipFollowCursor = on; }
-    //设置提示框位置偏移
-    void setTooltipOffset(int dx, int dy) { tipOffsetX = dx; tipOffsetY = dy; }
-    //设置提示框样式
-    void setTooltipStyle(COLORREF text, COLORREF bk, bool transparent);
-    //设置提示框文本
-    void setTooltipText(const std::string& s){ tipTextClick = s; tipUserOverride = true; }
-    void setTooltipTextsForToggle(const std::string& onText, const std::string& offText);
+	// === Tooltip API===
+	//设置是否启用提示框
+	void enableTooltip(bool on) { tipEnabled = on; if (!on) tipVisible = false; }
+	//设置提示框延时
+	void setTooltipDelay(int ms) { tipDelayMs = (ms < 0 ? 0 : ms); }
+	//设置提示框是否跟随鼠标
+	void setTooltipFollowCursor(bool on) { tipFollowCursor = on; }
+	//设置提示框位置偏移
+	void setTooltipOffset(int dx, int dy) { tipOffsetX = dx; tipOffsetY = dy; }
+	//设置提示框样式
+	void setTooltipStyle(COLORREF text, COLORREF bk, bool transparent);
+	//设置提示框文本
+	void setTooltipText(const std::string& s) { tipTextClick = s; tipUserOverride = true; }
+	void setTooltipTextsForToggle(const std::string& onText, const std::string& offText);
 private:
-    //初始化按钮
-    void initButton(const std::string text, StellarX::ButtonMode mode, StellarX::ControlShape shape, COLORREF ct, COLORREF cf, COLORREF ch);
-    //判断鼠标是否在圆形按钮内
-    bool isMouseInCircle(int mouseX, int mouseY, int x, int y, int radius);
-    //判断鼠标是否在椭圆按钮内
-    bool isMouseInEllipse(int mouseX, int mouseY, int x, int y, int width, int height);
+	//初始化按钮
+	void initButton(const std::string text, StellarX::ButtonMode mode, StellarX::ControlShape shape, COLORREF ct, COLORREF cf, COLORREF ch);
+	//判断鼠标是否在圆形按钮内
+	bool isMouseInCircle(int mouseX, int mouseY, int x, int y, int radius);
+	//判断鼠标是否在椭圆按钮内
+	bool isMouseInEllipse(int mouseX, int mouseY, int x, int y, int width, int height);
 	//获取对话框类型
-    bool model() const override { return false; }
-    void cutButtonText();
-    // 统一隐藏&恢复背景
-    void hideTooltip();
-    // 根据当前 click 状态选择文案
-    void refreshTooltipTextForState(); 
-
+	bool model() const override { return false; }
+	void cutButtonText();
+	// 统一隐藏&恢复背景
+	void hideTooltip();
+	// 根据当前 click 状态选择文案
+	void refreshTooltipTextForState();
 };
-

include/StellarX/Canvas.h

@@ -23,54 +23,51 @@
 class Canvas : public Control
 {
 protected:
-    std::vector<std::unique_ptr<Control>> controls;
+	std::vector<std::unique_ptr<Control>> controls;
 
-    StellarX::ControlShape               shape = StellarX::ControlShape::RECTANGLE;   //容器形状
-    StellarX::FillMode          canvasFillMode = StellarX::FillMode::Solid;           //容器填充模式
-    StellarX::LineStyle        canvasLineStyle = StellarX::LineStyle::Solid;          //线型
-    int                        canvaslinewidth = 1;                                   //线宽
+	StellarX::ControlShape               shape = StellarX::ControlShape::RECTANGLE;   //容器形状
+	StellarX::FillMode          canvasFillMode = StellarX::FillMode::Solid;           //容器填充模式
+	StellarX::LineStyle        canvasLineStyle = StellarX::LineStyle::Solid;          //线型
+	int                        canvaslinewidth = 1;                                   //线宽
 
-    COLORREF              canvasBorderClor = RGB(0, 0, 0);    //边框颜色
-    COLORREF              canvasBkClor = RGB(255,255,255);    //背景颜色
+	COLORREF              canvasBorderClor = RGB(0, 0, 0);    //边框颜色
+	COLORREF              canvasBkClor = RGB(255, 255, 255);    //背景颜色
 
-
-    // 清除所有子控件
+	// 清除所有子控件
 	void clearAllControls();
 public:
-    Canvas();
-    Canvas(int x, int y, int width, int height);
-    ~Canvas() {}
+	Canvas();
+	Canvas(int x, int y, int width, int height);
+	~Canvas() {}
 
-    void setX(int x)override;
+	void setX(int x)override;
 	void setY(int y)override;
 
-    //绘制容器及其子控件
-    void draw() override;
-    bool handleEvent(const ExMessage& msg) override;
-    //添加控件
-    void addControl(std::unique_ptr<Control> control);
-    //设置容器样式
-    void setShape(StellarX::ControlShape shape);
-    //设置容器填充模式
-    void setCanvasfillMode(StellarX::FillMode mode);
-    //设置容器边框颜色
-    void setBorderColor(COLORREF color);
-    //设置填充颜色
-    void setCanvasBkColor(COLORREF color);
-    //设置线形
-    void setCanvasLineStyle(StellarX::LineStyle style);
-    //设置线段宽度
-    void setLinewidth(int width);
-    //设置不可见后传递给子控件重写
-    void setIsVisible(bool visible) override;
-    void setDirty(bool dirty) override;
-    void onWindowResize() override;
-    void requestRepaint(Control* parent)override;
-    //获取子控件列表
-    std::vector<std::unique_ptr<Control>>& getControls() { return controls; }
+	//绘制容器及其子控件
+	void draw() override;
+	bool handleEvent(const ExMessage& msg) override;
+	//添加控件
+	void addControl(std::unique_ptr<Control> control);
+	//设置容器样式
+	void setShape(StellarX::ControlShape shape);
+	//设置容器填充模式
+	void setCanvasfillMode(StellarX::FillMode mode);
+	//设置容器边框颜色
+	void setBorderColor(COLORREF color);
+	//设置填充颜色
+	void setCanvasBkColor(COLORREF color);
+	//设置线形
+	void setCanvasLineStyle(StellarX::LineStyle style);
+	//设置线段宽度
+	void setLinewidth(int width);
+	//设置不可见后传递给子控件重写
+	void setIsVisible(bool visible) override;
+	void setDirty(bool dirty) override;
+	void onWindowResize() override;
+	void requestRepaint(Control* parent)override;
+	//获取子控件列表
+	std::vector<std::unique_ptr<Control>>& getControls() { return controls; }
 private:
-    //用来检查对话框是否模态,此控件不做实现
-    bool model() const override { return false; };
-    
+	//用来检查对话框是否模态,此控件不做实现
+	bool model() const override { return false; };
 };
-

include/StellarX/Control.h

@@ -35,118 +35,119 @@
 class Control
 {
 protected:
-    std::string id;     // 控件ID
-    int localx,x, localy,y;           // 左上角坐标
-    int localWidth,width, localHeight,height;  // 控件尺寸
-    Control* parent = nullptr;    // 父控件
-    bool dirty = true; // 是否重绘
-    bool show = true; // 是否显示
+	std::string id;     // 控件ID
+	int localx, x, localy, y;           // 左上角坐标
+	int localWidth, width, localHeight, height;  // 控件尺寸
+	Control* parent = nullptr;    // 父控件
+	bool dirty = true; // 是否重绘
+	bool show = true; // 是否显示
 
-    /* == 布局模式 == */
-    StellarX::LayoutMode layoutMode = StellarX::LayoutMode::Fixed;  // 布局模式
-    StellarX::Anchor anchor_1 = StellarX::Anchor::Top; // 锚点
-    StellarX::Anchor anchor_2 = StellarX::Anchor::Right; // 锚点
+	/* == 布局模式 == */
+	StellarX::LayoutMode layoutMode = StellarX::LayoutMode::Fixed;  // 布局模式
+	StellarX::Anchor anchor_1 = StellarX::Anchor::Top; // 锚点
+	StellarX::Anchor anchor_2 = StellarX::Anchor::Right; // 锚点
 
-    /* == 背景快照 ==  */
-    IMAGE* saveBkImage = nullptr;
-    int saveBkX = 0, saveBkY = 0;      // 快照保存起始坐标
-    int saveWidth = 0, saveHeight = 0; // 快照保存尺寸
-    bool hasSnap = false;     //  当前是否持有有效快照
+	/* == 背景快照 ==  */
+	IMAGE* saveBkImage = nullptr;
+	int saveBkX = 0, saveBkY = 0;      // 快照保存起始坐标
+	int saveWidth = 0, saveHeight = 0; // 快照保存尺寸
+	bool hasSnap = false;     //  当前是否持有有效快照
 
-    StellarX::RouRectangle rouRectangleSize; // 圆角矩形椭圆宽度和高度
+	StellarX::RouRectangle rouRectangleSize; // 圆角矩形椭圆宽度和高度
 
-    LOGFONT* currentFont = new LOGFONT();       // 保存当前字体样式和颜色
-    COLORREF* currentColor = new COLORREF();
-    COLORREF* currentBkColor = new COLORREF();  // 保存当前填充色
-    COLORREF* currentBorderColor = new COLORREF(); // 边框颜色
-    LINESTYLE* currentLineStyle = new LINESTYLE(); // 保存当前线型
+	LOGFONT* currentFont = new LOGFONT();       // 保存当前字体样式和颜色
+	COLORREF* currentColor = new COLORREF();
+	COLORREF* currentBkColor = new COLORREF();  // 保存当前填充色
+	COLORREF* currentBorderColor = new COLORREF(); // 边框颜色
+	LINESTYLE* currentLineStyle = new LINESTYLE(); // 保存当前线型
 
-    Control(const Control&) = delete;
-    Control& operator=(const Control&) = delete;
-    Control(Control&&) = delete;
-    Control& operator=(Control&&) = delete;
+	Control(const Control&) = delete;
+	Control& operator=(const Control&) = delete;
+	Control(Control&&) = delete;
+	Control& operator=(Control&&) = delete;
 
-    Control() : localx(0),x(0), localy(0),y(0), localWidth(100),width(100),height(100), localHeight(100) {}
-    Control(int x, int y, int width, int height)
-        : localx(x), x(x), localy(y), y(y), localWidth(width), width(width), height(height), localHeight(height){}
+	Control() : localx(0), x(0), localy(0), y(0), localWidth(100), width(100), height(100), localHeight(100) {}
+	Control(int x, int y, int width, int height)
+		: localx(x), x(x), localy(y), y(y), localWidth(width), width(width), height(height), localHeight(height) {
+	}
 public:
 
-    virtual ~Control()
-    {
-        delete currentFont;
-        delete currentColor;
-        delete currentBkColor;
-        delete currentBorderColor;
-        delete currentLineStyle;
+	virtual ~Control()
+	{
+		delete currentFont;
+		delete currentColor;
+		delete currentBkColor;
+		delete currentBorderColor;
+		delete currentLineStyle;
 
-        currentFont = nullptr;
-        currentColor = nullptr;
-        currentBkColor = nullptr;
-        currentBorderColor = nullptr;
-        currentLineStyle = nullptr;
-        discardBackground();
-    }
+		currentFont = nullptr;
+		currentColor = nullptr;
+		currentBkColor = nullptr;
+		currentBorderColor = nullptr;
+		currentLineStyle = nullptr;
+		discardBackground();
+	}
 protected:
-    //向上请求重绘
-    virtual void requestRepaint(Control* parent);
-    //根控件/无父时触发重绘
-    virtual void onRequestRepaintAsRoot();
+	//向上请求重绘
+	virtual void requestRepaint(Control* parent);
+	//根控件/无父时触发重绘
+	virtual void onRequestRepaintAsRoot();
 protected:
-    //保存背景快照
-    virtual void saveBackground(int x, int y, int w, int h);
-    // putimage 回屏
-    virtual void restBackground();
-    // 释放快照（窗口重绘/尺寸变化后必须作废）
-    void discardBackground();
+	//保存背景快照
+	virtual void saveBackground(int x, int y, int w, int h);
+	// putimage 回屏
+	virtual void restBackground();
+	// 释放快照（窗口重绘/尺寸变化后必须作废）
+	void discardBackground();
 public:
-    //释放快照重新保存，在尺寸变化时更新背景快照避免尺寸变化导致显示错位
-    void updateBackground();
-    //窗口变化丢快照
-    virtual void onWindowResize();
-    // 获取位置和尺寸
-    int getX() const { return x; }
-    int getY() const { return y; }
-    int getWidth() const { return width; }
-    int getHeight() const { return height; }
-    int getRight() const { return x + width; }
-    int getBottom() const { return y + height; }
+	//释放快照重新保存，在尺寸变化时更新背景快照避免尺寸变化导致显示错位
+	void updateBackground();
+	//窗口变化丢快照
+	virtual void onWindowResize();
+	// 获取位置和尺寸
+	int getX() const { return x; }
+	int getY() const { return y; }
+	int getWidth() const { return width; }
+	int getHeight() const { return height; }
+	int getRight() const { return x + width; }
+	int getBottom() const { return y + height; }
 
-    int getLocalX() const { return localx; }
-    int getLocalY() const { return localy; }
-    int getLocalWidth() const { return localWidth; }
-    int getLocalHeight() const { return localHeight; }
-    int getLocalRight() const { return localx + localWidth; }
-    int getLocalBottom() const { return localy + localHeight; }
+	int getLocalX() const { return localx; }
+	int getLocalY() const { return localy; }
+	int getLocalWidth() const { return localWidth; }
+	int getLocalHeight() const { return localHeight; }
+	int getLocalRight() const { return localx + localWidth; }
+	int getLocalBottom() const { return localy + localHeight; }
 
-    virtual void setX(int x) { this->x = x; dirty = true; }
-    virtual void setY(int y) { this->y = y; dirty = true; }
-    virtual void setWidth(int width) { this->width = width; dirty = true; }
-    virtual void setHeight(int height) { this->height = height; dirty = true; }
+	virtual void setX(int x) { this->x = x; dirty = true; }
+	virtual void setY(int y) { this->y = y; dirty = true; }
+	virtual void setWidth(int width) { this->width = width; dirty = true; }
+	virtual void setHeight(int height) { this->height = height; dirty = true; }
 public:
 
-    virtual void draw() = 0;
-    virtual bool handleEvent(const ExMessage& msg) = 0;//返回true代表事件已消费
-    //设置是否显示
-    virtual void setIsVisible(bool show);
-    //设置父容器指针
-    void setParent(Control* parent) { this->parent = parent; }
-    //设置是否重绘
-    virtual void setDirty(bool dirty) { this->dirty = dirty; }
-    //检查控件是否可见
-    bool IsVisible() const { return show; };
-    //获取控件id
-    std::string getId() const { return id; }
-    //检查是否为脏
-    bool isDirty() { return dirty; }
-    //用来检查对话框是否模态，其他控件不用实现
-    virtual bool model()const = 0;
-    //布局
-    void setLayoutMode(StellarX::LayoutMode layoutMode_);
-    void setAnchor(StellarX::Anchor anchor_1, StellarX::Anchor anchor_2);
-    StellarX::Anchor getAnchor_1() const;
-    StellarX::Anchor getAnchor_2() const;
-    StellarX::LayoutMode getLayoutMode() const;
+	virtual void draw() = 0;
+	virtual bool handleEvent(const ExMessage& msg) = 0;//返回true代表事件已消费
+	//设置是否显示
+	virtual void setIsVisible(bool show);
+	//设置父容器指针
+	void setParent(Control* parent) { this->parent = parent; }
+	//设置是否重绘
+	virtual void setDirty(bool dirty) { this->dirty = dirty; }
+	//检查控件是否可见
+	bool IsVisible() const { return show; };
+	//获取控件id
+	std::string getId() const { return id; }
+	//检查是否为脏
+	bool isDirty() { return dirty; }
+	//用来检查对话框是否模态，其他控件不用实现
+	virtual bool model()const = 0;
+	//布局
+	void setLayoutMode(StellarX::LayoutMode layoutMode_);
+	void setAnchor(StellarX::Anchor anchor_1, StellarX::Anchor anchor_2);
+	StellarX::Anchor getAnchor_1() const;
+	StellarX::Anchor getAnchor_2() const;
+	StellarX::LayoutMode getLayoutMode() const;
 protected:
-    void saveStyle();
-    void restoreStyle();
+	void saveStyle();
+	void restoreStyle();
 };

include/StellarX/CoreTypes.h

@@ -27,363 +27,364 @@
   */
 namespace StellarX
 {
-    /**
-     * @枚举类名称: FillStyle
-     * @功能描述: 用来定义控件填充图案的枚举类
-     *
-     * @详细说明:
-     *    根据此枚举类可以自定义控件填充图案
-     *    可以在控件初始化时设置填充图案
-     *    根据具体情况选择不同的填充图案
-     *    默认填充图案为水平线
-     *
-     * @取值说明:
-     *  Horizontal  -  水平线
-     *  Vertical    -  垂直线
-     *  FDiagonal   -  反斜线
-     *  BDiagonal   -  正斜线
-     *  Cross       -  十字
-     *  DiagCross   -  网格
-     *
-     * @使用示例:
-     *   FillStyle var = FillStyle::Horizontal;
-     *
-     * @备注:
-     *   此枚举类仅支持图案填充模式
-     */
-    enum class FillStyle
-    {
-        Horizontal = HS_HORIZONTAL,	// 水平线
-        Vertical = HS_VERTICAL,	    // 垂直线
-        FDiagonal = HS_FDIAGONAL,	// 反斜线
-        BDiagonal = HS_BDIAGONAL,	// 正斜线
-        Cross = HS_CROSS,		    // 十字
-        DiagCross = HS_DIAGCROSS	// 网格
-    };
+	/**
+	 * @枚举类名称: FillStyle
+	 * @功能描述: 用来定义控件填充图案的枚举类
+	 *
+	 * @详细说明:
+	 *    根据此枚举类可以自定义控件填充图案
+	 *    可以在控件初始化时设置填充图案
+	 *    根据具体情况选择不同的填充图案
+	 *    默认填充图案为水平线
+	 *
+	 * @取值说明:
+	 *  Horizontal  -  水平线
+	 *  Vertical    -  垂直线
+	 *  FDiagonal   -  反斜线
+	 *  BDiagonal   -  正斜线
+	 *  Cross       -  十字
+	 *  DiagCross   -  网格
+	 *
+	 * @使用示例:
+	 *   FillStyle var = FillStyle::Horizontal;
+	 *
+	 * @备注:
+	 *   此枚举类仅支持图案填充模式
+	 */
+	enum class FillStyle
+	{
+		Horizontal = HS_HORIZONTAL,	// 水平线
+		Vertical = HS_VERTICAL,	    // 垂直线
+		FDiagonal = HS_FDIAGONAL,	// 反斜线
+		BDiagonal = HS_BDIAGONAL,	// 正斜线
+		Cross = HS_CROSS,		    // 十字
+		DiagCross = HS_DIAGCROSS	// 网格
+	};
 
-    /**
-     * @枚举类名称: FillMode
-     * @功能描述:   用来定义控件填充模式的枚举类
-     *
-     * @详细说明:
-     *    根据此枚举类可以自定义控件填充模式
-     *    可以在控件初始化时设置填充模式
-     *    根据具体情况选择不同的填充模式
-     *    默认填充模式为固实填充
-     *
-     * @取值说明:
-     *    Solid       -   固实填充
-     *	  Null        -   不填充
-     *	  Hatched     -   图案填充
-     *	  Pattern     -   自定义图案填充
-     *	  DibPattern  -   自定义图像填充
-     *
-     * @使用示例:
-     *   FillMode var = FillMode::Solid;
-     */
-    enum class FillMode
-    {
-        Solid = BS_SOLID,       //固实填充
-        Null = BS_NULL,         // 不填充
-        Hatched = BS_HATCHED,   // 图案填充
-        Pattern = BS_PATTERN,   // 自定义图案填充
-        DibPattern = BS_DIBPATTERN  // 自定义图像填充
-    };
+	/**
+	 * @枚举类名称: FillMode
+	 * @功能描述:   用来定义控件填充模式的枚举类
+	 *
+	 * @详细说明:
+	 *    根据此枚举类可以自定义控件填充模式
+	 *    可以在控件初始化时设置填充模式
+	 *    根据具体情况选择不同的填充模式
+	 *    默认填充模式为固实填充
+	 *
+	 * @取值说明:
+	 *    Solid       -   固实填充
+	 *	  Null        -   不填充
+	 *	  Hatched     -   图案填充
+	 *	  Pattern     -   自定义图案填充
+	 *	  DibPattern  -   自定义图像填充
+	 *
+	 * @使用示例:
+	 *   FillMode var = FillMode::Solid;
+	 */
+	enum class FillMode
+	{
+		Solid = BS_SOLID,       //固实填充
+		Null = BS_NULL,         // 不填充
+		Hatched = BS_HATCHED,   // 图案填充
+		Pattern = BS_PATTERN,   // 自定义图案填充
+		DibPattern = BS_DIBPATTERN  // 自定义图像填充
+	};
 
-    /**
-     * @枚举类名称: LineStyle
-     * @功能描述: 此枚举类用来定义控件边框线型
-     *
-     * @详细说明:
-     *       根据此枚举类可以自定义控件边框线型
-     *       可以在控件初始化时设置边框线型
-     *	     根据具体情况选择不同的线型
-     *       默认线型为实线
-     *
-     * @取值说明:
-     *     Solid          // 实线
-     *	   Dash           // 虚线
-     *	   Dot            // 点线
-     *	   DashDot        // 点划线
-     *	   DashDotDot     // 双点划线
-     *	   Null           // 无线
-     *
-     * @使用示例:
-     *   LineStyle var = LineStyle::Solid;
-     */
-    enum class LineStyle
-    {
-        Solid = PS_SOLID,       // 实线
-        Dash = PS_DASH,         // 虚线
-        Dot = PS_DOT,           // 点线
-        DashDot = PS_DASHDOT,   // 点划线
-        DashDotDot = PS_DASHDOTDOT, // 双点划线
-        Null = PS_NULL          // 无线
-    };
+	/**
+	 * @枚举类名称: LineStyle
+	 * @功能描述: 此枚举类用来定义控件边框线型
+	 *
+	 * @详细说明:
+	 *       根据此枚举类可以自定义控件边框线型
+	 *       可以在控件初始化时设置边框线型
+	 *	     根据具体情况选择不同的线型
+	 *       默认线型为实线
+	 *
+	 * @取值说明:
+	 *     Solid          // 实线
+	 *	   Dash           // 虚线
+	 *	   Dot            // 点线
+	 *	   DashDot        // 点划线
+	 *	   DashDotDot     // 双点划线
+	 *	   Null           // 无线
+	 *
+	 * @使用示例:
+	 *   LineStyle var = LineStyle::Solid;
+	 */
+	enum class LineStyle
+	{
+		Solid = PS_SOLID,       // 实线
+		Dash = PS_DASH,         // 虚线
+		Dot = PS_DOT,           // 点线
+		DashDot = PS_DASHDOT,   // 点划线
+		DashDotDot = PS_DASHDOTDOT, // 双点划线
+		Null = PS_NULL          // 无线
+	};
 
-    /**
-     * @结构体名称: ControlText
-     * @功能描述: 控件字体样式  可以自定义不同的样式
-     *
-     * @详细说明:
-     * 主要使用的场景为：需要修改或想自定义控件字体大小，字体样式，颜色等
-     *
-     * @成员说明:
-     *      int       nHeight = 0;          - 字体高度
-     *	    int       nWidth = 0;           - 字体宽度 如果为0则自适应
-     *	LPCTSTR       lpszFace = "宋体";    - 字体名称
-     *	COLORREF      color = RGB(0, 0, 0); - 字体颜色
-     *	     int      nEscapement = 0;      - 字符串旋转角度
-     *	     int      nOrientation = 0;     - 字符旋转角度
-     *	     int      nWeight = 0;          - 字体粗细 范围0~1000 0表示默认
-     *	     bool     bItalic = false;      - 是否斜体
-     *	     bool     bUnderline = false;   - 是否下划线
-     *	     bool     bStrikeOut = false;   - 是否删除线
-     */
-    struct ControlText
-    {
-        int  nHeight = 0;           //- 字体高度
-        int  nWidth = 0;            //- 字体宽度 如果为0则自适应
-        LPCTSTR  lpszFace = "微软雅黑";     //- 字体名称
-        COLORREF color = RGB(0, 0, 0);  //- 字体颜色
-        int nEscapement = 0;       //- 字符串旋转角度
-        int nOrientation = 0;      //- 字符旋转角度
-        int nWeight = 0;           //- 字体粗细 范围0~1000 0表示默认
-        bool bItalic = false;       //- 是否斜体
-        bool bUnderline = false;    //- 是否下划线
-        bool bStrikeOut = false;     //- 是否删除线
+	/**
+	 * @结构体名称: ControlText
+	 * @功能描述: 控件字体样式  可以自定义不同的样式
+	 *
+	 * @详细说明:
+	 * 主要使用的场景为：需要修改或想自定义控件字体大小，字体样式，颜色等
+	 *
+	 * @成员说明:
+	 *      int       nHeight = 0;          - 字体高度
+	 *	    int       nWidth = 0;           - 字体宽度 如果为0则自适应
+	 *	LPCTSTR       lpszFace = "宋体";    - 字体名称
+	 *	COLORREF      color = RGB(0, 0, 0); - 字体颜色
+	 *	     int      nEscapement = 0;      - 字符串旋转角度
+	 *	     int      nOrientation = 0;     - 字符旋转角度
+	 *	     int      nWeight = 0;          - 字体粗细 范围0~1000 0表示默认
+	 *	     bool     bItalic = false;      - 是否斜体
+	 *	     bool     bUnderline = false;   - 是否下划线
+	 *	     bool     bStrikeOut = false;   - 是否删除线
+	 */
+	struct ControlText
+	{
+		int  nHeight = 0;           //- 字体高度
+		int  nWidth = 0;            //- 字体宽度 如果为0则自适应
+		LPCTSTR  lpszFace = "微软雅黑";     //- 字体名称
+		COLORREF color = RGB(0, 0, 0);  //- 字体颜色
+		int nEscapement = 0;       //- 字符串旋转角度
+		int nOrientation = 0;      //- 字符旋转角度
+		int nWeight = 0;           //- 字体粗细 范围0~1000 0表示默认
+		bool bItalic = false;       //- 是否斜体
+		bool bUnderline = false;    //- 是否下划线
+		bool bStrikeOut = false;     //- 是否删除线
 
-        bool operator!=(const ControlText& text);
-        ControlText& operator=(const ControlText& text);
-    };
+		bool operator!=(const ControlText& text);
+		ControlText& operator=(const ControlText& text);
+	};
 
-    /**
-     * @枚举名称: ControlShape
-     * @功能描述: 枚举控件的不同几何样式
-     *
-     * @详细说明:
-     * 定义了四种（有无边框算一种）不同的几何样式，可以根据具体需求
-     * 自定义控件的形状。
-     *
-     * @取值说明:
-     *      RECTANGLE = 1,     //有边框矩形
-     *  	B_RECTANGLE,       //无边框矩形
-     *  	ROUND_RECTANGLE,   //有边框圆角矩形
-     *  	B_ROUND_RECTANGLE, //无边框圆角矩形
-     *  	CIRCLE,            //有边框圆形
-     *  	B_CIRCLE,          //无边框圆形
-     *  	ELLIPSE,           //有边框椭圆
-     *  	B_ELLIPSE          //无边框椭圆
-     *
-     * @使用示例:
-     *   ControlShape shape = ControlShape::ELLIPSE;
-     *
-     * @备注:
-     *   按钮类支持所有形状，部分控件只支持部分形状，具体请参考控件类。
-     */
-    enum class ControlShape
-    {
-        RECTANGLE = 1,     //有边框矩形
-        B_RECTANGLE,       //无边框矩形
-        ROUND_RECTANGLE,   //有边框圆角矩形
-        B_ROUND_RECTANGLE, //无边框圆角矩形
-        CIRCLE,            //有边框圆形
-        B_CIRCLE,          //无边框圆形
-        ELLIPSE,           //有边框椭圆
-        B_ELLIPSE          //无边框椭圆
-    };
+	/**
+	 * @枚举名称: ControlShape
+	 * @功能描述: 枚举控件的不同几何样式
+	 *
+	 * @详细说明:
+	 * 定义了四种（有无边框算一种）不同的几何样式，可以根据具体需求
+	 * 自定义控件的形状。
+	 *
+	 * @取值说明:
+	 *      RECTANGLE = 1,     //有边框矩形
+	 *  	B_RECTANGLE,       //无边框矩形
+	 *  	ROUND_RECTANGLE,   //有边框圆角矩形
+	 *  	B_ROUND_RECTANGLE, //无边框圆角矩形
+	 *  	CIRCLE,            //有边框圆形
+	 *  	B_CIRCLE,          //无边框圆形
+	 *  	ELLIPSE,           //有边框椭圆
+	 *  	B_ELLIPSE          //无边框椭圆
+	 *
+	 * @使用示例:
+	 *   ControlShape shape = ControlShape::ELLIPSE;
+	 *
+	 * @备注:
+	 *   按钮类支持所有形状，部分控件只支持部分形状，具体请参考控件类。
+	 */
+	enum class ControlShape
+	{
+		RECTANGLE = 1,     //有边框矩形
+		B_RECTANGLE,       //无边框矩形
+		ROUND_RECTANGLE,   //有边框圆角矩形
+		B_ROUND_RECTANGLE, //无边框圆角矩形
+		CIRCLE,            //有边框圆形
+		B_CIRCLE,          //无边框圆形
+		ELLIPSE,           //有边框椭圆
+		B_ELLIPSE          //无边框椭圆
+	};
 
-    /**
-     * @枚举类名称: TextBoxmode
-     * @功能描述: 定义了文本框的两种模式
-     *
-     * @详细说明:
-     * 需要限制文本框是否接受用户输入时使用
-     *
-     * @取值说明:
-     *   INPUT_MODE,   // 用户可输入模式
-     *	 READONLY_MODE // 只读模式
-     */
-    enum class TextBoxmode
-    {
-        INPUT_MODE,  // 用户可输入模式
-        READONLY_MODE // 只读模式
-    };
+	/**
+	 * @枚举类名称: TextBoxmode
+	 * @功能描述: 定义了文本框的两种模式
+	 *
+	 * @详细说明:
+	 * 需要限制文本框是否接受用户输入时使用
+	 *
+	 * @取值说明:
+	 *   INPUT_MODE,   // 用户可输入模式
+	 *	 READONLY_MODE // 只读模式
+	 */
+	enum class TextBoxmode
+	{
+		INPUT_MODE,  // 用户可输入模式
+		READONLY_MODE, // 只读模式
+		PASSWORD_MODE// 密码模式
+	};
 
-    /**
-     * @枚举名称: ButtonMode
-     * @功能描述: 定义按钮的工作模式
-     *
-     * @详细说明:
-     * 根据按钮的工作模式，按钮可以有不同的行为。
-     * 用户可以在具体情况下设置按钮的工作模式。
-     *
-     * @取值说明:
-     *   NORMAL = 1, -  普通模式，点击后触发回调，但不会保持状态。
-     *	 TOGGLE,     -  切换模式，点击后会在选中和未选中之间切换，触发不同的回调函数。
-     *	 DISABLED    -  禁用模式，按钮不可点击，显示为灰色，文本显示删除线。
-     *
-     * @使用示例:
-     *   ButtonMode mode = ButtonMode::NORMAL;
-     */
-    enum class ButtonMode
-    {
-        NORMAL = 1, //普通模式
-        TOGGLE,     //切换模式
-        DISABLED    //禁用模式
-    };
+	/**
+	 * @枚举名称: ButtonMode
+	 * @功能描述: 定义按钮的工作模式
+	 *
+	 * @详细说明:
+	 * 根据按钮的工作模式，按钮可以有不同的行为。
+	 * 用户可以在具体情况下设置按钮的工作模式。
+	 *
+	 * @取值说明:
+	 *   NORMAL = 1, -  普通模式，点击后触发回调，但不会保持状态。
+	 *	 TOGGLE,     -  切换模式，点击后会在选中和未选中之间切换，触发不同的回调函数。
+	 *	 DISABLED    -  禁用模式，按钮不可点击，显示为灰色，文本显示删除线。
+	 *
+	 * @使用示例:
+	 *   ButtonMode mode = ButtonMode::NORMAL;
+	 */
+	enum class ButtonMode
+	{
+		NORMAL = 1, //普通模式
+		TOGGLE,     //切换模式
+		DISABLED    //禁用模式
+	};
 
-    /**
-     * @结构体名称: RouRectangle
-     * @功能描述: 定义了控件圆角矩形样式时圆角的椭圆尺寸
-     *
-     * @详细说明:
-     * 需要修改控件圆角矩形样式时的圆角椭圆。
-     *
-     * @成员说明:
-     *  int ROUND_RECTANGLEwidth = 20;  //构成圆角矩形的圆角的椭圆的宽度。
-     *  int ROUND_RECTANGLEheight = 20;  //构成圆角矩形的圆角的椭圆的高度。
-     */
-    struct RouRectangle
-    {
-        int ROUND_RECTANGLEwidth = 20;  //构成圆角矩形的圆角的椭圆的宽度。     
-        int ROUND_RECTANGLEheight = 20;  //构成圆角矩形的圆角的椭圆的高度。
-    };
+	/**
+	 * @结构体名称: RouRectangle
+	 * @功能描述: 定义了控件圆角矩形样式时圆角的椭圆尺寸
+	 *
+	 * @详细说明:
+	 * 需要修改控件圆角矩形样式时的圆角椭圆。
+	 *
+	 * @成员说明:
+	 *  int ROUND_RECTANGLEwidth = 20;  //构成圆角矩形的圆角的椭圆的宽度。
+	 *  int ROUND_RECTANGLEheight = 20;  //构成圆角矩形的圆角的椭圆的高度。
+	 */
+	struct RouRectangle
+	{
+		int ROUND_RECTANGLEwidth = 20;  //构成圆角矩形的圆角的椭圆的宽度。
+		int ROUND_RECTANGLEheight = 20;  //构成圆角矩形的圆角的椭圆的高度。
+	};
 
-    // 消息框类型
-    enum class MessageBoxType
-    {
-        OK,                // 只有确定按钮
-        OKCancel,          // 确定和取消按钮
-        YesNo,             // 是和否按钮
-        YesNoCancel,       // 是、否和取消按钮
-        RetryCancel,       // 重试和取消按钮
-        AbortRetryIgnore,  // 中止、重试和忽略按钮
-    };
+	// 消息框类型
+	enum class MessageBoxType
+	{
+		OK,                // 只有确定按钮
+		OKCancel,          // 确定和取消按钮
+		YesNo,             // 是和否按钮
+		YesNoCancel,       // 是、否和取消按钮
+		RetryCancel,       // 重试和取消按钮
+		AbortRetryIgnore,  // 中止、重试和忽略按钮
+	};
 
-    // 消息框返回值
-    enum class MessageBoxResult
-    {
-        OK = 1,         // 确定按钮
-        Cancel = 2,     // 取消按钮
-        Yes = 6,        // 是按钮
-        No = 7,         // 否按钮
-        Abort = 3,      // 中止按钮
-        Retry = 4,      // 重试按钮
-        Ignore = 5      // 忽略按钮
-    };
+	// 消息框返回值
+	enum class MessageBoxResult
+	{
+		OK = 1,         // 确定按钮
+		Cancel = 2,     // 取消按钮
+		Yes = 6,        // 是按钮
+		No = 7,         // 否按钮
+		Abort = 3,      // 中止按钮
+		Retry = 4,      // 重试按钮
+		Ignore = 5      // 忽略按钮
+	};
 #if 0   //布局管理器相关  —待实现—
-    /*
-     *
-     *@枚举名称: LayoutKind
-     * @功能描述 : 定义布局管理类型
-     *
-     *@详细说明 :
-     * 根据布局管理类型，控件可以有不同的布局方式。
-     * 用户可以在具体情况下设置布局管理类型。
-     *
-     * @取值说明 :
-     * Absolute：不管，保持子控件自己的坐标（向后兼容）。
-     * HBox：    水平方向排队；支持固定宽、权重分配、对齐、拉伸。
-     * VBox：    竖直方向排队；同上。
-     * Grid（网格）：按行列摆；支持固定/自适应/权重行列；支持跨行/跨列；单元内对齐/拉伸。
-     *
-     */
-     // 布局类型
-    enum class LayoutKind
-    {
-        Absolute = 1,
-        HBox,
-        VBox,
-        Grid,
-        Flow,
-        Stack
-    };
+	/*
+	 *
+	 *@枚举名称: LayoutKind
+	 * @功能描述 : 定义布局管理类型
+	 *
+	 *@详细说明 :
+	 * 根据布局管理类型，控件可以有不同的布局方式。
+	 * 用户可以在具体情况下设置布局管理类型。
+	 *
+	 * @取值说明 :
+	 * Absolute：不管，保持子控件自己的坐标（向后兼容）。
+	 * HBox：    水平方向排队；支持固定宽、权重分配、对齐、拉伸。
+	 * VBox：    竖直方向排队；同上。
+	 * Grid（网格）：按行列摆；支持固定/自适应/权重行列；支持跨行/跨列；单元内对齐/拉伸。
+	 *
+	 */
+	 // 布局类型
+	enum class LayoutKind
+	{
+		Absolute = 1,
+		HBox,
+		VBox,
+		Grid,
+		Flow,
+		Stack
+	};
 
-    // 布局参数
-    struct LayoutParams
-    {
-        // 边距左、右、上、下
-        int marginL = 0, marginR = 0, marginT = 0, marginB = 0;
-        // 固定尺寸（>=0 强制；-1 用控件当前尺寸）
-        int fixedW = -1, fixedH = -1;
-        // 主轴权重（HBox=宽度、VBox=高度、Grid见下）
-        float weight = 0.f;
-        // 对齐（非拉伸时生效）
-        enum Align { Start = 0, Center = 1, End = 2, Stretch = 3 };
-        int alignX = Start; // HBox: 次轴=Y；VBox: 次轴=X；Grid: 单元内
-        int alignY = Start; // Grid ：控制单元内垂直（HBox / VBox通常只用 alignX）
-        // Grid 专用（可先不做）
-        int gridRow = 0, gridCol = 0, rowSpan = 1, colSpan = 1;
-        // Flow 专用（可先不做）
-        int flowBreak = 0; // 1=强制换行
-    };
+	// 布局参数
+	struct LayoutParams
+	{
+		// 边距左、右、上、下
+		int marginL = 0, marginR = 0, marginT = 0, marginB = 0;
+		// 固定尺寸（>=0 强制；-1 用控件当前尺寸）
+		int fixedW = -1, fixedH = -1;
+		// 主轴权重（HBox=宽度、VBox=高度、Grid见下）
+		float weight = 0.f;
+		// 对齐（非拉伸时生效）
+		enum Align { Start = 0, Center = 1, End = 2, Stretch = 3 };
+		int alignX = Start; // HBox: 次轴=Y；VBox: 次轴=X；Grid: 单元内
+		int alignY = Start; // Grid ：控制单元内垂直（HBox / VBox通常只用 alignX）
+		// Grid 专用（可先不做）
+		int gridRow = 0, gridCol = 0, rowSpan = 1, colSpan = 1;
+		// Flow 专用（可先不做）
+		int flowBreak = 0; // 1=强制换行
+	};
 #endif
 
-    /*
-     * @枚举名称: TabPlacement
-     * @功能描述: 定义了选项卡页签的不同位置
-     *
-     * @详细说明:
-     * 根据选项卡页签的位置，选项卡页签可以有不同的布局方式。
-     *
-     * @成员说明:
-     *  Top,   - 选项卡页签位于顶部
-     *  Bottom, - 选项卡页签位于底部
-     *  Left,  - 选项卡页签位于左侧
-     *  Right  - 选项卡页签位于右侧
-     *
-     * @使用示例:
-     *   TabPlacement placement = TabPlacement::Top;
-     */
-    enum class TabPlacement
-    {
-        Top,
-        Bottom,
-        Left,
-        Right
-    };
-    /*
-    * @枚举名称: LayoutMode
-    * @功能描述: 定义了两种布局模式
-    *
-    * @详细说明:
-    * 根据不同模式，在窗口拉伸时采用不同的布局策略
-    *
-    * @成员说明:
-    * Fixed,          - 固定布局
-    * AnchorToEdges   - 锚定布局
-    *
-    * @使用示例:
-    *   LayoutMode mode = LayoutMode::Fixed;
-    */
-    enum class LayoutMode 
-    {
-        Fixed, 
-        AnchorToEdges 
-    };
-    /*
-    * @枚举名称: Anchor
-    * @功能描述: 定义了控件相对于窗口锚定的位置
-    *
-    * @详细说明:
-    * 根据不同的锚定位置，有不同的拉伸策略
-    *
-    * @成员说明:
-    *  Top,    - 锚定上边，控件上边与窗口上侧距离保持不变
-    *  Bottom, - 锚定底边，控件底边与窗口底边距离保持不变
-    *  Left,   - 锚定左边，控件左边与窗口左侧距离保持不变
-    *  Right   - 锚定右边，控件上边与窗口右侧距离保持不变
-    *
-    * @使用示例:
-    *   Anchor a = Anchor::Top;
-    */
-    enum class Anchor
-    {
-        NoAnchor = 0,
-        Left = 1,
-        Right,
-        Top,
-        Bottom
-    };
+	/*
+	 * @枚举名称: TabPlacement
+	 * @功能描述: 定义了选项卡页签的不同位置
+	 *
+	 * @详细说明:
+	 * 根据选项卡页签的位置，选项卡页签可以有不同的布局方式。
+	 *
+	 * @成员说明:
+	 *  Top,   - 选项卡页签位于顶部
+	 *  Bottom, - 选项卡页签位于底部
+	 *  Left,  - 选项卡页签位于左侧
+	 *  Right  - 选项卡页签位于右侧
+	 *
+	 * @使用示例:
+	 *   TabPlacement placement = TabPlacement::Top;
+	 */
+	enum class TabPlacement
+	{
+		Top,
+		Bottom,
+		Left,
+		Right
+	};
+	/*
+	* @枚举名称: LayoutMode
+	* @功能描述: 定义了两种布局模式
+	*
+	* @详细说明:
+	* 根据不同模式，在窗口拉伸时采用不同的布局策略
+	*
+	* @成员说明:
+	* Fixed,          - 固定布局
+	* AnchorToEdges   - 锚定布局
+	*
+	* @使用示例:
+	*   LayoutMode mode = LayoutMode::Fixed;
+	*/
+	enum class LayoutMode
+	{
+		Fixed,
+		AnchorToEdges
+	};
+	/*
+	* @枚举名称: Anchor
+	* @功能描述: 定义了控件相对于窗口锚定的位置
+	*
+	* @详细说明:
+	* 根据不同的锚定位置，有不同的拉伸策略
+	*
+	* @成员说明:
+	*  Top,    - 锚定上边，控件上边与窗口上侧距离保持不变
+	*  Bottom, - 锚定底边，控件底边与窗口底边距离保持不变
+	*  Left,   - 锚定左边，控件左边与窗口左侧距离保持不变
+	*  Right   - 锚定右边，控件上边与窗口右侧距离保持不变
+	*
+	* @使用示例:
+	*   Anchor a = Anchor::Top;
+	*/
+	enum class Anchor
+	{
+		NoAnchor = 0,
+		Left = 1,
+		Right,
+		Top,
+		Bottom
+	};
 }

include/StellarX/Dialog.h

@@ -45,7 +45,6 @@ class Dialog : public Canvas
 	std::string message;                  //提示信息
 	std::vector<std::string> lines;       //消息内容按行分割
 
-	
 	bool needsInitialization = true;      //是否需要初始化
 	bool close = false;					  //是否关闭
 	bool modal = true;                    //是否模态
@@ -57,7 +56,6 @@ class Dialog : public Canvas
 	COLORREF buttonFalseColor = RGB(215, 215, 215);   //按钮未被点击颜色
 	COLORREF buttonHoverColor = RGB(224, 224, 224);	  //按钮悬浮颜色
 
-
 	Button* closeButton = nullptr;  //关闭按钮
 
 	StellarX::MessageBoxResult result = StellarX::MessageBoxResult::Cancel; // 对话框结果
@@ -78,7 +76,6 @@ public:
 	//获取对话框消息，用以去重
 	std::string GetText() const;
 
-
 public:
 	Dialog(Window& hWnd, std::string text, std::string message = "对话框", StellarX::MessageBoxType type = StellarX::MessageBoxType::OK, bool modal = true);
 	~Dialog();
@@ -109,7 +106,6 @@ public:
 	//初始化
 	void setInitialization(bool init);
 
-
 private:
 	// 初始化按钮
 	void initButtons();

include/StellarX/StellarX.h

@@ -1,7 +1,7 @@
 /*******************************************************************************
  * @文件: StellarX.h
  * @摘要: 星垣(StellarX) GUI框架 - 主包含头文件
- * @版本: v2.3.1
+ * @版本: v2.3.2
  * @描述:
  *     一个为Windows平台打造的轻量级、模块化C++ GUI框架。
  *     基于EasyX图形库，提供简洁易用的API和丰富的控件。
@@ -11,8 +11,8 @@
  *
  * @作者: 我在人间做废物
  * @邮箱: [3150131407@qq.com] | [ysm3150131407@gmail.com]
+ * @官网：https://stellarx-gui.top/
  * @仓库: [https://github.com/Ysm-04/StellarX]
- * @官网：即将上线，敬请期待
  *
  * @许可证: MIT License
  * @版权: Copyright (c) 2025 我在人间做废物

include/StellarX/TabControl.h

@@ -25,48 +25,48 @@
 #define BUTMINWIDTH  30
 class TabControl :public Canvas
 {
-    int tabBarHeight = BUTMINWIDTH;        //页签栏高度   
-    StellarX::TabPlacement tabPlacement = StellarX::TabPlacement::Top ; //页签排列方式
-	std::vector<std::pair<std::unique_ptr<Button>,std::unique_ptr<Canvas>>> controls; //页签/页列表
+	int tabBarHeight = BUTMINWIDTH;        //页签栏高度
+	bool IsFirstDraw = true;          //首次绘制标记
+	int defaultActivation = -1;      //默认激活页签索引
+	StellarX::TabPlacement tabPlacement = StellarX::TabPlacement::Top; //页签排列方式
+	std::vector<std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>> controls; //页签/页列表
 
 private:
-    using Canvas::addControl;                 // 禁止外部误用
-    void addControl(std::unique_ptr<Control>) = delete; // 精准禁用该重载
+	using Canvas::addControl;                 // 禁止外部误用
+	void addControl(std::unique_ptr<Control>) = delete; // 精准禁用该重载
 private:
-    inline void initTabBar();
-    inline void initTabPage();
+	inline void initTabBar();
+	inline void initTabPage();
 public:
 	TabControl();
-	TabControl(int x,int y,int width,int height);
+	TabControl(int x, int y, int width, int height);
 	~TabControl();
 
-    void setX(int x)override;
-    void setY(int y)override;
+	void setX(int x)override;
+	void setY(int y)override;
 
 	void draw() override;
 	bool handleEvent(const ExMessage& msg) override;
 
-    //添加页签+页
-    void add(std::pair<std::unique_ptr<Button> ,std::unique_ptr<Canvas>>&& control);
-    //添加为某个页添加控件
-    void add(std::string tabText,std::unique_ptr<Control> control);
-    //设置页签位置 
-    void setTabPlacement(StellarX::TabPlacement placement);
-    //设置页签栏高度 两侧排列时为宽度
-    void setTabBarHeight(int height);
-    //设置不可见后传递给子控件重写
-    void setIsVisible(bool visible) override;
-    void onWindowResize() override;
-    //获取当前激活页签索引
-    int getActiveIndex() const;
-    //设置当前激活页签索引
-    void setActiveIndex(int idx);
-    //获取页签数量
-    int count() const; 
-    //通过页签文本返回索引
-    int indexOf(const std::string& tabText) const;
-    void setDirty(bool dirty) override;
-    void requestRepaint(Control* parent)override;
-   
+	//添加页签+页
+	void add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>&& control);
+	//添加为某个页添加控件
+	void add(std::string tabText, std::unique_ptr<Control> control);
+	//设置页签位置
+	void setTabPlacement(StellarX::TabPlacement placement);
+	//设置页签栏高度 两侧排列时为宽度
+	void setTabBarHeight(int height);
+	//设置不可见后传递给子控件重写
+	void setIsVisible(bool visible) override;
+	void onWindowResize() override;
+	//获取当前激活页签索引
+	int getActiveIndex() const;
+	//设置当前激活页签索引
+	void setActiveIndex(int idx);
+	//获取页签数量
+	int count() const;
+	//通过页签文本返回索引
+	int indexOf(const std::string& tabText) const;
+	void setDirty(bool dirty) override;
+	void requestRepaint(Control* parent)override;
 };
-

include/StellarX/label.h

@@ -21,28 +21,26 @@
 
 class Label : public Control
 {
-    std::string text;         //标签文本
-       COLORREF textBkColor; //标签背景颜色
-           bool textBkDisap = false;   //标签背景是否透明
+	std::string text;         //标签文本
+	COLORREF textBkColor; //标签背景颜色
+	bool textBkDisap = false;   //标签背景是否透明
 
-    //标签事件处理（标签无事件）不实现具体代码
-    bool handleEvent(const ExMessage& msg) override { return false; }
-    //用来检查对话框是否模态,此控件不做实现
-    bool model() const override { return false; };
+	//标签事件处理（标签无事件）不实现具体代码
+	bool handleEvent(const ExMessage& msg) override { return false; }
+	//用来检查对话框是否模态,此控件不做实现
+	bool model() const override { return false; };
 public:
-    StellarX::ControlText   textStyle;   //标签文本样式
+	StellarX::ControlText   textStyle;   //标签文本样式
 public:
-    Label();
-    Label(int x, int y, std::string text = "标签",COLORREF textcolor = BLACK, COLORREF bkColor= RGB(255,255,255));
-  
-    void draw() override;
-    void hide();
-    //设置标签背景是否透明
-    void setTextdisap(bool key);
-    //设置标签背景颜色
-    void setTextBkColor(COLORREF color);
-    //设置标签文本
-    void setText(std::string text);
+	Label();
+	Label(int x, int y, std::string text = "标签", COLORREF textcolor = BLACK, COLORREF bkColor = RGB(255, 255, 255));
 
+	void draw() override;
+	void hide();
+	//设置标签背景是否透明
+	void setTextdisap(bool key);
+	//设置标签背景颜色
+	void setTextBkColor(COLORREF color);
+	//设置标签文本
+	void setText(std::string text);
 };
-

include/StellarX/table.h

@@ -49,7 +49,6 @@
 #define TABLE_STR_PAGE_MID         "页/共"
 #define TABLE_STR_PAGE_SUFFIX      "页"
 
-
 class Table :public Control
 {
 private:
@@ -64,7 +63,7 @@ private:
 
 	int rowsPerPage = TABLE_DEFAULT_ROWS_PER_PAGE;  // 每页显示的行数
 	int currentPage = 1;                        // 当前页码
-	int totalPages  = 1;                         // 总页数
+	int totalPages = 1;                         // 总页数
 
 	bool isShowPageButton = true;			    // 是否显示翻页按钮
 	bool isNeedDrawHeaders = true;              // 是否需要绘制表头
@@ -73,7 +72,7 @@ private:
 
 	Button* prevButton = nullptr;               // 上一页按钮
 	Button* nextButton = nullptr;			    // 下一页按钮
-	Label*  pageNum = nullptr;                   //页码文本
+	Label* pageNum = nullptr;                   //页码文本
 
 	int dX = x, dY = y;							// 单元格的开始坐标
 	int uX = x, uY = y;							// 单元格的结束坐标
@@ -131,6 +130,12 @@ public:
 	void setTableLineStyle(StellarX::LineStyle style);
 	//设置边框宽度
 	void setTableBorderWidth(int width);
+	//清空表头
+	void clearHeaders();
+	//清空表格数据
+	void clearData();
+	//清空表头和数据
+	void resetTable();
 	//窗口变化丢快照+标脏
 	void onWindowResize() override;
 
@@ -153,7 +158,7 @@ public:
 	//获取线型
 	StellarX::LineStyle getTableLineStyle() const;
 	//获取表头
-	std::vector<std::string> getHeaders () const;
+	std::vector<std::string> getHeaders() const;
 	//获取表格数据
 	std::vector<std::vector<std::string>> getData() const;
 	//获取表格边框宽度
@@ -161,7 +166,4 @@ public:
 	//获取表格尺寸
 	int getTableWidth() const;
 	int getTableHeight() const;
-
-
 };
-

include/StellarX/textBox.h

@@ -18,42 +18,39 @@
 #pragma once
 #include "Control.h"
 
-
 class TextBox : public Control
 {
 	std::string   text;   //文本
-    StellarX::TextBoxmode   mode;  //模式
-    StellarX::ControlShape  shape; //形状
-    bool          click = false;  //是否点击
-    size_t           maxCharLen = 10;//最大字符长度
-    COLORREF      textBoxBkClor = RGB(255, 255, 255); //背景颜色
-    COLORREF      textBoxBorderClor = RGB(0,0,0);     //边框颜色
+	StellarX::TextBoxmode   mode;  //模式
+	StellarX::ControlShape  shape; //形状
+	bool          click = false;  //是否点击
+	size_t           maxCharLen = 10;//最大字符长度
+	COLORREF      textBoxBkClor = RGB(255, 255, 255); //背景颜色
+	COLORREF      textBoxBorderClor = RGB(0, 0, 0);     //边框颜色
 
 public:
-    StellarX::ControlText textStyle; //文本样式
+	StellarX::ControlText textStyle; //文本样式
 
-    TextBox(int x, int y, int width, int height, std::string text = "", StellarX::TextBoxmode mode = StellarX::TextBoxmode::INPUT_MODE, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
-    void draw() override;
-    bool handleEvent(const ExMessage& msg) override;
-    //设置模式
-    void setMode(StellarX::TextBoxmode mode);
-    //设置可输入最大字符长度
-    void setMaxCharLen(size_t len);
-    //设置形状
-    void setTextBoxshape(StellarX::ControlShape shape);
-    //设置边框颜色
-    void setTextBoxBorder(COLORREF color);
-    //设置背景颜色
-    void setTextBoxBk(COLORREF color);    
-    //设置文本
-    void setText(std::string text);
+	TextBox(int x, int y, int width, int height, std::string text = "", StellarX::TextBoxmode mode = StellarX::TextBoxmode::INPUT_MODE, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE);
+	void draw() override;
+	bool handleEvent(const ExMessage& msg) override;
+	//设置模式
+	void setMode(StellarX::TextBoxmode mode);
+	//设置可输入最大字符长度
+	void setMaxCharLen(size_t len);
+	//设置形状
+	void setTextBoxshape(StellarX::ControlShape shape);
+	//设置边框颜色
+	void setTextBoxBorder(COLORREF color);
+	//设置背景颜色
+	void setTextBoxBk(COLORREF color);
+	//设置文本
+	void setText(std::string text);
 
-    //获取文本
-    std::string getText() const;  
+	//获取文本
+	std::string getText() const;
 
 private:
-    //用来检查对话框是否模态,此控件不做实现
-    bool model() const override { return false; };
+	//用来检查对话框是否模态,此控件不做实现
+	bool model() const override { return false; };
 };
-
-

include/StellarX/window.h

@@ -1,5 +1,4 @@
-
-/**
+/**
  * Window（头文件）
  *
  * 设计目标：
@@ -23,88 +22,87 @@
 
 class Window
 {
-    // —— 尺寸状态 ——（绘制尺寸与待应用尺寸分离；收口时一次性更新）
-    int           width;                 // 当前有效宽（已应用到画布/控件的客户区宽）
-    int           height;                // 当前有效高（已应用到画布/控件的客户区高） 
-    int           localwidth;            // 基准宽（创建时的宽度）
-    int           localheight;           // 基准高（创建是的高度）
-    int           pendingW;              // 待应用宽（WM_SIZE/拉伸中记录用）
-    int           pendingH;              // 待应用高
-    int           minClientW;            // 业务设定的最小客户区宽（用于 GETMINMAXINFO 与 SIZING 夹紧）
-    int           minClientH;            // 业务设定的最小客户区高
-    int           windowMode = NULL;     // EasyX 初始化模式（EX_SHOWCONSOLE/EX_TOPMOST/...）
-    bool          needResizeDirty = false; // 统一收口重绘标志（置位后在事件环末尾处理）
-    bool          isSizing = false;      // 是否处于拖拽阶段（ENTER/EXIT SIZEMOVE 切换）
+	// —— 尺寸状态 ——（绘制尺寸与待应用尺寸分离；收口时一次性更新）
+	int           width;                 // 当前有效宽（已应用到画布/控件的客户区宽）
+	int           height;                // 当前有效高（已应用到画布/控件的客户区高）
+	int           localwidth;            // 基准宽（创建时的宽度）
+	int           localheight;           // 基准高（创建是的高度）
+	int           pendingW;              // 待应用宽（WM_SIZE/拉伸中记录用）
+	int           pendingH;              // 待应用高
+	int           minClientW;            // 业务设定的最小客户区宽（用于 GETMINMAXINFO 与 SIZING 夹紧）
+	int           minClientH;            // 业务设定的最小客户区高
+	int           windowMode = NULL;     // EasyX 初始化模式（EX_SHOWCONSOLE/EX_TOPMOST/...）
+	bool          needResizeDirty = false; // 统一收口重绘标志（置位后在事件环末尾处理）
+	bool          isSizing = false;      // 是否处于拖拽阶段（ENTER/EXIT SIZEMOVE 切换）
 
-    // —— 原生窗口句柄与子类化钩子 ——（子类化 EasyX 的窗口过程以拦截关键消息）
-    HWND          hWnd = NULL;           // EasyX 初始化后的窗口句柄
-    WNDPROC       oldWndProc = nullptr;  // 保存旧过程（CallWindowProc 回落）
-    bool          procHooked = false;    // 避免重复子类化
-    static LRESULT CALLBACK WndProcThunk(HWND h, UINT m, WPARAM w, LPARAM l); // 静态过程分发到 this
+	// —— 原生窗口句柄与子类化钩子 ——（子类化 EasyX 的窗口过程以拦截关键消息）
+	HWND          hWnd = NULL;           // EasyX 初始化后的窗口句柄
+	WNDPROC       oldWndProc = nullptr;  // 保存旧过程（CallWindowProc 回落）
+	bool          procHooked = false;    // 避免重复子类化
+	static LRESULT CALLBACK WndProcThunk(HWND h, UINT m, WPARAM w, LPARAM l); // 静态过程分发到 this
 
-    // —— 绘制相关 ——（是否使用合成双缓冲、窗口标题、背景等）
-    bool          useComposited = true;  // 是否启用 WS_EX_COMPOSITED（部分机器可能增加一帧观感延迟）
-    std::string   headline;              // 窗口标题文本
-    COLORREF      wBkcolor = BLACK;      // 纯色背景（无背景图时使用）
-    IMAGE* background = nullptr;  // 背景图对象指针（存在时优先绘制）
-    std::string   bkImageFile;           // 背景图文件路径（loadimage 用）
+	// —— 绘制相关 ——（是否使用合成双缓冲、窗口标题、背景等）
+	bool          useComposited = true;  // 是否启用 WS_EX_COMPOSITED（部分机器可能增加一帧观感延迟）
+	std::string   headline;              // 窗口标题文本
+	COLORREF      wBkcolor = BLACK;      // 纯色背景（无背景图时使用）
+	IMAGE* background = nullptr;  // 背景图对象指针（存在时优先绘制）
+	std::string   bkImageFile;           // 背景图文件路径（loadimage 用）
 
-    // —— 控件/对话框 ——（容器内的普通控件与非模态对话框）
-    std::vector<std::unique_ptr<Control>> controls;
-    std::vector<std::unique_ptr<Control>> dialogs;
+	// —— 控件/对话框 ——（容器内的普通控件与非模态对话框）
+	std::vector<std::unique_ptr<Control>> controls;
+	std::vector<std::unique_ptr<Control>> dialogs;
 
 public:
-    bool dialogClose = false;            // 项目内使用的状态位
+	bool dialogClose = false;            // 项目内使用的状态位
 
-    // —— 构造/析构 ——（仅初始化成员；实际样式与子类化在 draw() 中完成）
-    Window(int width, int height, int mode);
-    Window(int width, int height, int mode, COLORREF bkcloc);
-    Window(int width, int height, int mode, COLORREF bkcloc, std::string headline);
-    ~Window();
+	// —— 构造/析构 ——（仅初始化成员；实际样式与子类化在 draw() 中完成）
+	Window(int width, int height, int mode);
+	Window(int width, int height, int mode, COLORREF bkcloc);
+	Window(int width, int height, int mode, COLORREF bkcloc, std::string headline);
+	~Window();
 
-    // —— 绘制与事件循环 ——（draw* 完成一次全量绘制；runEventLoop 驱动事件与统一收口）
-    void draw();                         // 纯色背景版本
-    void draw(std::string pImgFile);     // 背景图版本
-    int  runEventLoop();                 // 主事件循环（PeekMessage + 统一收口重绘）
+	// —— 绘制与事件循环 ——（draw* 完成一次全量绘制；runEventLoop 驱动事件与统一收口）
+	void draw();                         // 纯色背景版本
+	void draw(std::string pImgFile);     // 背景图版本
+	int  runEventLoop();                 // 主事件循环（PeekMessage + 统一收口重绘）
 
-    // —— 背景/标题设置 ——（更换背景、背景色与标题；立即触发一次批量绘制）
-    void setBkImage(std::string pImgFile);
-    void setBkcolor(COLORREF c);
-    void setHeadline(std::string headline);
+	// —— 背景/标题设置 ——（更换背景、背景色与标题；立即触发一次批量绘制）
+	void setBkImage(std::string pImgFile);
+	void setBkcolor(COLORREF c);
+	void setHeadline(std::string headline);
 
-    // —— 控件/对话框管理 ——（添加到容器，或做存在性判断）
-    void addControl(std::unique_ptr<Control> control);
-    void addDialog(std::unique_ptr<Control> dialogs);
-    bool hasNonModalDialogWithCaption(const std::string& caption, const std::string& message) const;
+	// —— 控件/对话框管理 ——（添加到容器，或做存在性判断）
+	void addControl(std::unique_ptr<Control> control);
+	void addDialog(std::unique_ptr<Control> dialogs);
+	bool hasNonModalDialogWithCaption(const std::string& caption, const std::string& message) const;
 
-    // —— 访问器 ——（只读接口，供外部查询当前窗口/标题/背景等）
-    HWND        getHwnd() const;
-    int         getWidth() const;
-    int         getHeight() const;
-    std::string getHeadline() const;
-    COLORREF    getBkcolor() const;
-    IMAGE* getBkImage() const;
-    std::string getBkImageFile() const;
-    std::vector<std::unique_ptr<Control>>& getControls();
+	// —— 访问器 ——（只读接口，供外部查询当前窗口/标题/背景等）
+	HWND        getHwnd() const;
+	int         getWidth() const;
+	int         getHeight() const;
+	std::string getHeadline() const;
+	COLORREF    getBkcolor() const;
+	IMAGE* getBkImage() const;
+	std::string getBkImageFile() const;
+	std::vector<std::unique_ptr<Control>>& getControls();
 
-    // —— 配置开关 ——（动态调整最小客户区、合成双缓冲）
-    inline void setMinClientSize(int w, int h)
-    {
-        // 仅更新阈值；实际约束在 WM_GETMINMAXINFO/WM_SIZING 中生效
-        minClientW = w;
-        minClientH = h;
-    }
+	// —— 配置开关 ——（动态调整最小客户区、合成双缓冲）
+	inline void setMinClientSize(int w, int h)
+	{
+		// 仅更新阈值；实际约束在 WM_GETMINMAXINFO/WM_SIZING 中生效
+		minClientW = w;
+		minClientH = h;
+	}
 
-    inline void setComposited(bool on)
-    {
-        // 更新标志；真正应用在 draw()/样式 SetWindowLongEx + SWP_FRAMECHANGED
-        useComposited = on;
-    }
+	inline void setComposited(bool on)
+	{
+		// 更新标志；真正应用在 draw()/样式 SetWindowLongEx + SWP_FRAMECHANGED
+		useComposited = on;
+	}
 
-    void processWindowMessage(const ExMessage & msg); // 处理 EX_WINDOW 中的 WM_SIZE 等
-    void pumpResizeIfNeeded();                       // 执行一次统一收口重绘
-    void scheduleResizeFromModal(int w, int h);
+	void processWindowMessage(const ExMessage& msg); // 处理 EX_WINDOW 中的 WM_SIZE 等
+	void pumpResizeIfNeeded();                       // 执行一次统一收口重绘
+	void scheduleResizeFromModal(int w, int h);
 private:
-    void adaptiveLayout(std::unique_ptr<Control>& c,const int finalH, const int finalW);
-
+	void adaptiveLayout(std::unique_ptr<Control>& c, const int finalH, const int finalW);
 };

src/Button.cpp

@@ -163,7 +163,6 @@ void Button::initButton(const std::string text, StellarX::ButtonMode mode, Stell
 	tipLabel.textStyle = this->textStyle;  // 复用按钮字体样式
 }
 
-
 Button::~Button()
 {
 	if (buttonFileIMAGE)
@@ -274,7 +273,6 @@ void Button::draw()
 
 	restoreStyle();//恢复默认字体样式和颜色
 	dirty = false;     //标记按钮不需要重绘
-
 }
 // 处理鼠标事件，检测点击和悬停状态
 // 根据按钮模式和形状进行不同的处理
@@ -314,7 +312,6 @@ bool Button::handleEvent(const ExMessage& msg)
 	// 处理鼠标点击事件
 	if (msg.message == WM_LBUTTONDOWN && hover && mode != StellarX::ButtonMode::DISABLED)
 	{
-
 		if (mode == StellarX::ButtonMode::NORMAL)
 		{
 			click = true;
@@ -451,7 +448,6 @@ void Button::setROUND_RECTANGLEwidth(int width)
 {
 	rouRectangleSize.ROUND_RECTANGLEwidth = width;
 	this->dirty = true; // 标记需要重绘
-
 }
 
 void Button::setROUND_RECTANGLEheight(int height)
@@ -489,7 +485,6 @@ void Button::setFillIma(std::string imaNAme)
 	this->dirty = true;
 }
 
-
 void Button::setButtonBorder(COLORREF Border)
 {
 	buttonBorderColor = Border;
@@ -558,7 +553,6 @@ void Button::setButtonClick(BOOL click)
 		requestRepaint(parent);
 }
 
-
 std::string Button::getButtonText() const
 {
 	return this->text;
@@ -619,8 +613,6 @@ int Button::getButtonHeight() const
 	return this->height;
 }
 
-
-
 bool Button::isMouseInCircle(int mouseX, int mouseY, int x, int y, int radius)
 {
 	double dis = sqrt(pow(mouseX - x, 2) + pow(mouseY - y, 2));
@@ -666,11 +658,9 @@ void Button::cutButtonText()
 	else
 	{
 		cutText = ellipsize_cjk_pref(this->text, contentW, "…"); // 全角省略号
-
 	}
 	isUseCutText = true;
 	needCutText = false;
-
 }
 
 void Button::hideTooltip()
@@ -691,6 +681,3 @@ void Button::refreshTooltipTextForState()
 	else if (mode == StellarX::ButtonMode::TOGGLE)
 		tipLabel.setText(click ? tipTextOn : tipTextOff);
 }
-
-
-

src/Canvas.cpp

@@ -14,24 +14,24 @@ Canvas::Canvas(int x, int y, int width, int height)
 
 void Canvas::setX(int x)
 {
-    this->x = x;
-    for (auto& c : controls)
-    {
-        c->onWindowResize();
-        c->setX(c->getLocalX() + this->x);
-    }
+	this->x = x;
+	for (auto& c : controls)
+	{
+		c->onWindowResize();
+		c->setX(c->getLocalX() + this->x);
+	}
 	dirty = true;
 }
 
 void Canvas::setY(int y)
 {
-    this->y = y;
-    for (auto& c : controls)
-    {
-        c->onWindowResize();
-        c->setY(c->getLocalY() + this->y);
-    }
-    dirty = true;
+	this->y = y;
+	for (auto& c : controls)
+	{
+		c->onWindowResize();
+		c->setY(c->getLocalY() + this->y);
+	}
+	dirty = true;
 }
 
 void Canvas::clearAllControls()
@@ -50,38 +50,38 @@ void Canvas::draw()
 	}
 	saveStyle();
 	setlinecolor(canvasBorderClor);//设置线色
-    if(StellarX::FillMode::Null != canvasFillMode)
-        setfillcolor(canvasBkClor);//设置填充色
+	if (StellarX::FillMode::Null != canvasFillMode)
+		setfillcolor(canvasBkClor);//设置填充色
 	setfillstyle((int)canvasFillMode);//设置填充模式
 	setlinestyle((int)canvasLineStyle, canvaslinewidth);
 
-    // 在绘制画布之前，先恢复并更新背景快照：
-    // 1. 如果已有快照，则先回贴旧快照以清除之前的内容。
-    // 2. 当坐标或尺寸变化，或缓存图像无效时，丢弃旧快照并重新抓取新的背景。
-    int margin = canvaslinewidth > 1 ? canvaslinewidth : 1;
-    if (hasSnap)
-    {
-        // 恢复旧快照，清除上一次绘制
-        restBackground();
-        // 如果位置或尺寸变了，或没有有效缓存，则重新抓取
-        if (!saveBkImage || saveBkX != this->x - margin || saveBkY != this->y - margin || saveWidth != this->width + margin * 2 || saveHeight != this->height + margin * 2)
-        {
-            discardBackground();
-            saveBackground(this->x - margin, this->y - margin, this->width + margin * 2, this->height + margin * 2);
-        }
-    }
-    else
-    {
-        // 首次绘制或没有快照时直接抓取背景
-        saveBackground(this->x- margin, this->y- margin, this->width + margin*2, this->height + margin*2);
-    }
-    // 再次恢复最新快照，确保绘制区域干净
-    restBackground();
+	// 在绘制画布之前，先恢复并更新背景快照：
+	// 1. 如果已有快照，则先回贴旧快照以清除之前的内容。
+	// 2. 当坐标或尺寸变化，或缓存图像无效时，丢弃旧快照并重新抓取新的背景。
+	int margin = canvaslinewidth > 1 ? canvaslinewidth : 1;
+	if (hasSnap)
+	{
+		// 恢复旧快照，清除上一次绘制
+		restBackground();
+		// 如果位置或尺寸变了，或没有有效缓存，则重新抓取
+		if (!saveBkImage || saveBkX != this->x - margin || saveBkY != this->y - margin || saveWidth != this->width + margin * 2 || saveHeight != this->height + margin * 2)
+		{
+			discardBackground();
+			saveBackground(this->x - margin, this->y - margin, this->width + margin * 2, this->height + margin * 2);
+		}
+	}
+	else
+	{
+		// 首次绘制或没有快照时直接抓取背景
+		saveBackground(this->x - margin, this->y - margin, this->width + margin * 2, this->height + margin * 2);
+	}
+	// 再次恢复最新快照，确保绘制区域干净
+	restBackground();
 	//根据画布形状绘制
 	switch (shape)
 	{
 	case StellarX::ControlShape::RECTANGLE:
-		fillrectangle(x,y,x+width,y+height);//有边框填充矩形
+		fillrectangle(x, y, x + width, y + height);//有边框填充矩形
 		break;
 	case StellarX::ControlShape::B_RECTANGLE:
 		solidrectangle(x, y, x + width, y + height);//无边框填充矩形
@@ -121,7 +121,6 @@ bool Canvas::handleEvent(const ExMessage& msg)
 
 void Canvas::addControl(std::unique_ptr<Control> control)
 {
-   
 	//坐标转化
 	control->setX(control->getLocalX() + this->x);
 	control->setY(control->getLocalY() + this->y);
@@ -175,7 +174,6 @@ void Canvas::setCanvasLineStyle(StellarX::LineStyle style)
 	dirty = true;
 }
 
-
 void Canvas::setLinewidth(int width)
 {
 	this->canvaslinewidth = width;
@@ -198,179 +196,179 @@ void Canvas::setIsVisible(bool visible)
 void Canvas::setDirty(bool dirty)
 {
 	this->dirty = dirty;
-	for(auto& control : controls)
+	for (auto& control : controls)
 		control->setDirty(dirty);
 }
 
 void Canvas::onWindowResize()
 {
-    // 首先处理自身的快照等逻辑
-    Control::onWindowResize();
+	// 首先处理自身的快照等逻辑
+	Control::onWindowResize();
 
-    // 记录父容器原始尺寸（用于计算子控件的右/下边距）
-    int origParentW = this->localWidth;
-    int origParentH = this->localHeight;
+	// 记录父容器原始尺寸（用于计算子控件的右/下边距）
+	int origParentW = this->localWidth;
+	int origParentH = this->localHeight;
 
-    // 当前容器的新尺寸
-    int finalW = this->width;
-    int finalH = this->height;
+	// 当前容器的新尺寸
+	int finalW = this->width;
+	int finalH = this->height;
 
-    // 当前容器的新坐标（全局坐标）
-    int parentX = this->x;
-    int parentY = this->y;
+	// 当前容器的新坐标（全局坐标）
+	int parentX = this->x;
+	int parentY = this->y;
 
-    // 调整每个子控件在 AnchorToEdges 模式下的位置与尺寸
-    for (auto& ch : controls)
-    {
-        // Only adjust when using anchor-to-edges layout
-        if (ch->getLayoutMode() == StellarX::LayoutMode::AnchorToEdges)
-        {
-            // Determine whether this child is a Table; tables keep their height constant
-            bool isTable = (dynamic_cast<Table*>(ch.get()) != nullptr);
+	// 调整每个子控件在 AnchorToEdges 模式下的位置与尺寸
+	for (auto& ch : controls)
+	{
+		// Only adjust when using anchor-to-edges layout
+		if (ch->getLayoutMode() == StellarX::LayoutMode::AnchorToEdges)
+		{
+			// Determine whether this child is a Table; tables keep their height constant
+			bool isTable = (dynamic_cast<Table*>(ch.get()) != nullptr);
 
-            // Unpack anchors
-            auto a1 = ch->getAnchor_1();
-            auto a2 = ch->getAnchor_2();
+			// Unpack anchors
+			auto a1 = ch->getAnchor_1();
+			auto a2 = ch->getAnchor_2();
 
-            bool anchorLeft   = (a1 == StellarX::Anchor::Left   || a2 == StellarX::Anchor::Left);
-            bool anchorRight  = (a1 == StellarX::Anchor::Right  || a2 == StellarX::Anchor::Right);
-            bool anchorTop    = (a1 == StellarX::Anchor::Top    || a2 == StellarX::Anchor::Top);
-            bool anchorBottom = (a1 == StellarX::Anchor::Bottom || a2 == StellarX::Anchor::Bottom);
+			bool anchorLeft = (a1 == StellarX::Anchor::Left || a2 == StellarX::Anchor::Left);
+			bool anchorRight = (a1 == StellarX::Anchor::Right || a2 == StellarX::Anchor::Right);
+			bool anchorTop = (a1 == StellarX::Anchor::Top || a2 == StellarX::Anchor::Top);
+			bool anchorBottom = (a1 == StellarX::Anchor::Bottom || a2 == StellarX::Anchor::Bottom);
 
-            // If it's a table, treat as anchored left and right horizontally and anchored top vertically by default.
-            if (isTable)
-            {
-                anchorLeft = true;
-                anchorRight = true;
-                // If no explicit vertical anchor was provided, default to top.
-                if (!(anchorTop || anchorBottom))
-                {
-                    anchorTop = true;
-                }
-            }
+			// If it's a table, treat as anchored left and right horizontally and anchored top vertically by default.
+			if (isTable)
+			{
+				anchorLeft = true;
+				anchorRight = true;
+				// If no explicit vertical anchor was provided, default to top.
+				if (!(anchorTop || anchorBottom))
+				{
+					anchorTop = true;
+				}
+			}
 
-            // Compute new X and width
-            int newX = ch->getX();
-            int newWidth = ch->getWidth();
-            if (anchorLeft && anchorRight)
-            {
-                // Scale horizontally relative to parent's size.
-                if (origParentW > 0)
-                {
-                    // Maintain proportional position and size based on original local values.
-                    double scaleW = static_cast<double>(finalW) / static_cast<double>(origParentW);
-                    newX     = parentX + static_cast<int>(ch->getLocalX() * scaleW + 0.5);
-                    newWidth = static_cast<int>(ch->getLocalWidth() * scaleW + 0.5);
-                }
-                else
-                {
-                    // Fallback: keep original
-                    newX     = parentX + ch->getLocalX();
-                    newWidth = ch->getLocalWidth();
-                }
-            }
-            else if (anchorLeft && !anchorRight)
-            {
-                // Only left anchored: keep original width and left margin.
-                newWidth = ch->getLocalWidth();
-                newX     = parentX + ch->getLocalX();
-            }
-            else if (!anchorLeft && anchorRight)
-            {
-                // Only right anchored: keep original width and right margin.
-                newWidth = ch->getLocalWidth();
-                int origRightDist = origParentW - (ch->getLocalX() + ch->getLocalWidth());
-                newX = parentX + finalW - origRightDist - newWidth;
-            }
-            else
-            {
-                // No horizontal anchor: position relative to parent's left and width unchanged.
-                newWidth = ch->getLocalWidth();
-                newX     = parentX + ch->getLocalX();
-            }
-            ch->setX(newX);
-            ch->setWidth(newWidth);
+			// Compute new X and width
+			int newX = ch->getX();
+			int newWidth = ch->getWidth();
+			if (anchorLeft && anchorRight)
+			{
+				// Scale horizontally relative to parent's size.
+				if (origParentW > 0)
+				{
+					// Maintain proportional position and size based on original local values.
+					double scaleW = static_cast<double>(finalW) / static_cast<double>(origParentW);
+					newX = parentX + static_cast<int>(ch->getLocalX() * scaleW + 0.5);
+					newWidth = static_cast<int>(ch->getLocalWidth() * scaleW + 0.5);
+				}
+				else
+				{
+					// Fallback: keep original
+					newX = parentX + ch->getLocalX();
+					newWidth = ch->getLocalWidth();
+				}
+			}
+			else if (anchorLeft && !anchorRight)
+			{
+				// Only left anchored: keep original width and left margin.
+				newWidth = ch->getLocalWidth();
+				newX = parentX + ch->getLocalX();
+			}
+			else if (!anchorLeft && anchorRight)
+			{
+				// Only right anchored: keep original width and right margin.
+				newWidth = ch->getLocalWidth();
+				int origRightDist = origParentW - (ch->getLocalX() + ch->getLocalWidth());
+				newX = parentX + finalW - origRightDist - newWidth;
+			}
+			else
+			{
+				// No horizontal anchor: position relative to parent's left and width unchanged.
+				newWidth = ch->getLocalWidth();
+				newX = parentX + ch->getLocalX();
+			}
+			ch->setX(newX);
+			ch->setWidth(newWidth);
 
-            // Compute new Y and height
-            int newY = ch->getY();
-            int newHeight = ch->getHeight();
-            if (isTable)
-            {
-                // Table: Height remains constant; adjust Y based on anchors.
-                newHeight = ch->getLocalHeight();
-                if (anchorTop && anchorBottom)
-                {
-                    // If both top and bottom anchored, scale Y but keep height.
-                    if (origParentH > 0)
-                    {
-                        double scaleH = static_cast<double>(finalH) / static_cast<double>(origParentH);
-                        newY = parentY + static_cast<int>(ch->getLocalY() * scaleH + 0.5);
-                    }
-                    else
-                    {
-                        newY = parentY + ch->getLocalY();
-                    }
-                }
-                else if (anchorTop && !anchorBottom)
-                {
-                    // Top anchored only
-                    newY = parentY + ch->getLocalY();
-                }
-                else if (!anchorTop && anchorBottom)
-                {
-                    // Bottom anchored only
-                    int origBottomDist = origParentH - (ch->getLocalY() + ch->getLocalHeight());
-                    newY = parentY + finalH - origBottomDist - newHeight;
-                }
-                else
-                {
-                    // No vertical anchor: default to top
-                    newY = parentY + ch->getLocalY();
-                }
-            }
-            else
-            {
-                if (anchorTop && anchorBottom)
-                {
-                    // Scale vertically relative to parent's size.
-                    if (origParentH > 0)
-                    {
-                        double scaleH = static_cast<double>(finalH) / static_cast<double>(origParentH);
-                        newY      = parentY + static_cast<int>(ch->getLocalY() * scaleH + 0.5);
-                        newHeight = static_cast<int>(ch->getLocalHeight() * scaleH + 0.5);
-                    }
-                    else
-                    {
-                        newY      = parentY + ch->getLocalY();
-                        newHeight = ch->getLocalHeight();
-                    }
-                }
-                else if (anchorTop && !anchorBottom)
-                {
-                    // Top anchored only: keep height constant
-                    newHeight = ch->getLocalHeight();
-                    newY      = parentY + ch->getLocalY();
-                }
-                else if (!anchorTop && anchorBottom)
-                {
-                    // Bottom anchored only: keep height and adjust Y relative to bottom
-                    newHeight = ch->getLocalHeight();
-                    int origBottomDist = origParentH - (ch->getLocalY() + ch->getLocalHeight());
-                    newY = parentY + finalH - origBottomDist - newHeight;
-                }
-                else
-                {
-                    // No vertical anchor: position relative to parent's top, height constant.
-                    newHeight = ch->getLocalHeight();
-                    newY      = parentY + ch->getLocalY();
-                }
-            }
-            ch->setY(newY);
-            ch->setHeight(newHeight);
-        }
-        // Always forward the window resize event to the child (recursively).
-        ch->onWindowResize();
-    }
+			// Compute new Y and height
+			int newY = ch->getY();
+			int newHeight = ch->getHeight();
+			if (isTable)
+			{
+				// Table: Height remains constant; adjust Y based on anchors.
+				newHeight = ch->getLocalHeight();
+				if (anchorTop && anchorBottom)
+				{
+					// If both top and bottom anchored, scale Y but keep height.
+					if (origParentH > 0)
+					{
+						double scaleH = static_cast<double>(finalH) / static_cast<double>(origParentH);
+						newY = parentY + static_cast<int>(ch->getLocalY() * scaleH + 0.5);
+					}
+					else
+					{
+						newY = parentY + ch->getLocalY();
+					}
+				}
+				else if (anchorTop && !anchorBottom)
+				{
+					// Top anchored only
+					newY = parentY + ch->getLocalY();
+				}
+				else if (!anchorTop && anchorBottom)
+				{
+					// Bottom anchored only
+					int origBottomDist = origParentH - (ch->getLocalY() + ch->getLocalHeight());
+					newY = parentY + finalH - origBottomDist - newHeight;
+				}
+				else
+				{
+					// No vertical anchor: default to top
+					newY = parentY + ch->getLocalY();
+				}
+			}
+			else
+			{
+				if (anchorTop && anchorBottom)
+				{
+					// Scale vertically relative to parent's size.
+					if (origParentH > 0)
+					{
+						double scaleH = static_cast<double>(finalH) / static_cast<double>(origParentH);
+						newY = parentY + static_cast<int>(ch->getLocalY() * scaleH + 0.5);
+						newHeight = static_cast<int>(ch->getLocalHeight() * scaleH + 0.5);
+					}
+					else
+					{
+						newY = parentY + ch->getLocalY();
+						newHeight = ch->getLocalHeight();
+					}
+				}
+				else if (anchorTop && !anchorBottom)
+				{
+					// Top anchored only: keep height constant
+					newHeight = ch->getLocalHeight();
+					newY = parentY + ch->getLocalY();
+				}
+				else if (!anchorTop && anchorBottom)
+				{
+					// Bottom anchored only: keep height and adjust Y relative to bottom
+					newHeight = ch->getLocalHeight();
+					int origBottomDist = origParentH - (ch->getLocalY() + ch->getLocalHeight());
+					newY = parentY + finalH - origBottomDist - newHeight;
+				}
+				else
+				{
+					// No vertical anchor: position relative to parent's top, height constant.
+					newHeight = ch->getLocalHeight();
+					newY = parentY + ch->getLocalY();
+				}
+			}
+			ch->setY(newY);
+			ch->setHeight(newHeight);
+		}
+		// Always forward the window resize event to the child (recursively).
+		ch->onWindowResize();
+	}
 }
 
 void Canvas::requestRepaint(Control* parent)
@@ -384,8 +382,3 @@ void Canvas::requestRepaint(Control* parent)
 	else
 		onRequestRepaintAsRoot();
 }
-
-
-
-
-

src/Control.cpp

@@ -44,9 +44,14 @@ bool StellarX::ControlText::operator!=(const ControlText& text)
 }
 void Control::setIsVisible(bool show)
 {
+	this->show = show;
+	dirty = true;
+
 	if (!show)
 		this->updateBackground();
-	this->show = show;
+	else
+		requestRepaint(parent);
+	
 }
 void Control::onWindowResize()
 {

src/Dialog.cpp

@@ -1,21 +1,19 @@
 #include "Dialog.h"
 
-Dialog::Dialog(Window& h,std::string text,std::string message, StellarX::MessageBoxType type, bool modal)
-	: Canvas(),message(message), type(type), modal(modal), hWnd(h), titleText(text)
+Dialog::Dialog(Window& h, std::string text, std::string message, StellarX::MessageBoxType type, bool modal)
+	: Canvas(), message(message), type(type), modal(modal), hWnd(h), titleText(text)
 {
 	this->id = "Dialog";
 	show = false;
 }
 
-
-
 Dialog::~Dialog()
 {
 }
 
 void Dialog::draw()
 {
-	if(!show)
+	if (!show)
 	{
 		// 如果对话框不可见且需要清理，执行清理
 		if (pendingCleanup && !isCleaning)
@@ -24,16 +22,16 @@ void Dialog::draw()
 		}
 		return;
 	}
-    // 如果需要初始化，则执行初始化
-    if (needsInitialization && show)
-    {
-        initDialogSize();
-        needsInitialization = false;
-    }
+	// 如果需要初始化，则执行初始化
+	if (needsInitialization && show)
+	{
+		initDialogSize();
+		needsInitialization = false;
+	}
 
-    if (dirty && show)
-    {
-        // 保存当前绘图状态
+	if (dirty && show)
+	{
+		// 保存当前绘图状态
 		saveStyle();
 
 		Canvas::setBorderColor(this->borderColor);
@@ -51,24 +49,21 @@ void Dialog::draw()
 			textStyle.nEscapement, textStyle.nOrientation, textStyle.nWeight,
 			textStyle.bItalic, textStyle.bUnderline, textStyle.bStrikeOut);
 
-		
 		int ty = y + closeButtonHeight + titleToTextMargin; // 文本起始Y坐标
-		for (auto& line:lines)
+		for (auto& line : lines)
 		{
 			int tx = this->x + ((this->width - textwidth(line.c_str())) / 2); // 文本起始X坐标
 			outtextxy(tx, ty, LPCTSTR(line.c_str()));
 			ty = ty + textheight(LPCTSTR(line.c_str())) + 5; // 每行文本高度加5像素间距
 		}
 
-        // 恢复绘图状态
-        restoreStyle();
+		// 恢复绘图状态
+		restoreStyle();
 
-        dirty = false;
-    }
+		dirty = false;
+	}
 }
 
-
-
 bool Dialog::handleEvent(const ExMessage& msg)
 {
 	bool consume = false;
@@ -94,8 +89,8 @@ bool Dialog::handleEvent(const ExMessage& msg)
 	}
 
 	// 将事件传递给子控件处理
-	 if (!consume)
-		 consume = Canvas::handleEvent(msg);
+	if (!consume)
+		consume = Canvas::handleEvent(msg);
 
 	// 每次事件处理后检查是否需要执行延迟清理
 	if (pendingCleanup && !isCleaning)
@@ -134,7 +129,6 @@ void Dialog::SetModal(bool modal)
 	this->modal = modal;
 }
 
-
 void Dialog::SetResult(StellarX::MessageBoxResult result)
 {
 	this->result = result;
@@ -238,8 +232,6 @@ void Dialog::Show()
 		dirty = true;
 }
 
-
-
 void Dialog::Close()
 {
 	if (!show) return;
@@ -249,12 +241,9 @@ void Dialog::Close()
 	dirty = true;
 	pendingCleanup = true;  // 只标记需要清理，不立即执行
 
-
 	// 工厂模式下非模态触发回调 返回结果
-	if (resultCallback&& !modal) 
+	if (resultCallback && !modal)
 		resultCallback(this->result);
-	
-	
 }
 
 void Dialog::setInitialization(bool init)
@@ -267,7 +256,6 @@ void Dialog::setInitialization(bool init)
 	}
 }
 
-
 void Dialog::initButtons()
 {
 	controls.clear();
@@ -279,7 +267,7 @@ void Dialog::initButtons()
 		auto okbutton = createDialogButton((this->x + (this->width - (functionButtonWidth * buttonNum + buttonMargin * (buttonNum - 1))) / 2),
 			((this->y + (this->height - buttonAreaHeight)) + (buttonAreaHeight - functionButtonHeight) / 2),
 			"确定"
-			);
+		);
 		okbutton->setOnClickListener([this]()
 			{
 				this->SetResult(StellarX::MessageBoxResult::OK);
@@ -289,30 +277,30 @@ void Dialog::initButtons()
 
 		this->addControl(std::move(okbutton));
 	}
-		break;
+	break;
 	case StellarX::MessageBoxType::OKCancel: // 确定和取消按钮
 	{
 		auto okButton = createDialogButton(
 			(this->x + (this->width - (functionButtonWidth * buttonNum + buttonMargin * (buttonNum - 1))) / 2),
-				((this->y + (this->height - buttonAreaHeight)) + (buttonAreaHeight - functionButtonHeight) / 2),
-				"确定"
-			);
+			((this->y + (this->height - buttonAreaHeight)) + (buttonAreaHeight - functionButtonHeight) / 2),
+			"确定"
+		);
 		okButton->setOnClickListener([this]()
 			{
 				this->SetResult(StellarX::MessageBoxResult::OK);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		auto cancelButton = createDialogButton(
 			(okButton.get()->getX() + okButton.get()->getButtonWidth() + buttonMargin),
-			 okButton.get()->getY(),
+			okButton.get()->getY(),
 			"取消"
 		);
 		cancelButton->setOnClickListener([this]()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Cancel);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		okButton->textStyle = this->textStyle;
 		cancelButton->textStyle = this->textStyle;
@@ -320,7 +308,7 @@ void Dialog::initButtons()
 		this->addControl(std::move(okButton));
 		this->addControl(std::move(cancelButton));
 	}
-		break;
+	break;
 	case StellarX::MessageBoxType::YesNo:  // 是和否按钮
 	{
 		auto yesButton = createDialogButton(
@@ -332,7 +320,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Yes);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		auto noButton = createDialogButton(
 			(yesButton.get()->getX() + yesButton.get()->getButtonWidth() + buttonMargin),
@@ -343,7 +331,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::No);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		yesButton->textStyle = this->textStyle;
 		noButton->textStyle = this->textStyle;
@@ -351,7 +339,7 @@ void Dialog::initButtons()
 		this->addControl(std::move(yesButton));
 		this->addControl(std::move(noButton));
 	}
-		break;
+	break;
 	case StellarX::MessageBoxType::YesNoCancel: // 是、否和取消按钮
 	{
 		auto yesButton = createDialogButton(
@@ -363,7 +351,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Yes);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		auto noButton = createDialogButton(
 			yesButton.get()->getX() + yesButton.get()->getButtonWidth() + buttonMargin,
@@ -374,7 +362,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::No);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		auto cancelButton = createDialogButton(
 			noButton.get()->getX() + noButton.get()->getButtonWidth() + buttonMargin,
@@ -385,18 +373,17 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Cancel);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		yesButton->textStyle = this->textStyle;
 		noButton->textStyle = this->textStyle;
 		cancelButton->textStyle = this->textStyle;
 
-		
 		this->addControl(std::move(yesButton));
 		this->addControl(std::move(noButton));
 		this->addControl(std::move(cancelButton));
 	}
-	    break;
+	break;
 	case StellarX::MessageBoxType::RetryCancel: // 重试和取消按钮
 	{
 		auto retryButton = createDialogButton(
@@ -408,7 +395,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Retry);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		auto cancelButton = createDialogButton(
 			retryButton.get()->getX() + retryButton.get()->getButtonWidth() + buttonMargin,
@@ -419,7 +406,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Cancel);
 				this->hWnd.dialogClose = true;
-				 this->Close(); });
+				this->Close(); });
 
 		retryButton->textStyle = this->textStyle;
 		cancelButton->textStyle = this->textStyle;
@@ -427,11 +414,11 @@ void Dialog::initButtons()
 		this->addControl(std::move(retryButton));
 		this->addControl(std::move(cancelButton));
 	}
-	    break;
+	break;
 	case StellarX::MessageBoxType::AbortRetryIgnore: // 中止、重试和忽略按钮
 	{
 		auto abortButton = createDialogButton(
-			(this->x + (this->width - (functionButtonWidth * buttonNum + buttonMargin* (buttonNum-1))) / 2),
+			(this->x + (this->width - (functionButtonWidth * buttonNum + buttonMargin * (buttonNum - 1))) / 2),
 			((this->y + (this->height - buttonAreaHeight)) + (buttonAreaHeight - functionButtonHeight) / 2),
 			"中止"
 		);
@@ -439,7 +426,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Abort);
 				this->hWnd.dialogClose = true;
-				 this->Close();
+				this->Close();
 			});
 		auto retryButton = createDialogButton(
 			abortButton.get()->getX() + abortButton.get()->getButtonWidth() + buttonMargin,
@@ -450,7 +437,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Retry);
 				this->hWnd.dialogClose = true;
-				 this->Close();
+				this->Close();
 			});
 		auto ignoreButton = createDialogButton(
 			retryButton.get()->getX() + retryButton.get()->getButtonWidth() + buttonMargin,
@@ -461,7 +448,7 @@ void Dialog::initButtons()
 			{
 				this->SetResult(StellarX::MessageBoxResult::Ignore);
 				this->hWnd.dialogClose = true;
-				 this->Close();
+				this->Close();
 			});
 
 		abortButton->textStyle = this->textStyle;
@@ -472,7 +459,7 @@ void Dialog::initButtons()
 		this->addControl(std::move(retryButton));
 		this->addControl(std::move(ignoreButton));
 	}
-		break;
+	break;
 	}
 }
 
@@ -481,7 +468,7 @@ void Dialog::initCloseButton()
 	//初始化关闭按钮
 	auto but = std::make_unique<Button>
 		(
-			(this->x + this->width - closeButtonWidth) - 3, (this->y+3), closeButtonWidth-1, closeButtonHeight,
+			(this->x + this->width - closeButtonWidth) - 3, (this->y + 3), closeButtonWidth - 1, closeButtonHeight,
 			"X",           // 按钮文本
 			RGB(255, 0, 0),      // 按钮被点击颜色
 			this->canvasBkClor, // 按钮背景颜色
@@ -502,7 +489,7 @@ void Dialog::initCloseButton()
 
 void Dialog::initTitle()
 {
-	this->title = std::make_unique<Label>(this->x+5,this->y+5,titleText,textStyle.color);
+	this->title = std::make_unique<Label>(this->x + 5, this->y + 5, titleText, textStyle.color);
 	title->setTextdisap(true);
 	title->textStyle = this->textStyle;
 
@@ -516,7 +503,7 @@ void Dialog::splitMessageLines()
 	std::string currentLine;
 	for (size_t i = 0; i < message.length(); i++) {
 		// 处理 换行符 \r\n  \n  \r
-		if (i + 1 < message.length() && (message[i] == '\r' || message[i] == '\n')||(message[i] == '\r' && message[i+1] == '\n'))
+		if (i + 1 < message.length() && (message[i] == '\r' || message[i] == '\n') || (message[i] == '\r' && message[i + 1] == '\n'))
 		{
 			if (!currentLine.empty()) {
 				lines.push_back(currentLine);
@@ -587,10 +574,10 @@ void Dialog::initDialogSize()
 
 	// 计算按钮区域宽度
 	int buttonAreaWidth = buttonNum * functionButtonWidth +
-		(buttonNum > 0 ? (buttonNum +1) * buttonMargin : 0);
+		(buttonNum > 0 ? (buttonNum + 1) * buttonMargin : 0);
 
 	// 计算文本区域宽度（包括边距）
-	int textAreaWidth = textWidth + textToBorderMargin * 2 ;
+	int textAreaWidth = textWidth + textToBorderMargin * 2;
 
 	// 对话框宽度取两者中的较大值，并确保最小宽度
 	this->width = buttonAreaWidth > textAreaWidth ? buttonAreaWidth : textAreaWidth;
@@ -598,7 +585,7 @@ void Dialog::initDialogSize()
 
 	// 计算对话框高度
 	// 高度 = 标题栏高度 + 文本区域高度 + 按钮区域高度 + 间距
-	int textAreaHeight = textHeight * (int)lines.size() + 5*((int)lines.size()-1); // 文本行高+行间距
+	int textAreaHeight = textHeight * (int)lines.size() + 5 * ((int)lines.size() - 1); // 文本行高+行间距
 	this->height = closeButtonHeight +        // 标题栏高度
 		titleToTextMargin +        // 标题到文本的间距
 		textAreaHeight +           // 文本区域高度
@@ -717,7 +704,6 @@ void Dialog::requestRepaint(Control* parent)
 		for (auto& control : controls)
 			if (control->isDirty() && control->IsVisible())
 				control->draw();
-
 	}
 	else
 		onRequestRepaintAsRoot();

src/MessageBox.cpp

@@ -2,7 +2,7 @@
 
 namespace StellarX
 {
-	MessageBoxResult MessageBox::showModal(Window& wnd,const std::string& text,const std::string& caption,
+	MessageBoxResult MessageBox::showModal(Window& wnd, const std::string& text, const std::string& caption,
 		MessageBoxType type)
 	{
 		Dialog dlg(wnd, caption, text, type, true); // 模态
@@ -11,7 +11,7 @@ namespace StellarX
 		return dlg.GetResult();
 	}
 
-	void MessageBox::showAsync(Window& wnd,const std::string& text,const std::string& caption,MessageBoxType type,
+	void MessageBox::showAsync(Window& wnd, const std::string& text, const std::string& caption, MessageBoxType type,
 		std::function<void(MessageBoxResult)> onResult)
 	{
 		//去重，如果窗口内已有相同的对话框被触发，则不再创建

src/TabControl.cpp

@@ -33,7 +33,7 @@ inline void TabControl::initTabBar()
 		for (auto& c : controls)
 		{
 			c.first->setX(this->x + i * butW);
-			c.first->setY(this->y+this->height - tabBarHeight);
+			c.first->setY(this->y + this->height - tabBarHeight);
 			i++;
 		}
 		break;
@@ -41,18 +41,18 @@ inline void TabControl::initTabBar()
 		for (auto& c : controls)
 		{
 			c.first->setX(this->x);
-			c.first->setY(this->y+i* butH);
+			c.first->setY(this->y + i * butH);
 			i++;
 		}
 		break;
 	case StellarX::TabPlacement::Right:
 		for (auto& c : controls)
 		{
-			c.first->setX(this->x+this->width - tabBarHeight);
+			c.first->setX(this->x + this->width - tabBarHeight);
 			c.first->setY(this->y + i * butH);
 			i++;
 		}
-			break;
+		break;
 	default:
 		break;
 	}
@@ -147,7 +147,7 @@ inline void TabControl::initTabPage()
 	}
 }
 
-TabControl::TabControl():Canvas()
+TabControl::TabControl() :Canvas()
 {
 	this->id = "TabControl";
 }
@@ -173,7 +173,6 @@ void TabControl::setX(int x)
 		c.first->onWindowResize();
 		c.second->onWindowResize();
 	}
-
 }
 
 void TabControl::setY(int y)
@@ -192,28 +191,8 @@ void TabControl::setY(int y)
 void TabControl::draw()
 {
 	if (!dirty || !show)return;
- //   // 在绘制 TabControl 之前，先恢复并更新背景快照：
-	//int margin = canvaslinewidth > 1 ? canvaslinewidth : 1;
-	//if (hasSnap)
-	//{
-	//	// 恢复旧快照，清除上一次绘制
-	//	restBackground();
-	//	// 如果位置或尺寸变了，或没有有效缓存，则重新抓取
-	//	if (!saveBkImage || saveBkX != this->x - margin || saveBkY != this->y - margin || saveWidth != this->width + margin * 2 || saveHeight != this->height + margin * 2)
-	//	{
-	//		discardBackground();
-	//		saveBackground(this->x - margin, this->y - margin, this->width + margin * 2, this->height + margin * 2);
-	//	}
-	//}
-	//else
-	//{
-	//	// 首次绘制或没有快照时直接抓取背景
-	//	saveBackground(this->x - margin, this->y - margin, this->width + margin * 2, this->height + margin * 2);
-	//}
- //   // 再次恢复最新背景，保证绘制区域干净
- //   restBackground();
-    // 绘制画布背景和基本形状及其子画布控件
-    Canvas::draw();
+	   // 绘制画布背景和基本形状及其子画布控件
+	Canvas::draw();
 	for (auto& c : controls)
 	{
 		c.first->setDirty(true);
@@ -224,8 +203,17 @@ void TabControl::draw()
 		c.second->setDirty(true);
 		c.second->draw();
 	}
-	dirty = false;
 
+	// 首次绘制时处理默认激活页签
+	if (IsFirstDraw)
+	{
+		if (defaultActivation >= 0 && defaultActivation < (int)controls.size())
+			controls[defaultActivation].first->setButtonClick(true);
+		else if (defaultActivation >= (int)controls.size())//索引越界则激活最后一个
+			controls[controls.size() - 1].first->setButtonClick(true);
+		IsFirstDraw = false;//避免重复处理
+	}
+	dirty = false;
 }
 
 bool TabControl::handleEvent(const ExMessage& msg)
@@ -239,7 +227,7 @@ bool TabControl::handleEvent(const ExMessage& msg)
 			break;
 		}
 	for (auto& c : controls)
-		if(c.second->IsVisible())
+		if (c.second->IsVisible())
 			if (c.second->handleEvent(msg))
 			{
 				consume = true;
@@ -260,7 +248,7 @@ void TabControl::add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>
 	controls[idx].first->enableTooltip(true);
 	controls[idx].first->setbuttonMode(StellarX::ButtonMode::TOGGLE);
 
-	controls[idx].first->setOnToggleOnListener([this,idx]()
+	controls[idx].first->setOnToggleOnListener([this, idx]()
 		{
 			controls[idx].second->setIsVisible(true);
 			controls[idx].second->onWindowResize();
@@ -274,7 +262,7 @@ void TabControl::add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>
 			}
 			dirty = true;
 		});
-	controls[idx].first->setOnToggleOffListener([this,idx]()
+	controls[idx].first->setOnToggleOffListener([this, idx]()
 		{
 			controls[idx].second->setIsVisible(false);
 
@@ -293,12 +281,11 @@ void TabControl::add(std::string tabText, std::unique_ptr<Control> control)
 		if (tab.first->getButtonText() == tabText)
 		{
 			control->setParent(tab.second.get());
-			control->setIsVisible( tab.second->IsVisible());
+			control->setIsVisible(tab.second->IsVisible());
 			tab.second->addControl(std::move(control));
 			break;
 		}
 	}
-
 }
 
 void TabControl::setTabPlacement(StellarX::TabPlacement placement)
@@ -307,7 +294,6 @@ void TabControl::setTabPlacement(StellarX::TabPlacement placement)
 	setDirty(true);
 	initTabBar();
 	initTabPage();
-
 }
 
 void TabControl::setTabBarHeight(int height)
@@ -321,33 +307,42 @@ void TabControl::setTabBarHeight(int height)
 void TabControl::setIsVisible(bool visible)
 {
 	// 先让基类 Canvas 处理自己的回贴/丢快照逻辑
-	Canvas::setIsVisible(visible);   // <--- 新增
-
-	this->show = visible;
+	Canvas::setIsVisible(visible);
 	for (auto& tab : controls)
 	{
-		tab.first->setIsVisible(visible);
-		//页也要跟着关/开，否则它们会保留旧的 saveBkImage
-		tab.second->setIsVisible(visible);  
-		tab.second->setDirty(true);
+		if(true == visible)
+		{
+			tab.first->setIsVisible(visible);
+			//页也要跟着关/开，否则它们会保留旧的 saveBkImage
+			if (tab.first->isClicked())
+				tab.second->setIsVisible(true);
+			else
+				tab.second->setIsVisible(false);
+			tab.second->setDirty(true);
+		}
+		else
+		{
+			tab.first->setIsVisible(visible);
+			tab.second->setIsVisible(visible);
+		}
 	}
 }
 
 void TabControl::onWindowResize()
 {
-    // 调用基类的窗口变化处理，丢弃快照并标记脏
-    Control::onWindowResize();
-    // 根据当前 TabControl 的新尺寸重新计算页签栏和页面区域
-    initTabBar();
-    initTabPage();
-    // 转发窗口尺寸变化给所有页签按钮和页面
-    for (auto& c : controls)
-    {
-        c.first->onWindowResize();
-        c.second->onWindowResize();
-    }
-    // 尺寸变化后需要重绘自身
-    dirty = true;
+	// 调用基类的窗口变化处理，丢弃快照并标记脏
+	Control::onWindowResize();
+	// 根据当前 TabControl 的新尺寸重新计算页签栏和页面区域
+	initTabBar();
+	initTabPage();
+	// 转发窗口尺寸变化给所有页签按钮和页面
+	for (auto& c : controls)
+	{
+		c.first->onWindowResize();
+		c.second->onWindowResize();
+	}
+	// 尺寸变化后需要重绘自身
+	dirty = true;
 }
 
 int TabControl::getActiveIndex() const
@@ -364,20 +359,13 @@ int TabControl::getActiveIndex() const
 
 void TabControl::setActiveIndex(int idx)
 {
-	if (idx < 0 || idx > controls.size() - 1) return;
-	if (controls[idx].first->getButtonMode() == StellarX::ButtonMode::DISABLED)return;
-	if (controls[idx].first->isClicked())
-	{
-		if (controls[idx].second->IsVisible())
-			return;
-		else
-			controls[idx].second->setIsVisible(true);
-	}
+	if (IsFirstDraw)
+		defaultActivation = idx;
 	else
 	{
-		controls[idx].first->setButtonClick(true);
+		if (idx >= 0 && idx < controls.size())
+			controls[idx].first->setButtonClick(true);
 	}
-
 }
 
 int TabControl::count() const
@@ -388,7 +376,7 @@ int TabControl::count() const
 int TabControl::indexOf(const std::string& tabText) const
 {
 	int idx = -1;
-	for(auto& c : controls)
+	for (auto& c : controls)
 	{
 		idx++;
 		if (c.first->getButtonText() == tabText)
@@ -416,7 +404,7 @@ void TabControl::requestRepaint(Control* parent)
 		{
 			if (control.first->isDirty() && control.first->IsVisible())
 				control.first->draw();
-			else if (control.second->isDirty()&&control.second->IsVisible())
+			else if (control.second->isDirty() && control.second->IsVisible())
 				control.second->draw();
 		}
 	}

src/label.cpp

@@ -5,7 +5,7 @@ Label::Label()
 {
 	this->id = "Label";
 	this->text = "默认标签";
-	textStyle.color = RGB(0,0,0);
+	textStyle.color = RGB(0, 0, 0);
 	textBkColor = RGB(255, 255, 255);; //默认白色背景
 }
 
@@ -40,7 +40,7 @@ void Label::draw()
 			this->height = textheight(text.c_str());
 		}
 		if ((saveBkX != this->x) || (saveBkY != this->y) || (!hasSnap) || (saveWidth != this->width) || (saveHeight != this->height) || !saveBkImage)
-			saveBackground(this->x, this->y,this->width,this->height);
+			saveBackground(this->x, this->y, this->width, this->height);
 		// 恢复背景（清除旧内容）
 		restBackground();
 		outtextxy(x, y, LPCTSTR(text.c_str()));
@@ -71,5 +71,4 @@ void Label::setText(std::string text)
 {
 	this->text = text;
 	this->dirty = true;
-	
 }

src/table.cpp

@@ -26,12 +26,10 @@ void Table::drawTable()
 		dY = uY;
 		uY = dY + lineHeights.at(0) + TABLE_ROW_EXTRA;
 	}
-
 }
 
 void Table::drawHeader()
 {
-	
 	const int border = tableBorderWidth > 0 ? tableBorderWidth : 0;
 	// 内容区原点 = x+border, y+border
 	dX = x + border;
@@ -87,35 +85,35 @@ void Table::initTextWaH()
 		if (h > maxLineH)
 			maxLineH = h;
 
-    // 列宽包含左右 padding：在计算完最大文本宽度后，加上 2*padX 作为单元格内边距
-    for (size_t j = 0; j < colWidths.size(); ++j) {
-        colWidths[j] += 2 * padX;
-    }
+	// 列宽包含左右 padding：在计算完最大文本宽度后，加上 2*padX 作为单元格内边距
+	for (size_t j = 0; j < colWidths.size(); ++j) {
+		colWidths[j] += 2 * padX;
+	}
 
-    // 表内容总宽 = Σ(列宽 + 列间距)
-    int contentW = 0;
-    for (size_t j = 0; j < colWidths.size(); ++j)
-        contentW += colWidths[j] + colGap;
+	// 表内容总宽 = Σ(列宽 + 列间距)
+	int contentW = 0;
+	for (size_t j = 0; j < colWidths.size(); ++j)
+		contentW += colWidths[j] + colGap;
 
-    // 表头高 & 行高（与 drawHeader/drawTable 内部一致：+上下 padding）
-    const int headerH = maxLineH + 2 * padY;
-    const int rowH    = maxLineH + 2 * padY;
-    const int rowsH   = rowH * rowsPerPage;
+	// 表头高 & 行高（与 drawHeader/drawTable 内部一致：+上下 padding）
+	const int headerH = maxLineH + 2 * padY;
+	const int rowH = maxLineH + 2 * padY;
+	const int rowsH = rowH * rowsPerPage;
 
-    // 页脚：
-    const int pageTextH = textheight(LPCTSTR(pageNumtext.c_str()));
-    const int btnTextH  = textheight(LPCTSTR("上一页"));
-    const int btnPadV   = TABLE_BTN_TEXT_PAD_V;
-    const int btnH      = btnTextH + 2 * btnPadV;
-    const int footerPad = TABLE_FOOTER_PAD;
-    const int footerH   = (pageTextH > btnH ? pageTextH : btnH) + footerPad;
+	// 页脚：
+	const int pageTextH = textheight(LPCTSTR(pageNumtext.c_str()));
+	const int btnTextH = textheight(LPCTSTR("上一页"));
+	const int btnPadV = TABLE_BTN_TEXT_PAD_V;
+	const int btnH = btnTextH + 2 * btnPadV;
+	const int footerPad = TABLE_FOOTER_PAD;
+	const int footerH = (pageTextH > btnH ? pageTextH : btnH) + footerPad;
 
-    // 最终表宽/高：内容 + 对称边框
-    this->width  = contentW + (border << 1);
-    this->height = headerH + rowsH + footerH + (border << 1);
-    // 记录原始宽高用于锚点布局的参考；此处仅在初始化单元尺寸时重置
-    this->localWidth  = this->width;
-    this->localHeight = this->height;
+	// 最终表宽/高：内容 + 对称边框
+	this->width = contentW + (border << 1);
+	this->height = headerH + rowsH + footerH + (border << 1);
+	// 记录原始宽高用于锚点布局的参考；此处仅在初始化单元尺寸时重置
+	this->localWidth = this->width;
+	this->localHeight = this->height;
 }
 
 void Table::initButton()
@@ -132,7 +130,6 @@ void Table::initButton()
 	int nextW = textwidth(LPCTSTR(TABLE_STR_NEXT)) + padH * 2;
 	int btnH = lblH + padV * 2;
 
-
 	// 基于“页码标签”的矩形来摆放：
 	// prev 在页码左侧 gap 处；next 在右侧 gap 处；Y 对齐 pY
 	int prevX = pX - gap - prevW;
@@ -162,21 +159,21 @@ void Table::initButton()
 
 	prevButton->setOnClickListener([this]()
 		{
-		if (currentPage > 1) 
-		{
-			--currentPage;
-			dirty = true;
-			if (pageNum) pageNum->setDirty(true);
-		}
+			if (currentPage > 1)
+			{
+				--currentPage;
+				dirty = true;
+				if (pageNum) pageNum->setDirty(true);
+			}
 		});
 	nextButton->setOnClickListener([this]()
 		{
-		if (currentPage < totalPages) 
-		{
-			++currentPage;
-			dirty = true;
-			if (pageNum) pageNum->setDirty(true);
-		}
+			if (currentPage < totalPages)
+			{
+				++currentPage;
+				dirty = true;
+				if (pageNum) pageNum->setDirty(true);
+			}
 		});
 	isNeedButtonAndPageNum = false;
 }
@@ -199,7 +196,7 @@ void Table::initPageNum()
 	// 按理来说 x + (this->width - textW) / 2;就可以
 	// 但是在绘制时，发现控件偏右，因此减去40
 	int textW = textwidth(LPCTSTR(pageNumtext.c_str()));
-	pX = x + TABLE_PAGE_TEXT_OFFSET_X +(this->width - textW) / 2;
+	pX = x + TABLE_PAGE_TEXT_OFFSET_X + (this->width - textW) / 2;
 
 	if (!pageNum)
 		pageNum = new Label(pX, pY, pageNumtext);
@@ -216,9 +213,8 @@ void Table::initPageNum()
 
 void Table::drawPageNum()
 {
-	
 	pageNumtext = "第";
-	pageNumtext+= std::to_string(currentPage);
+	pageNumtext += std::to_string(currentPage);
 	pageNumtext += "页/共";
 	pageNumtext += std::to_string(totalPages);
 	pageNumtext += "页";
@@ -229,12 +225,11 @@ void Table::drawPageNum()
 	if (StellarX::FillMode::Null == tableFillMode)
 		pageNum->setTextdisap(true);
 	pageNum->draw();
-	
 }
 
 void Table::drawButton()
 {
-	if ((nullptr == prevButton || nullptr == nextButton)|| isNeedButtonAndPageNum)
+	if ((nullptr == prevButton || nullptr == nextButton) || isNeedButtonAndPageNum)
 		initButton();
 
 	this->prevButton->textStyle = this->textStyle;
@@ -247,7 +242,6 @@ void Table::drawButton()
 	this->nextButton->setDirty(true);
 	prevButton->draw();
 	nextButton->draw();
-
 }
 
 void Table::setX(int x)
@@ -266,35 +260,36 @@ void Table::setY(int y)
 
 void Table::setWidth(int width)
 {
-    // 调整列宽以匹配新的表格总宽度。不修改 localWidth，避免累计误差。
-    // 当 width 与当前 width 不同时，根据差值平均分配到各列，余数依次累加/扣减。
-    const int ncols = static_cast<int>(colWidths.size());
-    if (ncols <= 0) {
-        this->width = width;
-        isNeedButtonAndPageNum = true;
-        return;
-    }
-    int diff = width - this->width;
-    // 基础增量：整除部分
-    int baseChange = diff / ncols;
-    int remainder  = diff % ncols;
-    for (int i = 0; i < ncols; ++i) {
-        int change = baseChange;
-        if (remainder > 0) {
-            change += 1;
-            remainder -= 1;
-        } else if (remainder < 0) {
-            change -= 1;
-            remainder += 1;
-        }
-        int newWidth = colWidths[i] + change;
-        // 限制最小宽度为 1，防止出现负值
-        if (newWidth < 1) newWidth = 1;
-        colWidths[i] = newWidth;
-    }
-    this->width = width;
-    // 需要重新布局页脚元素
-    isNeedButtonAndPageNum = true;
+	// 调整列宽以匹配新的表格总宽度。不修改 localWidth，避免累计误差。
+	// 当 width 与当前 width 不同时，根据差值平均分配到各列，余数依次累加/扣减。
+	const int ncols = static_cast<int>(colWidths.size());
+	if (ncols <= 0) {
+		this->width = width;
+		isNeedButtonAndPageNum = true;
+		return;
+	}
+	int diff = width - this->width;
+	// 基础增量：整除部分
+	int baseChange = diff / ncols;
+	int remainder = diff % ncols;
+	for (int i = 0; i < ncols; ++i) {
+		int change = baseChange;
+		if (remainder > 0) {
+			change += 1;
+			remainder -= 1;
+		}
+		else if (remainder < 0) {
+			change -= 1;
+			remainder += 1;
+		}
+		int newWidth = colWidths[i] + change;
+		// 限制最小宽度为 1，防止出现负值
+		if (newWidth < 1) newWidth = 1;
+		colWidths[i] = newWidth;
+	}
+	this->width = width;
+	// 需要重新布局页脚元素
+	isNeedButtonAndPageNum = true;
 }
 
 void Table::setHeight(int height)
@@ -377,32 +372,35 @@ void Table::draw()
 			setfillstyle((int)tableFillMode);
 			setbkmode(TRANSPARENT);
 		}
-        // 在绘制前先恢复并更新背景快照：
-        // 如果已有快照且尺寸发生变化，先恢复旧快照以清除上一次绘制，然后丢弃旧快照再重新抓取新的区域。
-        if (hasSnap)
-        {
-            // 始终先恢复旧背景，清除上一帧内容
-            restBackground();
-            // 当尺寸变化或缓存图像无效时，需要重新截图
-            if (!saveBkImage || saveWidth != this->width || saveHeight != this->height)
-            {
-                discardBackground();
-                saveBackground(this->x, this->y, this->width, this->height);
-            }
-        }
-        else
-        {
-            // 首次绘制时无背景缓存，直接抓取
-            saveBackground(this->x, this->y, this->width, this->height);
-        }
-        // 恢复最新的背景，保证绘制区域干净
-        restBackground();
-        // 绘制表头
+		// 在绘制前先恢复并更新背景快照：
+		// 如果已有快照且尺寸发生变化，先恢复旧快照以清除上一次绘制，然后丢弃旧快照再重新抓取新的区域。
+		if (hasSnap)
+		{
+			// 始终先恢复旧背景，清除上一帧内容
+			restBackground();
+			// 当尺寸变化或缓存图像无效时，需要重新截图
+			if (!saveBkImage || saveWidth != this->width || saveHeight != this->height)
+			{
+				discardBackground();
+				saveBackground(this->x, this->y, this->width, this->height);
+			}
+		}
+		else
+		{
+			// 首次绘制时无背景缓存，直接抓取
+			saveBackground(this->x, this->y, this->width, this->height);
+		}
+		// 恢复最新的背景，保证绘制区域干净
+		restBackground();
+		// 绘制表头
 
-		dX = x;
-		dY = y;
-		drawHeader();
-		this->isNeedDrawHeaders = false;
+		//dX = x;
+		//dY = y;
+		if(isNeedDrawHeaders)
+		{
+			drawHeader();
+			this->isNeedDrawHeaders = false;
+		}
 		// 绘制当前页
 		drawTable();
 		// 绘制页码标签
@@ -412,7 +410,6 @@ void Table::draw()
 		if (this->isShowPageButton)
 			drawButton();
 
-
 		// 恢复绘图状态
 		restoreStyle();
 		dirty = false; // 标记不需要重绘
@@ -421,14 +418,14 @@ void Table::draw()
 
 bool Table::handleEvent(const ExMessage& msg)
 {
-	if(!show)return false;
+	if (!show)return false;
 	bool consume = false;
-	if(!this->isShowPageButton)
+	if (!this->isShowPageButton)
 		return consume;
 	else
 	{
-		if(prevButton)consume = prevButton->handleEvent(msg);
-		if (nextButton&&!consume)
+		if (prevButton)consume = prevButton->handleEvent(msg);
+		if (nextButton && !consume)
 			consume = nextButton->handleEvent(msg);
 	}
 	if (dirty)
@@ -446,7 +443,7 @@ void Table::setHeaders(std::initializer_list<std::string> headers)
 	dirty = true;
 }
 
-void Table::setData( std::vector<std::string> data)
+void Table::setData(std::vector<std::string> data)
 {
 	if (data.size() < headers.size())
 		for (int i = 0; data.size() <= headers.size(); i++)
@@ -459,12 +456,12 @@ void Table::setData( std::vector<std::string> data)
 	dirty = true;
 }
 
-void Table::setData( std::initializer_list<std::vector<std::string>> data)
+void Table::setData(std::initializer_list<std::vector<std::string>> data)
 {
 	for (auto lis : data)
 		if (lis.size() < headers.size())
 		{
-			for (size_t i = lis.size(); i< headers.size(); i++)
+			for (size_t i = lis.size(); i < headers.size(); i++)
 				lis.push_back("");
 			this->data.push_back(lis);
 		}
@@ -538,6 +535,31 @@ void Table::setTableBorderWidth(int width)
 	this->dirty = true;
 }
 
+void Table::clearHeaders()
+{
+	this->headers.clear();
+	isNeedCellSize = true; // 标记需要重新计算单元格尺寸
+	isNeedDrawHeaders = true; // 标记需要重新绘制表头
+	isNeedButtonAndPageNum = true;// 标记需要重新计算翻页按钮和页码信息
+	dirty = true;
+}
+
+void Table::clearData()
+{
+	this->data.clear();
+	this->currentPage = 1;
+	this->totalPages = 1;
+	isNeedCellSize = true; // 标记需要重新计算单元格尺寸
+	isNeedButtonAndPageNum = true;// 标记需要重新计算翻页按钮和页码信息
+	dirty = true;
+}
+
+void Table::resetTable()
+{
+	clearHeaders();
+	clearData();
+}
+
 void Table::onWindowResize()
 {
 	Control::onWindowResize();          // 先处理自己
@@ -616,5 +638,3 @@ int Table::getTableHeight() const
 {
 	return 0;
 }
-
-

src/textBox.cpp

@@ -1,165 +1,188 @@
 // TextBox.cpp
 #include "TextBox.h"
 
-
 TextBox::TextBox(int x, int y, int width, int height, std::string text, StellarX::TextBoxmode mode, StellarX::ControlShape shape)
-	:Control(x,y,width,height),text(text), mode(mode), shape(shape)
+	:Control(x, y, width, height), text(text), mode(mode), shape(shape)
 {
-    this->id = "TextBox";
+	this->id = "TextBox";
 }
 
 void TextBox::draw()
 {
-    if (dirty && show)
-    {
-        saveStyle();
-        setfillcolor(textBoxBkClor);
-        setlinecolor(textBoxBorderClor);
-        if (textStyle.nHeight > height)
-            textStyle.nHeight = height;
-        if (textStyle.nWidth > width)
-            textStyle.nWidth = width;
-        settextstyle(textStyle.nHeight, textStyle.nWidth, textStyle.lpszFace,
-            textStyle.nEscapement, textStyle.nOrientation, textStyle.nWeight,
-            textStyle.bItalic, textStyle.bUnderline, textStyle.bStrikeOut);
+	if (dirty && show)
+	{
+		saveStyle();
+		setfillcolor(textBoxBkClor);
+		setlinecolor(textBoxBorderClor);
+		if (textStyle.nHeight > height)
+			textStyle.nHeight = height;
+		if (textStyle.nWidth > width)
+			textStyle.nWidth = width;
+		settextstyle(textStyle.nHeight, textStyle.nWidth, textStyle.lpszFace,
+			textStyle.nEscapement, textStyle.nOrientation, textStyle.nWeight,
+			textStyle.bItalic, textStyle.bUnderline, textStyle.bStrikeOut);
 
-        settextcolor(textStyle.color);
-        setbkmode(TRANSPARENT);
-        int text_width = textwidth(LPCTSTR(text.c_str()));
-        int text_height = textheight(LPCTSTR(text.c_str()));
+		settextcolor(textStyle.color);
+		setbkmode(TRANSPARENT);
 		
-        if ((saveBkX != this->x) || (saveBkY != this->y) || (!hasSnap) || (saveWidth != this->width) || (saveHeight != this->height) || !saveBkImage)
-            saveBackground(this->x, this->y, this->width, this->height);
-        // 恢复背景（清除旧内容）
-        restBackground();
-        //根据形状绘制
-        switch (shape)
-        {
-        case StellarX::ControlShape::RECTANGLE:
-            fillrectangle(x,y,x+width,y+height);//有边框填充矩形
-            outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
-            break;
-        case StellarX::ControlShape::B_RECTANGLE:
-            solidrectangle(x, y, x + width, y + height);//无边框填充矩形
-            outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
-            break;
-        case StellarX::ControlShape::ROUND_RECTANGLE:
-            fillroundrect(x, y, x + width, y + height, rouRectangleSize.ROUND_RECTANGLEwidth, rouRectangleSize.ROUND_RECTANGLEheight);//有边框填充圆角矩形
-            outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
-            break;
-        case StellarX::ControlShape::B_ROUND_RECTANGLE:
-            solidroundrect(x, y, x + width, y + height, rouRectangleSize.ROUND_RECTANGLEwidth, rouRectangleSize.ROUND_RECTANGLEheight);//无边框填充圆角矩形
-            outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
-            break;
-        }
+		int text_width = 0;
+		int text_height = 0;
+		std::string pwdText;
+		if (StellarX::TextBoxmode::PASSWORD_MODE == mode)
+		{
+			for (size_t i = 0; i < text.size(); ++i)
+				pwdText += '*';
+			text_width = textwidth(LPCTSTR(pwdText.c_str()));
+			text_height = textheight(LPCTSTR(pwdText.c_str()));
+		}
+		else
+		{
+			text_width = textwidth(LPCTSTR(text.c_str()));
+			text_height = textheight(LPCTSTR(text.c_str()));
+		}
+
+		if ((saveBkX != this->x) || (saveBkY != this->y) || (!hasSnap) || (saveWidth != this->width) || (saveHeight != this->height) || !saveBkImage)
+			saveBackground(this->x, this->y, this->width, this->height);
+		// 恢复背景（清除旧内容）
+		restBackground();
+		//根据形状绘制
+		switch (shape)
+		{
+		case StellarX::ControlShape::RECTANGLE:
+			fillrectangle(x, y, x + width, y + height);//有边框填充矩形
+			StellarX::TextBoxmode::PASSWORD_MODE == mode ? outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(pwdText.c_str()))
+				: outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
+			break;
+		case StellarX::ControlShape::B_RECTANGLE:
+			solidrectangle(x, y, x + width, y + height);//无边框填充矩形
+			StellarX::TextBoxmode::PASSWORD_MODE == mode ? outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(pwdText.c_str()))
+			: outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
+			break;
+		case StellarX::ControlShape::ROUND_RECTANGLE:
+			fillroundrect(x, y, x + width, y + height, rouRectangleSize.ROUND_RECTANGLEwidth, rouRectangleSize.ROUND_RECTANGLEheight);//有边框填充圆角矩形
+			StellarX::TextBoxmode::PASSWORD_MODE == mode ? outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(pwdText.c_str()))
+			:outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
+			break;
+		case StellarX::ControlShape::B_ROUND_RECTANGLE:
+			solidroundrect(x, y, x + width, y + height, rouRectangleSize.ROUND_RECTANGLEwidth, rouRectangleSize.ROUND_RECTANGLEheight);//无边框填充圆角矩形
+			StellarX::TextBoxmode::PASSWORD_MODE == mode ? outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(pwdText.c_str()))
+			:outtextxy(x + 10, (y + (height - text_height) / 2), LPCTSTR(text.c_str()));
+			break;
+		}
 		restoreStyle();
 		dirty = false;     //标记不需要重绘
-    }
-    
+	}
 }
 
 bool TextBox::handleEvent(const ExMessage& msg)
 {
-    bool hover = false;
-    bool oldClick = click;
-    bool consume = false;
+	bool hover = false;
+	bool oldClick = click;
+	bool consume = false;
 
-    switch (shape)
-    {
-    case StellarX::ControlShape::RECTANGLE:
-    case StellarX::ControlShape::B_RECTANGLE:
-    case StellarX::ControlShape::ROUND_RECTANGLE:
-    case StellarX::ControlShape::B_ROUND_RECTANGLE:
-        hover = (msg.x > x && msg.x < (x + width) && msg.y > y && msg.y < (y + height));//判断鼠标是否在矩形按钮内
-        consume = false;
-        break;
-    }
-    if (hover && msg.message == WM_LBUTTONUP)
-    {
-        click = true;
-        if(StellarX::TextBoxmode::INPUT_MODE == mode)
+	switch (shape)
+	{
+	case StellarX::ControlShape::RECTANGLE:
+	case StellarX::ControlShape::B_RECTANGLE:
+	case StellarX::ControlShape::ROUND_RECTANGLE:
+	case StellarX::ControlShape::B_ROUND_RECTANGLE:
+		hover = (msg.x > x && msg.x < (x + width) && msg.y > y && msg.y < (y + height));//判断鼠标是否在矩形按钮内
+		consume = false;
+		break;
+	}
+	if (hover && msg.message == WM_LBUTTONUP)
+	{
+		click = true;
+		if (StellarX::TextBoxmode::INPUT_MODE == mode)
 		{
 			char* temp = new char[maxCharLen + 1];
-			dirty = InputBox(temp, (int)maxCharLen, "输入框", NULL, text.c_str(), NULL, NULL, false);
-            if(dirty)text = temp;
+			dirty = InputBox(temp, (int)maxCharLen+1, "输入框", NULL, text.c_str(), NULL, NULL, false);
+			if (dirty)text = temp;
 			delete[] temp;
 			temp = nullptr;
-            consume = true;
+			consume = true;
 		}
-        else if (StellarX::TextBoxmode::READONLY_MODE == mode)
-        {
-            dirty = false;
-            InputBox(NULL, (int)maxCharLen, "输出框（输入无效！）", NULL, text.c_str(), NULL, NULL, false);
-            consume = true;
-        }
-        flushmessage(EX_MOUSE | EX_KEY);
-    }
-    if (dirty)
-        requestRepaint(parent);
+		else if (StellarX::TextBoxmode::READONLY_MODE == mode)
+		{
+			dirty = false;
+			InputBox(NULL, (int)maxCharLen, "输出框（输入无效！）", NULL, text.c_str(), NULL, NULL, false);
+			consume = true;
+		}
+		else if (StellarX::TextBoxmode::PASSWORD_MODE == mode)
+		{
+			char* temp = new char[maxCharLen + 1];
+			dirty = InputBox(temp, (int)maxCharLen+1, "输入框\n不可见输入，覆盖即可", NULL, NULL, NULL, NULL, false);
+			if (dirty)text = temp;
+			delete[] temp;
+			temp = nullptr;
+			consume = true;
+		}
+		flushmessage(EX_MOUSE | EX_KEY);
+	}
+	if (dirty)
+		requestRepaint(parent);
 
-    if (click)
-        click = false;
-    return consume;
+	if (click)
+		click = false;
+	return consume;
 }
 
 void TextBox::setMode(StellarX::TextBoxmode mode)
 {
-    this->mode = mode;
-    this->dirty = true;
+	this->mode = mode;
+	this->dirty = true;
 }
 
 void TextBox::setMaxCharLen(size_t len)
 {
-    if (len > 0)
-        maxCharLen = len;
-    this->dirty = true;
+	if (len > 0)
+		maxCharLen = len;
+	this->dirty = true;
 }
 
 void TextBox::setTextBoxshape(StellarX::ControlShape shape)
 {
-    switch (shape)
-    {
-    case StellarX::ControlShape::RECTANGLE:
-    case StellarX::ControlShape::B_RECTANGLE:
-    case StellarX::ControlShape::ROUND_RECTANGLE:
-    case StellarX::ControlShape::B_ROUND_RECTANGLE:
-        this->shape = shape;
-        this->dirty = true;
-        break;
+	switch (shape)
+	{
+	case StellarX::ControlShape::RECTANGLE:
+	case StellarX::ControlShape::B_RECTANGLE:
+	case StellarX::ControlShape::ROUND_RECTANGLE:
+	case StellarX::ControlShape::B_ROUND_RECTANGLE:
+		this->shape = shape;
+		this->dirty = true;
+		break;
 	case StellarX::ControlShape::CIRCLE:
-    case StellarX::ControlShape::B_CIRCLE:
-    case StellarX::ControlShape::ELLIPSE:
-    case StellarX::ControlShape::B_ELLIPSE:
-        this->shape = StellarX::ControlShape::RECTANGLE;
-        this->dirty = true;
-        break;
-    }
+	case StellarX::ControlShape::B_CIRCLE:
+	case StellarX::ControlShape::ELLIPSE:
+	case StellarX::ControlShape::B_ELLIPSE:
+		this->shape = StellarX::ControlShape::RECTANGLE;
+		this->dirty = true;
+		break;
+	}
 }
 
 void TextBox::setTextBoxBorder(COLORREF color)
 {
-    textBoxBorderClor = color;
-    this->dirty = true;
+	textBoxBorderClor = color;
+	this->dirty = true;
 }
 
 void TextBox::setTextBoxBk(COLORREF color)
 {
-    textBoxBkClor = color;
-    this->dirty = true;
+	textBoxBkClor = color;
+	this->dirty = true;
 }
 
 void TextBox::setText(std::string text)
 {
-    if(text.size() > maxCharLen)
-        text = text.substr(0, maxCharLen);
-    this->text = text;
-    this->dirty = true;
-    draw();
+	if (text.size() > maxCharLen)
+		text = text.substr(0, maxCharLen);
+	this->text = text;
+	this->dirty = true;
+	draw();
 }
 
 std::string TextBox::getText() const
 {
-    return this->text;
+	return this->text;
 }
-
-