diff --git a/API Documentation.en.md b/API Documentation.en.md
deleted file mode 100644
index a9a8735..0000000
--- a/API Documentation.en.md	
+++ /dev/null
@@ -1,2028 +0,0 @@
-# API Documentation
-
-[中文 API ](API 文档.md)
-
-Below is the API documentation for the main classes and functions of the **StellarX GUI Framework**. Detailed information such as the purpose, interface, parameters, and return values for each class are as follows:
-
-## Control Class (Abstract Base Class)
-
-**Description:** `Control` is the abstract base class for all controls, defining common properties and interfaces, including basic functionalities like position, size, and dirty flag. It provides drawing state save and restore mechanisms to ensure that a control's drawing operations do not affect the global drawing state. It also declares a series of pure virtual functions (such as `draw()` and `handleEvent()`) to be implemented by subclasses and prohibits copying (supports move semantics) to prevent accidental copying overhead. Generally, `Control` is not instantiated directly but serves as the parent class for other specific controls.
-
-**Features:**
-
-- Defines the basic properties of a control (coordinates, size, visibility, dirty flag, etc.) and provides corresponding accessor methods.
-- Provides drawing state management interfaces (`saveStyle()`/`restoreStyle()`, etc.) for saving and restoring the global pen state before and after control drawing.
-- Declares pure virtual interfaces, such as `draw()` (draw the control) and `handleEvent()` (handle events), which all concrete controls must implement.
-- Supports move construction and move assignment to prevent controls from being accidentally copied.
-
-### Public Member Functions
-
-#### Control::updateBackground()
-
-- **Purpose:** Releases the previously saved background snapshot and recaptures the current background. Used to update the control's background cache after its size changes or content changes. Calling this function ensures the correctness of the control's background, avoiding misalignment due to size changes.
-
-- **Parameters:** None.
-
-- **Return Value:** None.
-
-- **Behavior Details:** In the default implementation, `updateBackground()` first discards the old background bitmap (equivalent to calling the internal `discardBackground()`), then resaves a background snapshot within the control's current position and new size range. This is usually called automatically when the control size changes or a redraw is needed, and generally does not require manual user calls.
-
-- **Example:** Assuming a custom control needs to refresh its background upon resizing, it can be called after adjusting the size:
-
-  c++
-
-  ```
-  myControl.setWidth(newW);
-  myControl.setHeight(newH);
-  myControl.updateBackground(); // Update the background snapshot to match the new size
-  ```
-
-  
-
-#### Control::onWindowResize()
-
-- **Purpose:** An event function called to notify the control to handle corresponding actions when the parent window's size changes. Used to adjust the control's state when the window size changes, for example, invalidating outdated background caches.
-
-- **Parameters:** None.
-
-- **Return Value:** None.
-
-- **Behavior Details:** In the default implementation, `onWindowResize()` calls `discardBackground()` to discard the background bitmap saved by the control, preventing background misalignment after the window size changes. Container controls override this method (e.g., `Canvas` will call the child controls' `onWindowResize()` after handling its own). Generally, users do not need to call this method actively—the framework automatically triggers the call when the window or container size changes.
-
-- **Example:** If a custom control needs to execute specific logic when the window size changes, it can override this function:
-
-  c++
-
-  ```
-  void MyControl::onWindowResize()
-  {
-      Control::onWindowResize(); // Call base class to discard background, etc.
-      // Custom logic, e.g., adjust position based on new window size
-      repositionBasedOnNewWindowSize();
-  }
-  ```
-
-  
-
-#### Control::getX() / getY() / getWidth() / getHeight()
-
-- **Purpose:** Gets the control's global coordinate position (top-left corner `x, y`) or current size (width, height).
-
-- **Parameters:** None.
-
-- **Return Value:** Returns the control's global X coordinate, global Y coordinate, current width, and height respectively, all of type `int`.
-
-- **Behavior Details:** These methods provide the control's position and size in the window coordinate system, typically used for layout calculations or debugging. Note that global coordinates are relative to the origin (0,0) of the entire application window.
-
-- **Example:**
-
-  c++
-
-  ```
-  int x = ctrl.getX();
-  int h = ctrl.getHeight();
-  std::cout << "Control at X = " << x << ", height = " << h << std::endl;
-  ```
-
-  
-
-#### Control::getRight() / getBottom()
-
-- **Purpose:** Gets the X coordinate of the control's right edge (`getRight()`) and the Y coordinate of the control's bottom edge (`getBottom()`), calculated in global coordinates.
-
-- **Parameters:** None.
-
-- **Return Value:** The X coordinate of the control's right edge and the Y coordinate of the bottom edge, type `int`.
-
-- **Behavior Details:** These two methods are equivalent to `getX() + getWidth()` and `getY() + getHeight()`, used to conveniently obtain the boundary positions covered by the control in the window coordinate system.
-
-- **Example:**
-
-  c++
-
-  ```
-  if (cursorX < ctrl.getRight() && cursorY < ctrl.getBottom())
-  {
-      // Cursor is within the control's rectangular area
-  }
-  ```
-
-  
-
-#### Control::getLocalX() / getLocalY() / getLocalWidth() / getLocalHeight()
-
-- **Purpose:** Gets the control's position relative to the parent container's coordinate system (`LocalX, LocalY`) and its size within the parent container (`LocalWidth, LocalHeight`).
-
-- **Parameters:** None.
-
-- **Return Value:** The control's X coordinate, Y coordinate, width, and height relative to the parent container, all of type `int`.
-
-- **Behavior Details:** When a control is added to a container (e.g., `Canvas`), its local coordinates use the container's top-left corner as the origin. If the control has no parent container (directly belongs to the window), the local coordinates are the same as the global coordinates. These methods are particularly useful for laying out controls inside a container.
-
-- **Example:** Assuming a container `canvas` contains a child control `childCtrl`:
-
-  c++
-
-  ```
-  int localX = childCtrl.getLocalX();
-  int globalX = childCtrl.getX();
-  std::cout << "Child global X: " << globalX
-            << ", local X in canvas: " << localX << std::endl;
-  ```
-
-  
-
-#### Control::getLocalRight() / getLocalBottom()
-
-- **Purpose:** Gets the coordinates of the control's right and bottom edges relative to the parent container's coordinate system.
-
-- **Parameters:** None.
-
-- **Return Value:** The control's right-side coordinate and bottom coordinate within the parent container, type `int`.
-
-- **Behavior Details:** Equivalent to `getLocalX() + getLocalWidth()` and `getLocalY() + getLocalHeight()` respectively. These methods provide convenience when needing to determine the control's boundary positions inside the container.
-
-- **Example:** Can be used to check if a child control exceeds the container's bounds:
-
-  c++
-
-  ```
-  if (childCtrl.getLocalRight() > canvas.getWidth())
-  {
-      // The child control's right edge within the container exceeds the container's width
-  }
-  ```
-
-  
-
-#### Control::setX(int x) / setY(int y) / setWidth(int w) / setHeight(int h)
-
-- **Purpose:** Sets the control's global coordinate position (top-left X or Y) or adjusts the control's size (width or height).
-
-- **Parameters:** `x` or `y` is the new global coordinate; `w` is the new width value; `h` is the new height value (all of type `int`).
-
-- **Return Value:** None.
-
-- **Behavior Details:** Calling these methods directly modifies the control's position or size and automatically marks the control as "needing redraw" (internally sets the `dirty` flag to `true`), causing the control to be drawn at the new position or with the new size in the next refresh cycle. Note that if the control is in a container, setting the global coordinates will change its position in the window, but its position relative to the parent container will also be updated accordingly.
-
-- **Example:** Move control `ctrl` to window coordinates (100,100) and adjust the width to 200:
-
-  c++
-
-  ```
-  ctrl.setX(100);
-  ctrl.setY(100);
-  ctrl.setWidth(200);
-  // Height remains unchanged; if needed, call ctrl.setHeight(newHeight);
-  ```
-
-  
-
-#### Control::draw() (Pure Virtual Function)
-
-- **Purpose:** Abstract interface for drawing the control, implemented by concrete control classes with actual drawing logic.
-
-- **Parameters:** None (drawing information is determined by the control's internal state).
-
-- **Return Value:** None.
-
-- **Behavior Details:** `draw()` is called by the system during framework redraws; specific controls should complete their own drawing work in the implementation. Typically, a `draw()` implementation needs to first call `Control::saveStyle()` to save the current drawing state, then set drawing colors/fonts/etc. and draw, followed by calling `Control::restoreStyle()` to restore the state. **Users should not call this method directly**; to force a redraw, mark the control as dirty (`setDirty(true)`) and wait for the system call.
-
-- **Example:** The following is example pseudocode for a custom control implementing `draw()`:
-
-  c++
-
-  ```
-  void MyControl::draw()
-  {
-      saveStyle();
-      setfillcolor(backgroundColor);
-      bar(x, y, x+width, y+height); // Draw background rectangle
-      // ... Other drawing ...
-      restoreStyle();
-  }
-  ```
-
-  
-
-#### Control::handleEvent(const ExMessage& msg) (Pure Virtual Function)
-
-- **Purpose:** Abstract interface for event handling, implemented by concrete controls, used to handle interactive events like mouse and keyboard.
-
-- **Parameters:** `msg` is the EasyX framework's event message (`ExMessage`), containing information such as event type, mouse coordinates, and key presses.
-
-- **Return Value:** Boolean value, `true` indicates the event has been handled ("consumed") by the control and does not need further propagation; `false` indicates the control did not handle the event, and the event can be passed to other objects or default logic.
-
-- **Behavior Details:** The `handleEvent()` method is also automatically called by the system in the event loop, allowing controls to respond to user input. Different controls handle different types of events as needed (e.g., buttons handle mouse clicks, text boxes handle keyboard input). If a control recognizes and handles an event (e.g., a mouse click within the button area), it should return `true`, indicating the event stops here and does not propagate further. For unhandled events, it returns `false`.
-
-- **Example:** Simplified event handling logic for a button control:
-
-  c++
-
-  ```
-  bool Button::handleEvent(const ExMessage& msg)
-  {
-      if(msg.message == WM_LBUTTONDOWN && isPointInButton(msg.x, msg.y)) {
-          // Handle button click
-          onClickCallback(); // Call the registered callback
-          return true;
-      }
-      return false;
-  }
-  ```
-
-  
-
-#### Control::setIsVisible(bool show)
-
-- **Purpose:** Sets the control's visible state, dynamically showing or hiding the control. Passing `false` hides the control; passing `true` shows it.
-
-- **Parameters:** `show` is a boolean value specifying whether the control should be visible. `true` means visible, `false` means hidden.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This method allows switching the control's display state at runtime. After calling, the control's `IsVisible()` state changes and the redraw logic is automatically triggered: when hidden, the control's content is no longer drawn; when shown again, the control is marked as needing redraw. For container controls (like `Canvas`), this method is overridden to **recursively affect its child controls**: hiding a container also hides all its child controls; showing the container again also shows the child controls. This simplifies the visibility control of entire interface groups.
-
-- **Example:**
-
-  c++
-
-  ```
-  button.setIsVisible(false); // Hide a button
-  // ... After some operations ...
-  button.setIsVisible(true);  // Show the button again
-  ```
-
-  
-
-#### Control::setParent(Control* parent)
-
-- **Purpose:** Sets the control's parent container pointer. Usually called by the container when adding the control; manual calls are less common.
-
-- **Parameters:** `parent` is a pointer to the new parent container control (`Canvas`, etc.). Passing `nullptr` clears the parent container association.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This method sets the internal `parent` pointer to the specified container and adjusts the control's coordinate interpretation accordingly (local coordinates are relative to the parent container when one exists). The framework automatically calls this function when adding a control to a container; user intervention is not required. **Note:** When moving a control from one container to another, besides calling `setParent()`, you must also ensure the control is removed from the old container and added to the new one (using the container's `addControl()`, etc.), otherwise the interface state will be inconsistent.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas1.addControl(std::move(ctrl));    // Internally automatically calls setParent(&canvas1)
-  // To transfer from canvas1 to canvas2:
-  canvas1.removeControl(ctrlPtr);
-  canvas2.addControl(std::move(ctrlPtr)); // Internally calls setParent(&canvas2)
-  ```
-
-  
-
-#### Control::setDirty(bool dirty)
-
-- **Purpose:** Manually sets the control's "needs redraw" flag. Call this function when the control's content or properties change and you want to refresh the display immediately.
-
-- **Parameters:** `dirty` boolean value, `true` marks the control as needing redraw, `false` clears the redraw flag.
-
-- **Return Value:** None.
-
-- **Behavior Details:** After setting `dirty` to `true`, the control's `draw()` will be called to redraw during the next screen refresh. Usually, the framework internally sets this flag when control properties change, e.g., after calling methods like `setX()/setWidth()` that modify position or size, the control is already marked dirty. Developers can also call it in custom scenarios, for example, when the control's internal state changes but there is no corresponding setter method. Generally, there is no need to manually set `dirty` to `false` because the framework automatically clears the flag after redrawing.
-
-- **Example:**
-
-  c++
-
-  ```
-  ctrl.setDirty(true); // Request the ctrl control to redraw
-  ```
-
-  
-
-#### Control::IsVisible() const
-
-- **Purpose:** Checks if the control is currently in a visible state.
-
-- **Parameters:** None.
-
-- **Return Value:** `bool`, whether the control is currently visible. `true` means visible, `false` means hidden.
-
-- **Behavior Details:** This method returns the state of the control's internal `show` flag. Initially, controls are visible by default (`true`). If `setIsVisible(false)` is called or the control's parent container is hidden, this method returns `false`. When the control is not visible, its `draw()` will not be called.
-
-- **Example:**
-
-  c++
-
-  ```
-  if (!ctrl.IsVisible())
-  {
-      ctrl.setIsVisible(true); // Ensure the control is visible
-  }
-  ```
-
-  
-
-## Window Class (Application Main Window)
-
-**Description:** The `Window` class represents the application's main window. It manages window creation, the message loop, and the global control container. `Window` is responsible for initializing the graphics window (based on EasyX) and also serves as the carrier for all top-level controls (acting as their parent container). It handles system event distribution, timed redraws, etc., allowing users to focus on adding controls to the window and responding to events. An application typically creates only one `Window` instance.
-
-**Features:**
-
-- Provides multiple window initialization modes (e.g., with or without double buffering, whether to show the console, etc.) to suit different application needs.
-- Supports setting window background color or background image, as well as window title.
-- Built-in **dialog management** system: tracks popped-up modal/non-modal dialogs to avoid repeating the same dialog.
-- Integrates a complete message processing loop, automatically dispatching events to each control's `handleEvent()` method and scheduling redraws of each control's `draw()`.
-- Manages the lifecycle of all controls and dialogs added to the window, automatically cleaning up when the window is destroyed.
-
-### Public Member Functions
-
-#### Window(int width, int height, int mode, COLORREF bkColor = BLACK, std::string headline = "Window") (Constructor)
-
-- **Purpose:** Creates an application window of the specified size and performs necessary graphics initialization. You can specify the window mode, background color, and window title.
-
-- **Parameters:**
-
-  - `width`: Window width (pixels).
-  - `height`: Window height (pixels).
-  - `mode`: Window mode flags (int type). Different values configure window properties, such as whether to use **double buffering** for drawing, whether to show the console window, etc. Typically, 0 represents the default (window mode, hide console), or you can use constants provided by EasyX to combine this parameter, e.g., `EW_SHOWCONSOLE` to show the console, `EW_NOCLOSE` to disable the close button, etc.
-  - `bkColor` *(optional)*: Window background color, defaults to black (`BLACK`).
-  - `headline` *(optional)*: Window title text, defaults to "Window".
-
-- **Return Value:** None (constructor).
-
-- **Behavior Details:** When constructing a `Window` object, it calls EasyX's graphics initialization function `initgraph(width, height, mode)` to create the form, automatically applies the provided background color, and sets the window title. If the mode enables double buffering, the framework will use a manual refresh mechanism. After creating the window, **you must call** `runEventLoop()` to enter the message loop before the window starts responding to events and drawing.
-
-- **Example:**
-
-  c++
-
-  ```
-  // Create an 800x600 window, double-buffered and showing the console, background white, titled "Example"
-  int mode = EW_SHOWCONSOLE | EW_NOBORDER; // Example mode combination only
-  Window mainWin(800, 600, mode, WHITE, "Example");
-  mainWin.draw();
-  mainWin.runEventLoop();
-  ```
-
-  
-
-#### Window::~Window() (Destructor)
-
-- **Purpose:** Destroys the window object and cleans up resources.
-
-- **Parameters:** None.
-
-- **Return Value:** None.
-
-- **Behavior Details:** When the `Window` object is destroyed, the framework automatically closes the graphics window, releases EasyX graphics resources, and cleans up the controls and dialog objects hosted in the window. Usually does not require explicit calls; simply let the `Window` object go out of scope or be reclaimed by the system when the program ends.
-
-- **Example:**
-
-  c++
-
-  ```
-  {
-      Window win(400, 300, 0);
-      // ... Use win ...
-  } // Scope ends, automatically destructs, window closes
-  ```
-
-  
-
-#### Window::runEventLoop()
-
-- **Purpose:** Enters the window message processing loop, starting the GUI main event loop. After calling this function, the window begins responding to user interactions and continues running until the window is closed.
-
-- **Parameters:** None.
-
-- **Return Value:** `int`, the exit code of the window message loop (can typically be returned directly to `main()`).
-
-- **Behavior Details:** This function internally implements a typical event loop: continuously calls EasyX's `peekmessage()` to get event messages and dispatches them to the `handleEvent()` methods of the controls within the window. Simultaneously, it handles redraws as needed: each frame traverses all controls and calls their `draw()` methods. In the loop, the window also checks for the existence of modal dialogs and prevents interaction with underlying controls, etc. **Must** be called after creating the window and adding controls; otherwise, the window will be blank and unresponsive.
-
-- **Example:**
-
-  c++
-
-  ```
-  Window win(640, 480, EW_SHOWCONSOLE, LIGHTGRAY, "Demo");
-  // ... Add controls and other initialization ...
-  wni.draw();
-  return win.runEventLoop(); // Enter event loop, blocks until window closes
-  ```
-
-  
-
-#### Window::addControl(std::unique_ptr<Control> control)
-
-- **Purpose:** Adds a new control to the window for management and display. Can add any control inheriting from `Control`, such as buttons, text boxes, containers, etc.
-
-- **Parameters:** `control` is a `unique_ptr` smart pointer pointing to the control to be added. The function internally takes ownership of this pointer.
-
-- **Return Value:** None.
-
-- **Behavior Details:** When adding a control, the window includes the control in its internally maintained control list and calls the control's `setParent()`. Thereafter, the framework considers this control during each redraw and event handling. The control's initial position and size in the window coordinate system depend on the control's own properties. If you need to remove a control, currently it can be done via `clearAllControls()` (in `Canvas`) or by destroying the window.
-
-- **Example:**
-
-  c++
-
-  ```
-  auto btn = std::make_unique<Button>(50, 50, 80, 30, "OK");
-  mainWin.addControl(std::move(btn)); // Add the button to the main window for display
-  ```
-
-  
-
-#### Window::addDialog(std::unique_ptr<Control> dialog)
-
-- **Purpose:** Pops up a dialog control and adds it to the window. Used when adding dialogs.
-
-- **Parameters:** `dialog` is a `unique_ptr` to a `Dialog` or other dialog control object.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This function is similar to `addControl()` but specifically for dialog controls. The window adds the dialog to its internal dialog list and gives it special handling in the event loop (e.g., when a modal dialog exists, it prevents interaction with other controls). The framework also provides a duplicate prevention mechanism: if the dialog to be added already exists (matched by the dialog's title and message), it can avoid duplicate addition. Usually, this function is not used directly to add modal dialogs—instead, use the simplified call via `MessageBox::showModal()`.
-
-- **Example:**
-
-  c++
-
-  ```
-  auto dlg = std::make_unique<Dialog>(mainWin, "Warning", "An error occurred", MessageBoxType::OKCancel);
-  mainWin.addDialog(std::move(dlg)); // Non-modal dialog, displays asynchronously
-  ```
-
-  
-
-#### Window::hasNonModalDialogWithCaption(const std::string& caption, const std::string& message) const
-
-- **Purpose:** Checks if a non-modal dialog with the specified title and content already exists in the current window.
-
-- **Parameters:** `caption` is the dialog title text; `message` is the message content displayed by the dialog.
-
-- **Return Value:** `bool`, returns `true` if a non-modal dialog with the same title and content exists, otherwise `false`.
-
-- **Behavior Details:** This method is used to prevent popping up duplicate prompt boxes. When calling `MessageBox::showAsync()` to display a non-modal dialog, it internally uses this function to check if a dialog with the same content is already open and unclosed, thus avoiding multiple duplicate dialogs on the interface. Generally, users do not need to call it directly, but knowing its existence helps understand the framework's duplicate prevention mechanism.
-
-- **Example:** (Internal framework usage)
-
-  c++
-
-  ```
-  if (!hasNonModalDialogWithCaption("Warning", "An error occurred"))
-  {
-      // Safely pop up a new dialog
-      addDialog(std::make_unique<Dialog>(...));
-  }
-  ```
-
-  
-
-#### Window::draw()
-
-- **Purpose:** Manually triggers a redraw of the window content.
-
-- **Parameters:** None.
-
-- **Return Value:** None.
-
-- **Behavior Details:** By default, the framework automatically calls the internal drawing logic every frame, so manual calls to this function are generally unnecessary. But in some special cases (e.g., wanting to force an immediate redraw of certain content), you can call `mainWin.draw()`. This function traverses all controls added to the window and calls their `draw()` method for drawing. If double buffering mode is used, draw() will complete the drawing in the background and update the screen.
-
-- **Example:**
-
-  c++
-
-  ```
-  // Immediately refresh the window display after changing the background
-  mainWin.setBkcolor(WHITE);
-  mainWin.draw();
-  ```
-
-  
-
-#### Window::draw(const std::string& pImgFile)
-
-- **Purpose:** Draws the specified image file as the window background and refreshes the display.
-
-- **Parameters:** `pImgFile`, the image file path (string).
-
-- **Return Value:** None.
-
-- **Behavior Details:** This function provides a convenient way to set the window background image. When called, it loads the image from the specified path and tiles it as the window background, then calls the `draw()` of the window's other controls for normal drawing. Equivalent to setting the background image and immediately refreshing. If the specified file cannot be loaded or is not a valid image, the original background remains unchanged.
-
-- **Example:**
-
-  c++
-
-  ```
-  mainWin.draw("background.jpg"); // Use background.jpg as the background and redraw the window
-  ```
-
-  
-
-#### Window::setBkImage(const std::string& pImgFile)
-
-- **Purpose:** Sets the window background image but does not draw it immediately.
-
-- **Parameters:** `pImgFile`, the image file path.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This method changes the window background image setting but does not automatically trigger a redraw (waits for the next event loop refresh or a call to `draw()`). If immediate effect is needed, use it with `draw()`. Setting an empty string or invalid path will remove the background image, leaving only the background color.
-
-- **Example:**
-
-  c++
-
-  ```
-  mainWin.setBkImage("bg.png");
-  // The new background will be drawn automatically next frame, or manually call mainWin.draw();
-  ```
-
-  
-
-#### Window::setBkcolor(COLORREF c)
-
-- **Purpose:** Sets the window background color.
-
-- **Parameters:** `c`, the color value (COLORREF, e.g., `WHITE`, `RGB(255,255,255)`, etc.).
-
-- **Return Value:** None.
-
-- **Behavior Details:** Modifies the window background color; the new background color takes effect on the next refresh. If a background image was set previously, the new color will be covered by the background image (unless the background image is removed). Usually, the background color can be specified directly via the constructor parameter when creating the window; this function is for dynamically changing the background color during runtime.
-
-- **Example:**
-
-  c++
-
-  ```
-  mainWin.setBkcolor(LIGHTGRAY);
-  ```
-
-  
-
-#### Window::setHeadline(const std::string& headline)
-
-- **Purpose:** Sets the window title bar text.
-
-- **Parameters:** `headline`, a string, the new title text.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Calling this function changes the window's title bar content (implemented via Win32 API call `SetWindowText`). The change is immediate and does not require a refresh cycle.
-
-- **Example:**
-
-  c++
-
-  ```
-  mainWin.setHeadline("Processing Complete");
-  ```
-
-  
-
-### Getter Methods (Getters)
-
-#### Window::getWidth() / getHeight()
-
-- **Purpose:** Gets the current width or height of the window.
-
-- **Parameters:** None.
-
-- **Return Value:** Window width or height (int).
-
-- **Behavior Details:** This size is the size of the window's drawing area (consistent with the size specified at creation, unless the window was stretched during runtime). If the window supports stretching and was resized by the user, these two values update dynamically.
-
-- **Example:**
-
-  c++
-
-  ```
-  int w = mainWin.getWidth();
-  int h = mainWin.getHeight();
-  ```
-
-  
-
-#### Window::getHeadline()
-
-- **Purpose:** Gets the current title text of the window.
-
-- **Parameters:** None.
-
-- **Return Value:** Title string (`std::string`).
-
-- **Behavior Details:** If not set, returns the default title (specified at creation or the default "Window").
-
-- **Example:**
-
-  c++
-
-  ```
-  std::string title = mainWin.getHeadline();
-  ```
-
-  
-
-#### Window::getBkcolor()
-
-- **Purpose:** Gets the current window background color value.
-
-- **Parameters:** None.
-
-- **Return Value:** Background color (`COLORREF`).
-
-- **Behavior Details:** If the window is using a background image, this color usually still returns the most recently set color value, but it is currently covered by the background image during drawing.
-
-- **Example:**
-
-  c++
-
-  ```
-  COLORREF c = mainWin.getBkcolor();
-  ```
-
-  
-
-#### Window::getBkImage()
-
-- **Purpose:** Gets the background image object currently used by the window.
-
-- **Parameters:** None.
-
-- **Return Value:** Pointer to the background `IMAGE` object, may return `nullptr` if there is no background image.
-
-- **Behavior Details:** The returned `IMAGE*` is managed internally by the window; **do not modify or release it**. Only for read-only scenarios (e.g., layout based on background image size, etc.).
-
-- **Example:**
-
-  c++
-
-  ```
-  IMAGE* bg = mainWin.getBkImage();
-  if(bg)
-  {
-      // Example: Get background image width and height
-      int bgW = bg->getwidth();
-      int bgH = bg->getheight();
-  }
-  ```
-
-  
-
-#### Window::getHwnd()
-
-- **Purpose:** Gets the operating system handle (`HWND`) of the window.
-
-- **Parameters:** None.
-
-- **Return Value:** Windows window handle (`HWND`).
-
-- **Behavior Details:** This handle can be used to call underlying Win32 APIs to achieve window-level functionalities not provided by the framework. Generally not recommended to manipulate the window handle directly unless for advanced needs (like modifying window styles, etc.).
-
-- **Example:**
-
-  c++
-
-  ```
-  HWND hWnd = mainWin.getHwnd();
-  // Call Win32 API, e.g., change window icon:
-  SendMessage(hWnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
-  ```
-
-  
-
-#### Window::getControls()
-
-- **Purpose:** Gets a reference to the list of all top-level control containers within the window.
-
-- **Parameters:** None.
-
-- **Return Value:** `std::vector<std::unique_ptr<Control>>&`, a reference to the control list managed by the window.
-
-- **Behavior Details:** Returns the control container maintained internally by the window. You can traverse the element pointers to inspect or debug which controls have been added. Do not attempt to modify this list (e.g., insert/delete) to avoid corrupting the framework's internal state.
-
-- **Example:**
-
-  c++
-
-  ```
-  for(const auto& ctrl : mainWin.getControls())
-  {
-      std::cout << typeid(*ctrl).name() << std::endl;
-  }
-  ```
-
-  
-
-## Canvas Class (Container Control)
-
-**Description:** `Canvas` is a container class control used to group and manage child controls. It is itself a visible control that can draw a background and border. A typical use is as a **layout panel**: add multiple child controls to a Canvas, and let the Canvas handle event distribution and drawing order uniformly. Canvas supports multiple layout modes (absolute positioning or simple horizontal/vertical layouts), simplifying interface layout work.
-
-**Features:**
-
-- Supports four rectangular shapes (rectangle, rounded rectangle, and their borderless versions) as container appearances, with options to set the presence of borders and corner roundness, etc.
-- Provides custom fill modes (solid color or background image) and border styles (color, line style, line width).
-- Automatically manages child controls: takes over the lifecycle of child controls, automatically destroying them when the Canvas is destructed; also passes events to appropriate child controls when events occur.
-- Supports nested container structures: Canvas itself can be a child control of another Canvas, enabling complex layouts.
-- Simple layout capabilities: Currently supports **absolute layout** (by directly setting child control coordinates). **Horizontal Box HBox/Vertical Box VBox layout**), Grid, Flow, Stack and other layout types are currently reserved.
-
-### Public Member Functions
-
-#### Canvas() / Canvas(int x, int y, int width, int height) (Constructors)
-
-- **Purpose:** Creates a container control. You can use the default constructor to create an invisible Canvas and then set properties, or directly specify position and size for construction.
-
-- **Parameters:**
-
-  - `x, y`: The coordinates of the Canvas's top-left corner in the parent container (int).
-  - `width, height`: The initial width and height of the Canvas (int).
-
-- **Return Value:** None (constructor).
-
-- **Behavior Details:** A Canvas constructed by default is initialized to size 0 and requires manual size setting; the constructor with specified coordinates/size creates a visible container of the corresponding size. The default layout mode for Canvas is `LayoutKind::Absolute` (absolute positioning), which can be changed via its `layoutKind` property (currently only HBox/VBox are supported). After construction is complete, use `addControl()` to add child controls.
-
-- **Example:**
-
-  c++
-
-  ```
-  Canvas panel(50, 50, 300, 200); // Create a 300x200 panel at coordinates (50,50) in the parent container (or window)
-  panel.setCanvasBkColor(LIGHTGRAY);
-  ```
-
-  
-
-#### Canvas::addControl(std::unique_ptr<Control> control)
-
-- **Purpose:** Adds a control to the current Canvas container.
-
-- **Parameters:** `control`, a `unique_ptr` to the control to be added.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Calling this function incorporates the child control into the Canvas's management: the Canvas stores the child control pointer in its internal list and automatically calls `control->setParent(this)` to establish the parent-child relationship. After addition, the child control's position uses the Canvas's top-left corner as the reference origin (i.e., its `getLocalX()/getLocalY()` will be relative to the Canvas). The Canvas does not automatically layout absolutely positioned child controls—their coordinates need to be set manually; but if the Canvas uses HBox/VBox layout mode, adding a control will rearrange the child control positions according to the layout rules.
-
-- **Example:**
-
-  c++
-
-  ```
-  auto txt = std::make_unique<Label>(0, 0, "Hello");
-  canvas.addControl(std::move(txt)); // Label will be added inside the canvas container
-  ```
-
-  
-
-#### Canvas::clearAllControls()
-
-- **Purpose:** Removes and destroys all child controls within the Canvas container.
-
-- **Parameters:** None.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This method traverses and deletes each child control pointer saved internally (smart pointers automatically destruct the objects), then clears the list. Useful when needing to dynamically refresh the interface or replace the entire panel content. **Note:** After removing controls, the corresponding controls are no longer displayed, and their memory is freed.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.clearAllControls(); // Clear all added child controls
-  ```
-
-  
-
-#### Canvas::setShape(StellarX::ControlShape shape)
-
-- **Purpose:** Sets the Canvas container's shape (form and border type).
-
-- **Parameters:** `shape`, a `ControlShape` enumeration value specifying the container's shape and border style.
-
-- **Return Value:** None.
-
-- **Behavior Details:** `ControlShape` defines various shapes, such as bordered rectangle, borderless rectangle, bordered rounded rectangle, borderless rounded rectangle, circle/ellipse, etc. Calling this method changes the Canvas's outer contour shape when drawn (e.g., if set to rounded rectangle, it draws rounded borders, etc.). The default shape is `ControlShape::RECTANGLE` (bordered rectangle). After setting, the Canvas should be marked `dirty` so the new shape appears on the next redraw.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setShape(StellarX::ControlShape::B_ROUND_RECTANGLE); // Set to borderless rounded rectangle
-  ```
-
-  
-
-#### Canvas::setCanvasFillMode(StellarX::FillMode mode)
-
-- **Purpose:** Sets the Canvas background's fill mode.
-
-- **Parameters:** `mode`, a `FillMode` enumeration value. This enumeration defines background fill methods, such as solid color fill (`Solid`), fill with current background image (`Image`), use grid/line patterns, etc.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Default is solid color fill. If set to `Image`, the Canvas will use its currently set background image to draw its own background (can set the background image via the interface inherited by Canvas). Changing the fill mode requires a redraw to take effect.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setCanvasFillMode(StellarX::FillMode::Solid); // Background solid color fill
-  ```
-
-  
-
-#### Canvas::setBorderColor(COLORREF color)
-
-- **Purpose:** Sets the Canvas border color.
-
-- **Parameters:** `color`, the color value (`COLORREF`).
-
-- **Return Value:** None.
-
-- **Behavior Details:** This color is only used for the border during drawing if the Canvas's current shape has a border (like `RECTANGLE` or `ROUND_RECTANGLE`, etc.). The default border color is usually black.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setBorderColor(RGB(0, 128, 255)); // Set border to blue
-  ```
-
-  
-
-#### Canvas::setCanvasBkColor(COLORREF color)
-
-- **Purpose:** Sets the Canvas background color.
-
-- **Parameters:** `color`, the color value (`COLORREF`), will be used as the background fill color for the container area.
-
-- **Return Value:** None.
-
-- **Behavior Details:** If the current fill mode is solid color, this color will be used to fill the entire Canvas background area; if the fill mode is image and no background image is available, it will also degrade to using this color for filling. After changing the background color, the Canvas needs to be redrawn to see the effect (the framework automatically marks it for redraw).
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setCanvasBkColor(DARKGRAY);
-  ```
-
-  
-
-#### Canvas::setCanvasLineStyle(StellarX::LineStyle style)
-
-- **Purpose:** Sets the Canvas border line's style.
-
-- **Parameters:** `style`, a `LineStyle` enumeration value (solid line, dashed line, dotted line, etc.).
-
-- **Return Value:** None.
-
-- **Behavior Details:** When the Canvas draws its border, it will use the specified line style. This property can affect the border's visual effect, e.g., `LineStyle::Solid` is a solid line (default), `LineStyle::Dash` is a dashed line, etc.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setCanvasLineStyle(StellarX::LineStyle::Dash);
-  ```
-
-  
-
-#### Canvas::setLinewidth(int width)
-
-- **Purpose:** Sets the Canvas border line's width (thickness).
-
-- **Parameters:** `width`, the line width, in pixels.
-
-- **Return Value:** None.
-
-- **Behavior Details:** The default border width is 1 pixel. Setting a larger value can draw a thick border. If the Canvas's current shape is borderless, this setting has no effect until the shape is switched to a bordered type.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setLinewidth(3); // Thicken border to 3 pixels
-  ```
-
-  
-
-#### Canvas::setIsVisible(bool visible) (override)
-
-- **Purpose:** Overridden from `Control::setIsVisible`, used to show or hide the entire container and all its child controls.
-
-- **Parameters:** `visible` boolean value, `true` shows the container, `false` hides it.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Besides changing its own visible state, `Canvas::setIsVisible` calls the same `setIsVisible(visible)` for each child control within the container, ensuring the child controls' visibility matches the container's. That is, hiding a Canvas container recursively hides all its contents, and showing it again shows all contents.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setIsVisible(false); // Hide the entire container and child controls
-  ```
-
-  
-
-#### Canvas::setDirty(bool dirty) (override)
-
-- **Purpose:** Overridden from `Control::setDirty`, marks the container and its child controls as needing redraw.
-
-- **Parameters:** `dirty` boolean value, `true` marks as needing redraw.
-
-- **Return Value:** None.
-
-- **Behavior Details:** When `setDirty(true)` is called on a Canvas container, both the Canvas itself and all the child controls it contains will be redrawn in the next frame. This is useful when the container moves entirely or the background changes. Usually, the framework handles most cases automatically, and developers rarely need to call this manually.
-
-- **Example:**
-
-  c++
-
-  ```
-  canvas.setDirty(true); // The entire container and child elements will redraw on the next refresh
-  ```
-
-  
-
-#### Canvas::onWindowResize() (override)
-
-- **Purpose:** Overrides `Control::onWindowResize`, handles actions when the parent window size changes, and passes the notification to all child controls.
-- **Parameters:** None.
-- **Return Value:** None.
-- **Behavior Details:** `Canvas` overrides this method so that when the window size changes: it first calls its own base class logic (e.g., discarding background snapshots), then traverses and calls all child controls' `onWindowResize()`, allowing child controls to also perceive the window change. This ensures that after the window size changes, the container's internal layout can update (e.g., HBox/VBox layouts will automatically recalculate and rearrange on the next draw).
-- **Example:** *This method is called automatically by the framework; users do not need to use it directly.*
-
-#### Canvas::model() const (override)
-
-- **Purpose:** Determines if the Canvas is a modal dialog container. This method is specific to the `Dialog` class and is not applicable in Canvas; it consistently returns false.
-- **Parameters:** None.
-- **Return Value:** `false`.
-- **Behavior Details:** A regular Canvas is not a dialog, so this method always returns false. Can be ignored.
-
-### Example
-
-c++
-
-```
-// Example of creating a Canvas container and adding child controls
-Canvas panel(10, 10, 400, 300);
-panel.setCanvasBkColor(LIGHTGRAY);
-panel.setShape(StellarX::ControlShape::ROUND_RECTANGLE);
-panel.setLinewidth(2);
-panel.setBorderColor(BLACK);
-
-// Add a few buttons to the Canvas, assuming mainWin Window is already created
-auto btn1 = std::make_unique<Button>(20, 20, 80, 30, "Btn1");
-auto btn2 = std::make_unique<Button>(20, 60, 80, 30, "Btn2");
-panel.addControl(std::move(btn1));
-panel.addControl(std::move(btn2));
-
-// Add the Canvas to the main window
-mainWin.addControl(std::make_unique<Canvas>(panel));
-```
-
-
-
-## Label Class (Static Text Label)
-
-**Description:** `Label` is a control for displaying static text and is not interactive. It can display a piece of text on the interface, supporting style attributes like text color, background color, and whether the background is transparent or not. Label is suitable for explanatory text, title text, or prompt messages on the interface. Its characteristics are lightweight and no additional event handling overhead.
-
-**Features:**
-
-- Supports two display modes: transparent or opaque background, allowing the underlying background to show through behind the text if needed.
-- Provides complete text style control: including font, size, color, bold/italic effects, etc. (set via the public `textStyle` member structure).
-- Label automatically adjusts display based on its text content (e.g., calculating the area occupied by the text for layout).
-- Label itself does not handle user input events, so it does not interfere with other controls' interactions. Drawing is simple and efficient.
-
-### Public Member Functions
-
-#### Label() / Label(int x, int y, std::string text = "Label", COLORREF textColor = BLACK, COLORREF bkColor = RGB(255,255,255)) (Constructors)
-
-- **Purpose:** Creates a text label control. Can use default construction and then set properties, or directly specify position, text, and colors for construction.
-
-- **Parameters:**
-
-  - `x, y`: The Label's top-left corner position coordinates.
-  - `text`: The initially displayed text content (defaults to "Label").
-  - `textColor`: Text color (optional, default black).
-  - `bkColor`: Background color (optional, default white).
-
-- **Return Value:** None.
-
-- **Behavior Details:** The constructor initializes the Label based on the provided information. If using default construction, you must call `setText()` etc., to set the content. The Label's initial background is opaque; if a transparent background is needed, call `setTextdisap(true)` to enable it. Position coordinates are relative to the parent container or window.
-
-- **Example:**
-
-  c++
-
-  ```
-  Label title(100, 20, "Hello, World", BLACK, WHITE);
-  title.setTextdisap(true); // Background transparent
-  ```
-
-  
-
-#### Label::setText(const std::string& text)
-
-- **Purpose:** Sets the text content displayed by the Label.
-
-- **Parameters:** `text`, the new text string.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Updates the Label's internal text and marks the control as needing redraw to display the new text. If the text length changes, the Label's own size does not automatically change—the Label always displays text according to its initially set size; text beyond the range will be clipped or wrap (Label itself does not auto-wrap; you need to explicitly add `'\n'`).
-
-- **Example:**
-
-  c++
-
-  ```
-  label.setText("Welcome to StellarX!");
-  ```
-
-  
-
-#### Label::setTextBkColor(COLORREF color)
-
-- **Purpose:** Sets the fill color for the Label's text background rectangular area.
-
-- **Parameters:** `color`, the color value.
-
-- **Return Value:** None.
-
-- **Behavior Details:** When the Label background is opaque, this color is used to fill the text background area. Default is white. If the Label background is set to transparent (see `setTextdisap`), this color is not drawn. Changing the background color requires refreshing the control to take effect (the framework automatically redraws the next frame).
-
-- **Example:**
-
-  c++
-
-  ```
-  label.setTextBkColor(LIGHTBLUE);
-  ```
-
-  
-
-#### Label::setTextdisap(bool transparent)
-
-- **Purpose:** Toggles the Label background's transparent/opaque mode.
-
-- **Parameters:** `transparent`, boolean value. `true` means background transparent, `false` means opaque (uses background color fill).
-
-- **Return Value:** None.
-
-- **Behavior Details:** In transparent background mode, when drawing text, the Label does not cover the content underneath; the area around the text is completely transparent. In non-transparent mode, it fills the Label area with the current background color before drawing the text. By default, the Label background is opaque. Setting transparent allows you to set it back to opaque later to restore background color filling.
-
-- **Example:**
-
-  c++
-
-  ```
-  label.setTextdisap(true); // Enable background transparency
-  ```
-
-  
-
-#### Label::hide()
-
-- **Purpose:** Hides this Label control.
-
-- **Parameters:** None.
-
-- **Return Value:** None.
-
-- **Behavior Details:** After calling, the Label will no longer be visible, equivalent to calling `setIsVisible(false)` on this control. The framework will not draw this Label on the next refresh. It can be made visible again by calling `setIsVisible(true)` or re-adding the Label to the parent container, etc.
-
-- **Example:**
-
-  c++
-
-  ```
-  label.hide();
-  ```
-
-  
-
-### Public Member Variable
-
-- **textStyle** (`StellarX::ControlText`): Label text style structure, public member. Contains attributes like font name, height, width, color, italic/underline, etc. You can directly modify its fields to customize the text appearance, e.g., `label.textStyle.color = RED;` changes the text color. After modification, the Label should be marked as needing redraw.
-
-### Example
-
-c++
-
-```
-Label nameLabel(20, 20, "Name:", BLACK, WHITE);
-nameLabel.setTextdisap(false);                // Background opaque
-nameLabel.setTextBkColor(RGB(240,240,240));   // Light gray background
-nameLabel.textStyle.lpszFace = "Consolas";    // Change font
-nameLabel.textStyle.nHeight = 20;             // Font size 20
-nameLabel.textStyle.color = RGB(80,80,80);    // Dark gray text
-// The Name label will now display in Consolas font, dark gray text on a light gray background
-```
-
-
-
-## Button Class (Button Control)
-
-**Description:** `Button` is a feature-rich button control supporting multiple states (normal, hover, pressed, disabled) and modes (normal button or toggle switch). It can respond to user interactions like mouse clicks and trigger callbacks. The Button's appearance is highly customizable, offering different geometric shapes (rectangle, rounded, circle, ellipse) and various visual styles (color fill, image background, etc.), suitable for executing commands, toggling states, etc.
-
-**Features:**
-
-- **Three Operating Modes:** Supports **normal button** (each click triggers an action once), **toggle button** (two-state switch, click changes its own state), and **disabled** (non-interactive).
-- **Eight Appearance Shapes:** Provides rectangle, borderless rectangle, rounded rectangle, borderless rounded rectangle, circle, borderless circle, ellipse, borderless ellipse eight shapes. Can choose whether to draw a border via parameters.
-- **Multi-State Colors:** Allows setting different foreground/background colors for default, hover, and pressed states, providing visual feedback.
-- **Multiple Fill Modes:** Background can use solid colors, preset fill patterns, or specified images, achieving rich button visual effects.
-- **Complete Mouse Event Handling:** Can detect mouse hover, leave, press, release, etc., and change appearance or trigger callbacks.
-
-### Public Member Functions
-
-#### 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) (Constructor 1)
-
-- **Purpose:** Creates a button control, specifying position, size, display text, optional button mode, and shape.
-
-- **Parameters:**
-
-  - `x, y`: Button top-left corner coordinates.
-  - `width, height`: Button width and height.
-  - `text`: Text displayed on the button (defaults to empty string, i.e., no text).
-  - `mode`: Button operating mode, `ButtonMode` enumeration, default normal button (`NORMAL`), can be set to `TOGGLE` (toggle button).
-  - `shape`: Button shape, `ControlShape` enumeration, default bordered rectangle.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This constructor creates a button with a default color scheme. In normal mode, the button triggers a click event once per click; in toggle mode, the button has "pressed/released" two states, toggling state with each click. The button shape parameter determines whether the button is circular, rectangular, or another shape, combined with border presence.
-
-- **Example:**
-
-  c++
-
-  ```
-  Button okBtn(50, 100, 80, 30, "OK", ButtonMode::NORMAL, ControlShape::RECTANGLE);
-  ```
-
-  
-
-#### Button(int x, int y, int width, int height, const std::string& text, COLORREF colorDefault, COLORREF colorPressed, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE) (Constructor 2)
-
-- **Purpose:** Creates a button and customizes its default and pressed state background colors.
-
-- **Parameters:**
-
-  - First four `x, y, width, height, text` same as above.
-  - `colorDefault`: Background fill color when the button is not pressed.
-  - `colorPressed`: Background fill color when the button is pressed.
-  - `mode`: Button mode (default normal).
-  - `shape`: Button shape (default bordered rectangle).
-
-- **Return Value:** None.
-
-- **Behavior Details:** The button uses different colors in different states; this constructor allows directly setting the colors for normal and pressed states. The hover state defaults to an intermediate color between the two (or calculated via an internal algorithm) and can be adjusted via further function calls. Text color defaults to black and can be set separately.
-
-- **Example:**
-
-  c++
-
-  ```
-  Button toggleBtn(10, 10, 60, 25, "On/Off", GREEN, RED, ButtonMode::TOGGLE);
-  // Unpressed shows green, pressed shows red
-  ```
-
-  
-
-#### Button(int x, int y, int width, int height, const std::string& text, COLORREF colorDefault, COLORREF colorPressed, COLORREF colorHover, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE) (Constructor 3)
-
-- **Purpose:** Creates a button, manually specifying the background colors for normal, pressed, and hover states.
-
-- **Parameters:**
-
-  - First five same as above (including `text`).
-  - `colorDefault`: Default background color.
-  - `colorPressed`: Pressed background color.
-  - `colorHover`: Mouse hover background color.
-  - `mode`: Mode (default normal).
-  - `shape`: Shape (default rectangle).
-
-- **Return Value:** None.
-
-- **Behavior Details:** Provides full control over the three-state colors. If the hover color is not specified separately (using the previous constructor), the button internally automatically generates a hover color; using this constructor uses the provided `colorHover`. Other properties are the same as above.
-
-- **Example:**
-
-  c++
-
-  ```
-  Button customBtn(100,100,100,40,"Custom", RGB(0,200,0), RGB(0,150,0), RGB(0,220,0));
-  ```
-
-  
-
-#### Button::setOnClickListener(const std::function<void()>&& callback)
-
-- **Purpose:** Sets the click event callback function for the button. Called when the button is clicked in normal mode (or clicked from the unpressed state in toggle mode).
-
-- **Parameters:** `callback`, a function object (`std::function<void()>`) with no parameters and no return value, can be a lambda or function pointer, etc.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Once the callback is set, when the user left-clicks the button and the button event is recognized, the framework will automatically execute this callback function during event processing. Ensure the operations performed in the callback do not block for too long (to avoid affecting UI responsiveness). This method can be called multiple times to change the callback, with the last setting taking effect.
-
-- **Example:**
-
-  c++
-
-  ```
-  okBtn.setOnClickListener([](){
-      std::cout << "OK button clicked!" << std::endl;
-  });
-  ```
-
-  
-
-#### Button::setOnToggleOnListener(const std::function<void()>&& callback)
-
-- **Purpose:** Sets the "on" state callback for a **toggle mode** button. Called when the button transitions from the non-pressed state to the pressed state (toggled on).
-
-- **Parameters:** `callback`, a callback of type `std::function<void()>`.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Only effective when the button mode is `TOGGLE`. Executed when the user clicks the button causing it to enter the "pressed" (ON) state. Typical use is like toggling a feature on: you can implement the "on" action logic in the callback.
-
-- **Example:**
-
-  c++
-
-  ```
-  toggleBtn.setOnToggleOnListener([](){
-      turnFeatureOn();
-  });
-  ```
-
-  
-
-#### Button::setOnToggleOffListener(const std::function<void()>&& callback)
-
-- **Purpose:** Sets the "off" state callback for a **toggle mode** button. Called when the button transitions from the pressed state to the released state (toggled off).
-
-- **Parameters:** `callback`, a callback of type `std::function<void()>`.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Only used for `TOGGLE` mode buttons. Executed when the user clicks the button again, causing it to switch from the ON state back to the OFF state. For example, the logic to turn off a feature should be placed in this callback.
-
-- **Example:**
-
-  c++
-
-  ```
-  toggleBtn.setOnToggleOffListener([](){
-      turnFeatureOff();
-  });
-  ```
-
-  
-
-#### Button::setTooltipOffset(int dx, int dy)
-
-- **Purpose:** Sets the offset of the button's hover tooltip relative to the mouse position.
-
-- **Parameters:** `dx, dy`, the offset pixels in the X-axis and Y-axis directions respectively.
-
-- **Return Value:** None.
-
-- **Behavior Details:** When the button has a hover tooltip enabled, the default tooltip displays at an offset down and right from the mouse pointer. This function allows customizing the offset; positive `dx, dy` means offset down and right.
-
-- **Example:**
-
-  c++
-
-  ```
-  btn.setTooltipOffset(10, 15); // Tooltip offset 10 right, 15 down relative to mouse
-  ```
-
-  
-
-#### Button::setTooltipStyle(COLORREF textColor, COLORREF bkColor, bool transparent)
-
-- **Purpose:** Sets the button's hover tooltip text color, background color, and background transparency property.
-
-- **Parameters:**
-
-  - `textColor`: Tooltip text color.
-  - `bkColor`: Tooltip box background fill color.
-  - `transparent`: Whether the background is transparent, `true` means the tooltip background is transparent, only showing text.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Allows customizing the tooltip's appearance, e.g., setting white text, black background, etc. If set to background transparent, `bkColor` has no effect. Calling this function immediately affects the style of subsequent tooltips. The default tooltip style is usually light yellow background, black text, opaque.
-
-- **Example:**
-
-  c++
-
-  ```
-  btn.setTooltipStyle(WHITE, BLUE, false); // Tooltip white text, blue background
-  ```
-
-  
-
-#### Button::setTooltipText(const std::string& text)
-
-- **Purpose:** Sets the button's tooltip text content.
-
-- **Parameters:** `text`, string, new tooltip content.
-
-- **Return Value:** None.
-
-- **Behavior Details:** When the mouse hovers over the button for a certain time, a small tooltip appears displaying this text. By default, if no tooltip text is set, the button's own `text` is used as the tooltip. Calling this function allows specifying different tooltip content. Setting it to an empty string means no tooltip is displayed.
-
-- **Example:**
-
-  c++
-
-  ```
-  btn.setTooltipText("Click this button to submit the form");
-  ```
-
-  
-
-#### Button::setTooltipTextsForToggle(const std::string& onText, const std::string& offText)
-
-- **Purpose:** For a toggle mode button, sets the hover tooltip text for the "on state" and "off state" respectively.
-
-- **Parameters:**
-
-  - `onText`: Tooltip text when the button is pressed (ON).
-  - `offText`: Tooltip text when the button is released (OFF).
-
-- **Return Value:** None.
-
-- **Behavior Details:** A toggle button might need different prompt information in its two states, e.g., ON state prompt "Click to close XXX", OFF state prompt "Click to open XXX". Call this function to provide the tooltip content for both states. Calling this will override any unified tooltip set previously via `setTooltipText`.
-
-- **Example:**
-
-  c++
-
-  ```
-  toggleBtn.setTooltipTextsForToggle("Currently ON, click to turn off", "Currently OFF, click to turn on");
-  ```
-
-  
-
-### Example
-
-c++
-
-```
-// Create and set up a button
-Button sendBtn(50, 50, 100, 40, "Send", BLUE, LIGHTBLUE, ButtonMode::NORMAL);
-sendBtn.setOnClickListener([](){
-    sendMessage();
-});
-sendBtn.setTooltipText("Send message");
-sendBtn.setTooltipStyle(WHITE, BLACK, false);
-```
-
-
-
-## TextBox Class (Text Box Control)
-
-**Description:** `TextBox` is a single-line text input box control supporting user text input and editing, and can also be configured as read-only mode for displaying non-editable text content. It integrates EasyX's input box functionality internally to handle text input while providing a degree of appearance customization. Typical uses include getting usernames, search boxes, etc.
-
-**Features:**
-
-- **Input/Read-Only Modes:** Provides two modes; input mode allows users to click and pop up a system input box to enter text, read-only mode displays text but prohibits user modification.
-- **Maximum Length Limit:** Can set the maximum number of characters for input text to avoid overflow.
-- **System Input Box Integration:** Uses Windows input method to ensure input compatibility, using EasyX's `InputBox` to get user input.
-- **Multiple Shapes:** Supports rectangle, rounded rectangle variants, etc., as text box border shapes to meet UI style needs.
-
-### Public Member Functions
-
-#### TextBox(int x, int y, int width, int height, const std::string& text = "", StellarX::TextBoxMode mode = StellarX::TextBoxMode::INPUT) (Constructor)
-
-- **Purpose:** Creates a text box control, specifying position, size, initial text, and mode (input or read-only).
-
-- **Parameters:**
-
-  - `x, y`: Text box top-left corner coordinates.
-  - `width, height`: Text box width and height.
-  - `text`: Initial text content, default empty.
-  - `mode`: Text box mode, `TextBoxMode` enumeration, defaults to input mode (`INPUT`), optional `READONLY`.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Can provide an initial display text at construction (like a hint "Please enter...", or existing content), and the mode. If READONLY, the text box won't respond to click input, only for display. Default background is white, bordered rectangle. When the user clicks an input mode text box, the framework automatically calls EasyX's `InputBox` to pop up an input dialog to get text.
-
-- **Example:**
-
-  c++
-
-  ```
-  TextBox nameField(100, 80, 150, 25, "", TextBoxMode::INPUT);
-  ```
-
-  
-
-#### TextBox::setText(const std::string& text)
-
-- **Purpose:** Sets the text content currently displayed in the text box.
-
-- **Parameters:** `text`, string, new text.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Directly changes the text box content without user input. Often used to initialize the text box content or update the display during program operation. If the text box is currently in read-only mode, it only changes the displayed text; if in input mode, the user can still edit/overwrite this text later.
-
-- **Example:**
-
-  c++
-
-  ```
-  nameField.setText("Guest");
-  ```
-
-  
-
-#### TextBox::getText() const
-
-- **Purpose:** Gets the text content currently contained in the text box.
-
-- **Parameters:** None.
-
-- **Return Value:** `std::string`, the text box content.
-
-- **Behavior Details:** When the user modifies the text via the input box, this can get the latest result. Even in read-only mode, this method can be used to get the currently displayed text.
-
-- **Example:**
-
-  c++
-
-  ```
-  std::string input = nameField.getText();
-  ```
-
-  
-
-#### TextBox::setMaxCharLen(size_t len)
-
-- **Purpose:** Sets the maximum character number limit for text box input.
-
-- **Parameters:** `len`, the maximum character length.
-
-- **Return Value:** None.
-
-- **Behavior Details:** This method can restrict users from inputting overly long text. When calling the EasyX input box, this value is passed as a parameter, ensuring the user cannot input a string longer than the specified length (excess parts are truncated). Defaults to some internal preset value (e.g., 64).
-
-- **Example:**
-
-  c++
-
-  ```
-  nameField.setMaxCharLen(20); // Limit input to 20 characters max
-  ```
-
-  
-
-#### TextBox::setMode(StellarX::TextBoxMode mode)
-
-- **Purpose:** Switches the text box's working mode: input (INPUT) or read-only (READONLY).
-
-- **Parameters:** `mode`, a `TextBoxMode` enumeration value.
-
-- **Return Value:** None.
-
-- **Behavior Details:** Calling this function at runtime can switch the text box from editable to read-only, or vice versa. Switching to read-only mode prohibits users from clicking to activate input; switching to input mode restores interactivity. Changing the mode does not affect the current text content.
-
-- **Example:**
-
-  c++
-
-  ```
-  nameField.setMode(TextBoxMode::READONLY); // Disable editing
-  ```
-
-  
-
-### Example
-
-c++
-
-```
-TextBox inputField(50, 50, 200, 25, "Please enter name");
-inputField.setMaxCharLen(30);
-inputField.setOnClickListener([](){
-    // TextBox itself does not directly support setOnClickListener, but can handle via handleEvent
-});
-std::string text = inputField.getText(); // Read user input result
-```
-
-
-
-## Dialog Class (Dialog Control)
-
-**Description:** `Dialog` is a dialog control that can contain a prompt text and several button options, supporting both modal and non-modal display methods. Dialog is typically created and displayed via static methods of the `MessageBox` class. It encapsulates the dialog window's layout, button responses, and return results logic. Dialogs can be used to display messages, warnings, error prompts, etc., and collect user confirm/cancel operations.
-
-**Features:**
-
-- Provides six standard dialog types (OK, YesNo, YesNoCancel, etc.), facilitating quick generation of common confirmation prompts.
-- Supports both **modal** (blocks the caller until the dialog closes) and **non-modal** (dialog displays while the program continues running, and results are obtained via callback) modes.
-- Automatically calculates window size and layout based on text length and button count, no manual adjustment needed.
-- Built-in background snapshot save and restore mechanism, preventing interface flicker when the dialog pops up and restoring the original interface when closed.
-- When created using factory methods (`MessageBox`), the framework automatically prevents popping up duplicate dialogs with the same content.
-
-### Public Member Functions
-
-#### Dialog(Window& parent, const std::string& caption, const std::string& message = "Dialog", StellarX::MessageBoxType type = StellarX::MessageBoxType::OK) (Constructor)
-
-- **Purpose:** Creates a dialog control, specifying the parent window, title, message content, and dialog type (button combination).
-- **Parameters:**
-  - `parent`: The main window reference to which the dialog belongs. The dialog will attach to this window.
-  - `caption`: Dialog title text.
-  - `message`: Dialog body message text. Default displays "Dialog".
-  - `type`: Dialog type, `MessageBoxType` enumeration value, determines which button options are included (e.g., `OK`, `YesNo`, etc.). Default is OK type with only an OK button.
-- **Return Value:** None.
-- **Behavior Details:** The constructor creates corresponding buttons in number and text based on `type` and lays them out at the dialog bottom; places the `message` text in the central area of the dialog for display. The dialog itself is a special control within the window, usually positioned centrally. Generally, the constructor is not called directly to generate dialogs; instead, use `MessageBox::showModal` or `showAsync` to create and display.
-- **Example:** *Usually called by MessageBox; no need to use directly.*
-
-#### Dialog::draw() (override)
-
-- **Purpose:** Draws the dialog, including background, text, and buttons.
-- **Parameters:** None.
-- **Return Value:** None.
-- **Behavior Details:** `Dialog::draw()` draws the dialog's own semi-transparent background overlay (in modal cases) or border, as well as the internal message text and button controls. Modal dialogs first draw the window's background snapshot when drawing, then overlay the dialog content to highlight the dialog. Users do not need to call this directly; handled automatically by the framework.
-
-#### Dialog::handleEvent(const ExMessage& msg) (override)
-
-- **Purpose:** Handles button clicks and other events within the dialog.
-- **Parameters:** `msg`, the event message.
-- **Return Value:** `bool`, indicates whether the event was consumed by the dialog.
-- **Behavior Details:** The `handleEvent` implemented by Dialog dispatches click events to its contained buttons and sets the dialog result based on button clicks (like "OK" or "Cancel"). If the dialog is displayed modally, clicking will end the modal loop and return the result; if non-modal, it passes the result through a pre-registered callback function.
-
-#### Dialog::model() const (override)
-
-- **Purpose:** Indicates whether the dialog is modal.
-- **Parameters:** None.
-- **Return Value:** `bool`, returns true for modal dialogs, false for non-modal.
-- **Behavior Details:** The framework sets this flag based on how the Dialog was created. Modal dialogs are created in `showModal`, non-modal in `showAsync`. This flag is used in the event loop to determine whether to intercept events for other underlying window controls (when a modal dialog exists, underlying control events are paused).
-
-#### Dialog::getResult()
-
-- **Purpose:** Gets the dialog's return result.
-- **Parameters:** None.
-- **Return Value:** `MessageBoxResult` enumeration value, representing the button the user finally clicked on the dialog, e.g., OK, Cancel, Yes, No, etc.
-- **Behavior Details:** Only meaningful for modal dialogs. Before the modal `MessageBox::showModal` returns, it saves the result in the Dialog object and returns it to the caller. In non-modal mode, the result is obtained via callback; this function is not used directly.
-
-### Example
-
-c++
-
-```
-// (Generally not using the Dialog class directly, but through MessageBox)
-// Here demonstrates manual creation and addition of a non-modal dialog:
-Dialog* dlg = new Dialog(mainWin, "Title", "Content", MessageBoxType::YesNo);
-mainWin.addDialog(std::unique_ptr<Dialog>(dlg));
-// Dialog will display, automatically destroys after user clicks a button. Result can be queried via dlg->getResult() or obtained via callback.
-```
-
-
-
-## MessageBox Utility Class
-
-**Description:** `MessageBox` provides a simplified dialog creation interface, allowing users to quickly pop up message boxes in the form of **static methods** without directly manipulating the `Dialog` class. It supports both modal dialogs (blocking) and non-modal dialogs (asynchronous via callback). Typical calls are very concise, e.g., one line of code can pop up a "confirmation" dialog waiting for the user to click OK.
-
-**Features:**
-
-- Static method calls, can be used without instantiating an object, convenient for global calls.
-- Automatically handles the difference between modal and non-modal logic; modal dialogs block and wait for results, non-modal return immediately and get results via callback after user selection.
-- Tightly integrated with `Window`: MessageBox internally uses the main window's dialog management mechanism, ensuring the same dialog content isn't popped up repeatedly within a window.
-- Provides a mechanism to prevent duplicate pops: for non-modal prompts with the same content, the second call can choose not to pop up a new one.
-
-### Public Static Functions
-
-#### MessageBox::showModal(Window& wnd, const std::string& text, const std::string& caption = "Prompt", MessageBoxType type = MessageBoxType::OK)
-
-- **Purpose:** Pops up a **modal** dialog, blocking the current thread until the user closes the dialog, and returns the user's selection result.
-
-- **Parameters:**
-
-  - `wnd`: The belonging `Window` reference, specifying in which main window to pop up the dialog.
-  - `text`: The main message text displayed by the dialog.
-  - `caption`: Dialog title (optional, defaults to "Prompt").
-  - `type`: Dialog type (optional, `MessageBoxType` enumeration, defaults to `OK` type).
-
-- **Return Value:** `MessageBoxResult` enumeration, representing the button the user clicked, e.g., `MessageBoxResult::OK`, `MessageBoxResult::Cancel`, etc.
-
-- **Behavior Details:** This function internally creates a `Dialog` object, configures the content and buttons, and displays it modally. The calling thread is blocked, entering an internal message loop that only responds to dialog-related events until the user clicks a button or closes the dialog. Then the function returns the corresponding result. During the modal dialog, other controls in the parent window temporarily lose responsiveness (are masked). This is a synchronous call, simple and easy to use.
-
-- **Example:**
-
-  c++
-
-  ```
-  MessageBoxResult res = MessageBox::showModal(mainWin, "Are you sure you want to exit?", "Exit Confirmation", MessageBoxType::YesNo);
-  if(res == MessageBoxResult::Yes) {
-      // User selected Yes, execute exit logic
-  }
-  ```
-
-  
-
-#### MessageBox::showAsync(Window& wnd, const std::string& text, const std::string& caption = "Prompt", MessageBoxType type = MessageBoxType::OK, std::function<void(MessageBoxResult)> onResult = nullptr)
-
-- **Purpose:** Pops up a dialog in **non-modal** manner, the function returns immediately, and the user's selection result is obtained asynchronously via a callback function.
-
-- **Parameters:**
-
-  - `wnd`: The belonging `Window` reference.
-  - `text`: Message text.
-  - `caption`: Title text (defaults to "Prompt").
-  - `type`: Dialog type (defaults to OK).
-  - `onResult`: Result callback, optional. Type is `std::function<void(MessageBoxResult)>`. When the user clicks a button to close the dialog, the framework calls this callback and passes the result. If `nullptr` is passed, no callback is used.
-
-- **Return Value:** None.
-
-- **Behavior Details:** The function returns immediately; the calling thread is not blocked. The dialog displays non-modally, and other controls on the parent window can still interact (unless the dialog monopolizes the area). When the user makes a selection (clicks a button) or closes the dialog, if a callback was provided, it is called and passed the result enumeration. Simultaneously, the dialog object self-destructs. Internally uses `Window::addDialog()` to add the dialog to window management. The framework has a **deduplication** mechanism: if a non-modal dialog with exactly the same content is currently open and unclosed, calling `showAsync` again will avoid popping up a new one (i.e., the function returns directly and no new dialog is created).
-
-- **Example:**
-
-  c++
-
-  ```
-  MessageBox::showAsync(mainWin, "File saved successfully!", "Notification", MessageBoxType::OK,
-      [](MessageBoxResult res){
-          // Callback logic when non-modal dialog closes
-          if(res == MessageBoxResult::OK) {
-              // User clicked OK
-          }
-      });
-  ```
-
-  
-
-## TabControl Class (Tab Container Control)
-
-**Description:** `TabControl` is a tab container control managing "tab button + corresponding page (Canvas)" pair combinations. It provides tab bar layout in four directions (top/bottom/left/right), selection switching functionality, and precise positioning of the page content area. This control supports adaptive layout upon window size changes, visibility linkage, and dirty region redraws, making it an ideal solution for hosting multiple pages within the same area.
-
-**Features:**
-
-- **Four-Direction Tab Layout:** Supports tab bar arrangement at the top, bottom, left, and right.
-- **Tab-Page Pair Management:** Each tab consists of a button tab and its corresponding Canvas page, supporting one-click addition.
-- **Intelligent Switching Mechanism:** Deeply integrated with Button's TOGGLE mode; clicking a tab automatically shows/hides the corresponding page.
-- **Adaptive Layout:** Automatically calculates tab and page areas, responds to window size changes.
-- **Child Control Management:** Supports adding child controls to specific tabs, automatically handling coordinate conversion.
-- **State Management:** Provides functionality to get and set the index of the currently active tab.
-
-### Public Member Functions
-
-#### TabControl() (Constructor 1)
-
-- **Purpose:** Creates a default TabControl control using default position and size.
-
-- **Parameters:** None
-
-- **Return Value:** None
-
-- **Behavior Details:** This constructor creates a TabControl with default position and size values. The control ID is set to "TabControl", tabs are arranged at the top by default, and the tab bar height uses the default value.
-
-- **Example:**
-
-  c++
-
-  ```
-  TabControl tabCtrl;
-  ```
-
-  
-
-#### TabControl(int x, int y, int width, int height) (Constructor 2)
-
-- **Purpose:** Creates a TabControl control with specified position and size.
-
-- **Parameters:**
-
-  - `x, y`: Control top-left corner coordinates
-  - `width, height`: Control's width and height
-
-- **Return Value:** None
-
-- **Behavior Details:** Creates a TabControl with the specified position and size. The control ID is set to "TabControl", tabs are arranged at the top by default, and the tab bar height uses the default value.
-
-- **Example:**
-
-  c++
-
-  ```
-  TabControl tabCtrl(10, 10, 400, 300);
-  ```
-
-  
-
-#### ~TabControl() (Destructor)
-
-- **Purpose:** Destroys the TabControl instance and releases related resources.
-- **Parameters:** None
-- **Return Value:** None
-- **Behavior Details:** Automatically cleans up all tab buttons and page Canvas objects, ensuring no memory leaks.
-
-#### void draw() override
-
-- **Purpose:** Draws the TabControl and all its child controls.
-
-- **Parameters:** None
-
-- **Return Value:** None
-
-- **Behavior Details:** Overrides Canvas's draw method. First checks the dirty flag and visibility; if redraw is needed, saves/restores the background first, then calls the base class draw method, and finally draws all tab buttons and the currently visible page. Resets the dirty flag after drawing.
-
-- **Example:**
-
-  c++
-
-  ```
-  tabCtrl.draw();
-  ```
-
-  
-
-#### bool handleEvent(const ExMessage& msg) override
-
-- **Purpose:** Handles input events and dispatches them to child controls.
-
-- **Parameters:**
-
-  - `msg`: Input event message
-
-- **Return Value:** `bool` - Returns true if the event was consumed, otherwise false
-
-- **Behavior Details:** Passes events sequentially to all tab buttons and the currently visible page for processing. If any child control consumes the event, returns true immediately. If the control state becomes dirty, requests a redraw.
-
-- **Example:**
-
-  c++
-
-  ```
-  ExMessage msg;
-  if (tabCtrl.handleEvent(msg))
-  {
-      // Event has been handled
-  }
-  ```
-
-  
-
-#### void add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>&& control)
-
-- **Purpose:** Adds a tab and its corresponding page to the TabControl.
-
-- **Parameters:**
-
-  - `control`: A pair object containing the button tab and Canvas page, passed using move semantics
-
-- **Return Value:** None
-
-- **Behavior Details:** Adds the new tab-page pair to the control list, initializes the tab bar and page layout. Sets the parent control for the new tab, enables tooltips, sets it to toggle mode, and registers a listener for toggle state changes. Newly added pages are invisible by default.
-
-- **Example:**
-
-  c++
-
-  ```
-  auto tabPair = std::make_pair(std::make_unique<Button>(), std::make_unique<Canvas>());
-  tabPair.first->setButtonText("Tab 1");
-  tabCtrl.add(std::move(tabPair));
-  ```
-
-  
-
-#### void add(std::string tabText, std::unique_ptr<Control> control)
-
-- **Purpose:** Adds a child control to the specified tab.
-
-- **Parameters:**
-
-  - `tabText`: The target tab's text identifier
-  - `control`: The child control to add
-
-- **Return Value:** None
-
-- **Behavior Details:** Finds the corresponding page Canvas based on the tab text and adds the child control to that page. The child control's visibility will be synchronized with the target page.
-
-- **Example:**
-
-  c++
-
-  ```
-  auto button = std::make_unique<Button>(20, 20, 80, 30, "Click me");
-  tabCtrl.add("Tab 1", std::move(button));
-  ```
-
-  
-
-#### void setTabPlacement(StellarX::TabPlacement placement)
-
-- **Purpose:** Sets the arrangement position of the tabs.
-
-- **Parameters:**
-
-  - `placement`: Tab arrangement method, a TabPlacement enumeration value
-
-- **Return Value:** None
-
-- **Behavior Details:** Sets the tabs to be arranged at the top, bottom, left, or right. Triggers re-layout of the tab bar and pages, and marks the control as dirty needing redraw.
-
-- **Example:**
-
-  c++
-
-  ```
-  tabCtrl.setTabPlacement(StellarX::TabPlacement::Left);
-  ```
-
-  
-
-#### void setTabBarHeight(int height)
-
-- **Purpose:** Sets the height of the tab bar (or width for left/right arrangement).
-
-- **Parameters:**
-
-  - `height`: The new height value for the tab bar
-
-- **Return Value:** None
-
-- **Behavior Details:** Modifies the tab bar's dimensions, triggers re-layout of the tab bar and pages, and marks the control as dirty needing redraw.
-
-- **Example:**
-
-  c++
-
-  ```
-  tabCtrl.setTabBarHeight(30);
-  ```
-
-  
-
-#### void setIsVisible(bool visible) override
-
-- **Purpose:** Sets the control's visibility and synchronizes the visible state of all child controls.
-
-- **Parameters:**
-
-  - `visible`: Whether it is visible
-
-- **Return Value:** None
-
-- **Behavior Details:** Overrides the base class method. First calls Canvas's setIsVisible to handle background snapshot logic, then sets its own visibility, and finally synchronizes the visible state of all tab buttons and pages. When a page is set to invisible, its background snapshot is cleared.
-
-- **Example:**
-
-  c++
-
-  ```
-  tabCtrl.setIsVisible(false); // Hide the entire TabControl and all its child controls
-  ```
-
-  
-
-#### void onWindowResize() override
-
-- **Purpose:** Responds to the window resize event.
-
-- **Parameters:** None
-
-- **Return Value:** None
-
-- **Behavior Details:** Overrides the base class method, calls the parent class's window resize handling, and then notifies all tab buttons and pages to perform adaptive adjustments.
-
-- **Example:**
-
-  c++
-
-  ```
-  tabCtrl.onWindowResize();
-  ```
-
-  
-
-#### int getActiveIndex() const
-
-- **Purpose:** Gets the index of the currently active tab.
-
-- **Parameters:** None
-
-- **Return Value:** `int` - The index of the currently active tab, returns -1 if no tab is active
-
-- **Behavior Details:** Traverses all tab buttons and returns the index of the first one in the clicked (active) state.
-
-- **Example:**
-
-  c++
-
-  ```
-  int activeIndex = tabCtrl.getActiveIndex();
-  ```
-
-  
-
-#### void setActiveIndex(int idx)
-
-- **Purpose:** Sets the tab at the specified index to the active state.
-
-- **Parameters:**
-
-  - `idx`: The index of the tab to activate
-
-- **Return Value:** None
-
-- **Behavior Details:** If the index is valid and the corresponding tab is not disabled, sets it to the active state. If the tab is already active but the page is not visible, shows the page; if it's not active, simulates a click to activate it.
-
-- **Example:**
-
-  c++
-
-  ```
-  tabCtrl.setActiveIndex(2); // Activate the third tab
-  ```
-
-  
-
-#### int count() const
-
-- **Purpose:** Gets the number of tabs in the TabControl.
-
-- **Parameters:** None
-
-- **Return Value:** `int` - The total number of tabs
-
-- **Behavior Details:** Returns the number of tab-page pairs in the control.
-
-- **Example:**
-
-  c++
-
-  ```
-  int tabCount = tabCtrl.count();
-  ```
-
-  
-
-#### int indexOf(const std::string& tabText) const
-
-- **Purpose:** Finds the corresponding index by tab text.
-
-- **Parameters:**
-
-  - `tabText`: The tab text to find
-
-- **Return Value:** `int` - The index of the matching tab, returns -1 if not found
-
-- **Behavior Details:** Traverses all tab buttons, compares the button text with the target text, and returns the index of the first matching tab.
-
-- **Example:**
-
-  c++
-
-  ```
-  int index = tabCtrl.indexOf("Settings");
-  ```
-
-  
-
-#### Usage Example
-
-c++
-
-```
-// Create a tab control
-auto ta = std::make_unique<TabControl>(10, 10, 950, 240);
-// Create tab buttons
-auto but = std::make_unique<Button>(0, 0, 100, 15, "Button1");
-// Create a pair to wrap the tab and page, then add it to the tab control
-std::pair<std::unique_ptr<Button>,std::unique_ptr<Canvas>> p;
-p.first =std::move( but);
-p.second = std::make_unique<Canvas>(200, 200, 100, 100);
-p.second->setCanvasBkColor(RGB(0,255,0));
-p.second->addControl(std::move(table));
-
-std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>> p1;
-p1.first = std::make_unique<Button>(0, 0, 100, 15, "Button2");
-p1.second = std::make_unique<Canvas>(200, 200, 100, 100);
-p1.second->setCanvasBkColor(RGB(255,200,0));
-// Set the tab bar position
-ta->setTabPlacement(StellarX::TabPlacement::Bottom);
-// Add controls to the tab control
-ta->add(std::move(p));
-ta->add(std::move(p1));
-ta->setCanvasfillMode(StellarX::FillMode::Null);
-// Add the tab control to the window's control list
-mainWindow.addControl(std::move(ta));
-```
\ No newline at end of file
diff --git a/API 文档.md b/API 文档.md
deleted file mode 100644
index 51c6710..0000000
--- a/API 文档.md	
+++ /dev/null
@@ -1,1756 +0,0 @@
-#  API 文档
-
-[English API Documentation](API Documentation.en.md)
-
-下面是 **StellarX GUI 框架** 各主要类和函数的 API 文档。每个类的用途、接口、参数和返回值等详细信息如下：
-
-## Control 类 (抽象基类)
-
-**描述：** `Control` 是所有控件的抽象基类，定义了通用的属性和接口，包括位置、尺寸、重绘标记等基础功能。它提供绘图状态的保存与恢复机制，确保控件的绘制操作不影响全局绘图状态。此外还声明了一系列供子类实现的纯虚函数（如 `draw()` 和 `handleEvent()`），并禁止拷贝（支持移动语义）以防止意外的复制开销。一般情况下，`Control` 不直接实例化，而作为其他具体控件的父类存在。
-
-**特性：**
-
-- 定义控件的基本属性（坐标、尺寸、可见性、脏标记等）并提供对应的存取方法。
-- 提供绘图状态管理接口（`saveStyle()`/`restoreStyle()` 等）用于在控件绘制前后保存和恢复全局画笔状态。
-- 声明纯虚接口，如 `draw()`（绘制控件）和 `handleEvent()`（处理事件），所有具体控件都需实现。
-- 提供移动构造和移动赋值支持，防止控件被不小心拷贝。
-
-### 公共成员函数
-
-#### Control::updateBackground()
-
-- **用途：** 释放之前保存的背景快照并重新捕获当前背景，用于在控件尺寸变化或内容变化后更新其背景缓存。调用此函数可确保控件背景的正确性，避免因为尺寸变化导致的背景错位。
-
-- **参数：** 无。
-
-- **返回值：** 无。
-
-- **行为细节：** 默认实现中，`updateBackground()` 会先丢弃旧的背景位图（相当于调用内部的 `discardBackground()`），然后在控件当前位置和新尺寸范围内重新保存一份背景快照。这通常在控件大小改变或重绘需求发生时自动调用，一般不需要用户手动调用。
-
-- **示例：** 假设有自定义控件在大小调整时需要刷新背景，可以在调整尺寸后调用：
-
-  ```c++
-  myControl.setWidth(newW);
-  myControl.setHeight(newH);
-  myControl.updateBackground(); // 更新背景快照以匹配新尺寸
-  ```
-
-#### Control::onWindowResize()
-
-- **用途：** 当父窗口尺寸发生变化时，通知控件进行相应处理的事件函数。用于在窗口大小改变时调整控件状态，例如作废过期的背景缓存。
-
-- **参数：** 无。
-
-- **返回值：** 无。
-
-- **行为细节：** 默认实现中，`onWindowResize()` 会调用 `discardBackground()` 丢弃控件保存的背景位图，以防止窗口尺寸变化后背景错位。容器控件会重写该方法（例如 `Canvas` 会在自身处理后继续调用子控件的 `onWindowResize()`）。一般用户不需要主动调用此方法——框架会在窗口或容器尺寸变化时自动触发调用。
-
-- **示例：** 自定义控件如需在窗口大小改变时执行特定逻辑，可以重写此函数：
-
-  ```c++
-  void MyControl::onWindowResize()
-  {
-      Control::onWindowResize(); // 调用基类以丢弃背景等
-      // 自定义逻辑，例如根据新窗口尺寸调整位置
-      repositionBasedOnNewWindowSize();
-  }
-  ```
-
-#### Control::getX() / getY() / getWidth() / getHeight()
-
-- **用途：** 获取控件的全局坐标位置（左上角 `x, y`）或当前尺寸（宽度、高度）。
-
-- **参数：** 无。
-
-- **返回值：** 分别返回控件的全局 X 坐标、全局 Y 坐标、当前宽度、高度，类型均为 `int`。
-
-- **行为细节：** 这些方法提供控件在窗口坐标系下的位置和大小，通常用于布局计算或调试。注意，全局坐标是相对于整个应用窗口的原点(0,0)。
-
-- **示例：**
-
-  ```c++
-  int x = ctrl.getX();
-  int h = ctrl.getHeight();
-  std::cout << "Control at X = " << x << ", height = " << h << std::endl;
-  ```
-
-#### Control::getRight() / getBottom()
-
-- **用途：** 获取控件的右边缘的 X 坐标 (`getRight()`) 和下边缘的 Y 坐标 (`getBottom()`)，以全局坐标计算。
-
-- **参数：** 无。
-
-- **返回值：** 控件右边缘 X 坐标、底边缘 Y 坐标，类型为 `int`。
-
-- **行为细节：** 这两个方法相当于 `getX() + getWidth()` 和 `getY() + getHeight()`，用于方便地获取控件在窗口坐标系中覆盖的边界位置。
-
-- **示例：**
-
-  ```c++
-  if (cursorX < ctrl.getRight() && cursorY < ctrl.getBottom()) 
-  {
-      // 光标在ctrl控件矩形范围内
-  }
-  ```
-
-#### Control::getLocalX() / getLocalY() / getLocalWidth() / getLocalHeight()
-
-- **用途：** 获取控件相对于父容器坐标系的位置 (`LocalX, LocalY`) 以及在父容器内的尺寸 (`LocalWidth, LocalHeight`)。
-
-- **参数：** 无。
-
-- **返回值：** 控件相对父容器的 X 坐标、Y 坐标、宽度、高度，类型均为 `int`。
-
-- **行为细节：** 当控件被添加到容器（例如 `Canvas`）时，其本地坐标以容器的左上角为原点。如果控件没有父容器（直接属于窗口），则本地坐标与全局坐标相同。这些方法对于在容器内部布局控件特别有用。
-
-- **示例：** 假设有一个容器 `canvas`，其中包含子控件 `childCtrl`：
-
-  ```c++
-  int localX = childCtrl.getLocalX();
-  int globalX = childCtrl.getX();
-  std::cout << "Child global X: " << globalX 
-            << ", local X in canvas: " << localX << std::endl;
-  ```
-
-#### Control::getLocalRight() / getLocalBottom()
-
-- **用途：** 获取控件相对于父容器坐标系的右边缘和底边缘坐标。
-
-- **参数：** 无。
-
-- **返回值：** 控件在父容器内的右侧坐标、下侧坐标，类型为 `int`。
-
-- **行为细节：** 分别等价于 `getLocalX() + getLocalWidth()` 和 `getLocalY() + getLocalHeight()`。当需要确定控件在容器内部的边界位置时，这些方法提供了便利。
-
-- **示例：** 可用于判断子控件是否超出了容器范围：
-
-  ```c++
-  if (childCtrl.getLocalRight() > canvas.getWidth())
-  {
-      // 子控件在容器内的右边缘超出了容器宽度
-  }
-  ```
-
-#### Control::setX(int x) / setY(int y) / setWidth(int w) / setHeight(int h)
-
-- **用途：** 设置控件的全局坐标位置（左上角 X 或 Y）或调整控件的尺寸（宽度或高度）。
-
-- **参数：** `x` 或 `y` 为新的全局坐标；`w` 为新的宽度值；`h` 为新的高度值（类型均为 `int`）。
-
-- **返回值：** 无。
-
-- **行为细节：** 调用这些方法将直接修改控件的位置或大小，并自动将控件标记为“需要重绘”（内部将 `dirty` 标志置为 `true`），使得下一轮刷新时控件会按照新位置或新尺寸绘制。需要注意，如果控件在容器中，设置全局坐标会改变其在窗口中的位置，但相对父容器的位置也会随之更新。
-
-- **示例：** 将控件 `ctrl` 移动到窗口坐标(100,100)，并调整宽度为200：
-
-  ```c++
-  ctrl.setX(100);
-  ctrl.setY(100);
-  ctrl.setWidth(200);
-  // 高度保持不变，如果需要也可调用 ctrl.setHeight(newHeight);
-  ```
-
-#### Control::draw() (纯虚函数)
-
-- **用途：** 绘制控件的抽象接口，由具体控件类实现实际的绘图逻辑。
-
-- **参数：** 无（绘制所需信息由控件内部状态确定）。
-
-- **返回值：** 无。
-
-- **行为细节：** `draw()` 会在框架重绘时由系统调用，具体控件应在实现中完成自身的绘图工作。通常一个 `draw()` 实现需要先调用 `Control::saveStyle()` 保存当前绘图状态，然后设置绘图颜色/字体等并绘制，再调用 `Control::restoreStyle()` 恢复状态。**用户不应直接调用**此方法；若要强制重绘，可以将控件标记为脏 (`setDirty(true)`) 并等待系统调用。
-
-- **示例：** 以下为自定义控件实现 `draw()` 的示例伪代码：
-
-  ```c++
-  void MyControl::draw()
-  {
-      saveStyle(); 
-      setfillcolor(backgroundColor);
-      bar(x, y, x+width, y+height); // 绘制背景矩形
-      // ... 其他绘制 ...
-      restoreStyle();
-  }
-  ```
-
-#### Control::handleEvent(const ExMessage& msg) (纯虚函数)
-
-- **用途：** 事件处理抽象接口，由具体控件实现，用于处理鼠标、键盘等交互事件。
-
-- **参数：** `msg` 为 EasyX 框架的事件消息 (`ExMessage`)，包含了事件类型、鼠标坐标、按键等信息。
-
-- **返回值：** 布尔值，`true` 表示该事件已被控件处理（“消费”），不需要继续传递；`false` 表示控件未处理该事件，事件可交由其它对象或默认逻辑处理。
-
-- **行为细节：** `handleEvent()` 方法同样由系统在事件循环中自动调用，用于让控件响应用户输入。不同控件根据需要处理不同类型的事件（如按钮处理鼠标点击，文本框处理键盘输入）。如果控件识别并处理了某个事件（例如鼠标点击在按钮范围内），应该返回 `true`，表示事件到此为止，不再向上传播。对于未处理的事件则返回 `false`。
-
-- **示例：** 简化的按钮控件事件处理逻辑：
-
-  ```c++
-  bool Button::handleEvent(const ExMessage& msg)
-  {
-      if(msg.message == WM_LBUTTONDOWN && isPointInButton(msg.x, msg.y)) {
-          // 处理按钮点击
-          onClickCallback(); // 调用已注册的回调
-          return true;
-      }
-      return false;
-  }
-  ```
-
-#### Control::setIsVisible(bool show)
-
-- **用途：** 设置控件的可见状态，动态显示或隐藏控件。传入 `false` 将隐藏控件，传入 `true` 则显示控件。
-
-- **参数：** `show` 为布尔值，指定是否让控件可见。`true` 表示可见，`false` 表示隐藏。
-
-- **返回值：** 无。
-
-- **行为细节：** 该方法允许在运行时切换控件的显示状态。调用后控件的 `IsVisible()` 状态将改变，并自动触发重绘逻辑：隐藏时控件内容不再绘制；重新显示时控件会被标记需要重绘。对于容器控件（如 `Canvas`），本方法已被重写以**递归影响其子控件**：隐藏一个容器时，其所有子控件也会被隐藏；再次显示容器时，子控件也随之显示。这简化了整组界面的显隐控制。
-
-- **示例：**
-
-  ```c++
-  button.setIsVisible(false); // 隐藏一个按钮
-  // ... 某些操作后 ...
-  button.setIsVisible(true);  // 再次显示按钮
-  ```
-
-#### Control::setParent(Control* parent)
-
-- **用途：** 设置控件的父容器指针。通常由容器在添加控件时调用，手动调用情形较少。
-
-- **参数：** `parent` 指向新的父容器控件 (`Canvas` 等) 的指针。传入 `nullptr` 则表示清除父容器关联。
-
-- **返回值：** 无。
-
-- **行为细节：** 该方法将内部的 `parent` 指针设置为指定容器，并相应调整控件的坐标解释方式（有父容器时本地坐标相对于父容器）。在将控件添加到某个容器时，框架会自动调用此函数，无需用户干预。**注意：** 将控件从一个容器转移到另一个时，除了调用 `setParent()` 外，还需要确保在旧容器中移除、在新容器中添加控件（使用容器的 `addControl()` 等），否则界面状态不一致。
-
-- **示例：**
-
-  ```c++
-  canvas1.addControl(std::move(ctrl));    // 内部自动 setParent(&canvas1)
-  // 如需从 canvas1 转移到 canvas2:
-  canvas1.removeControl(ctrlPtr);
-  canvas2.addControl(std::move(ctrlPtr)); // 内部 setParent(&canvas2)
-  ```
-
-#### Control::setDirty(bool dirty)
-
-- **用途：** 手动设置控件的“需要重绘”标记。当控件的内容或属性改变且希望立即刷新显示时，可调用此函数。
-
-- **参数：** `dirty` 布尔值，`true` 表示标记控件需要重绘，`false` 表示清除重绘标记。
-
-- **返回值：** 无。
-
-- **行为细节：** 将 `dirty` 设置为 `true` 后，会在下一次屏幕刷新时调用控件的 `draw()` 重新绘制。通常框架内部在控件属性变化时已经设置了该标记，例如调用 `setX()/setWidth()` 等修改位置尺寸的方法后，控件已被标记脏。开发者也可以在自定义场景下调用它，例如控件内部状态变化但没有对应的 setter 方法时。一般不需要将 `dirty` 手动置为 `false`，因为重绘后框架会自动清除该标记。
-
-- **示例：**
-
-  ```c++
-  ctrl.setDirty(true); // 请求ctrl控件重绘
-  ```
-
-#### Control::IsVisible() const
-
-- **用途：** 检查控件当前是否处于可见状态。
-
-- **参数：** 无。
-
-- **返回值：** `bool`，当前控件是否可见。`true` 表示可见，`false` 表示被隐藏。
-
-- **行为细节：** 该方法返回控件内部 `show` 标志位的状态。初始情况下控件默认为可见 (`true`)，如果通过 `setIsVisible(false)` 或控件所属父容器被隐藏，则此方法返回 `false`。当控件不可见时，其 `draw()` 将不会被调用。
-
-- **示例：**
-
-  ```c++
-  if (!ctrl.IsVisible())
-  {
-      ctrl.setIsVisible(true); // 确保控件可见
-  }
-  ```
-
-## Window 类 (应用主窗口)
-
-**描述：** `Window` 类代表应用程序的主窗口，它管理窗口的创建、消息循环以及全局的控件容器。`Window` 既负责初始化图形窗口（基于 EasyX），也是所有顶层控件的载体（充当它们的父级容器）。它处理系统事件的分发、定时重绘等，使用户只需关注向窗口添加控件和对事件作出响应。一个应用典型地只创建一个 `Window` 实例。
-
-**特性：**
-
-- 提供多种窗口初始化模式（如是否双缓冲、是否显示控制台等）以适应不同应用需求。
-- 支持设置窗口背景颜色或背景图片，以及窗口标题。
-- 内置**对话框管理**系统：跟踪已弹出的模态/非模态对话框，避免重复弹出相同对话框。
-- 集成完整的消息处理循环，自动分发事件给各控件的 `handleEvent()` 方法，并调度重绘各控件的 `draw()`。
-- 管理所有添加到窗口的控件和对话框的生命周期，在窗口销毁时自动清理。
-
-### 公共成员函数
-
-#### Window(int width, int height, int mode, COLORREF bkColor = BLACK, std::string headline = "窗口") (构造函数)
-
-- **用途：** 创建一个指定大小的应用程序窗口，并进行必要的图形初始化。可以指定窗口模式、背景颜色和窗口标题。
-
-- **参数：**
-
-  - `width`：窗口宽度（像素）。
-  - `height`：窗口高度（像素）。
-  - `mode`：窗口模式标志（int 类型）。不同的值可配置窗口属性，例如是否使用**双缓冲**绘图、是否显示控制台窗口等。典型地，0 表示默认（窗口模式，隐藏控制台），也可以使用 EasyX 提供的常量组合此参数，如 `EW_SHOWCONSOLE` 显示控制台，`EW_NOCLOSE` 禁止关闭按钮等。
-  - `bkColor` *(可选)*：窗口背景色，默认为黑色 (`BLACK`)。
-  - `headline` *(可选)*：窗口标题文本，默认为“窗口”。
-
-- **返回值：** 无（构造函数）。
-
-- **行为细节：** 构造 `Window` 对象时，会调用 EasyX 的图形初始化函数 `initgraph(width, height, mode)` 创建窗体，并自动应用提供的背景色以及设置窗口标题。如果模式开启了双缓冲，则框架会采用手动刷新机制。创建窗口后，**必须调用** `runEventLoop()` 进入消息循环，窗口才开始响应事件和绘制。
-
-- **示例：**
-
-  ```c++
-  // 创建800x600的窗口，双缓冲且显示控制台，背景为白色，标题为“示例”
-  int mode = EW_SHOWCONSOLE | EW_NOBORDER; // 仅示例模式组合
-  Window mainWin(800, 600, mode, WHITE, "示例");
-  mainWin.draw();
-  mainWin.runEventLoop();
-  ```
-
-#### Window::~Window() (析构函数)
-
-- **用途：** 销毁窗口对象并清理资源。
-
-- **参数：** 无。
-
-- **返回值：** 无。
-
-- **行为细节：** 当 `Window` 对象被销毁时，框架会自动关闭图形窗口、释放 EasyX 图形资源，并清理窗口中托管的控件和对话框对象。通常不需要显式调用，直接让 `Window` 对象离开作用域或程序结束时由系统回收。
-
-- **示例：**
-
-  ```c++
-  { 
-      Window win(400, 300, 0);
-      // ... 使用 win ...
-  } // 作用域结束，自动析构，窗口关闭
-  ```
-
-#### Window::runEventLoop()
-
-- **用途：** 进入窗口消息处理循环，启动 GUI 主事件循环。调用此函数后，窗口开始响应用户交互并持续运行，直到窗口关闭。
-
-- **参数：** 无。
-
-- **返回值：** `int`，窗口消息循环的退出代码（通常可直接返回给 `main()`）。
-
-- **行为细节：** 该函数内部实现一个典型的事件循环：不断调用 EasyX 的 `peekmessage()` 获取事件消息，并将其分发给窗口内各控件的 `handleEvent()` 方法处理。同时，它负责按需重绘：每帧遍历所有控件调用其 `draw()` 方法。在循环中窗口也会检查模态对话框的存在并阻止底层控件交互等。**必须**在创建窗口并添加控件后调用此方法，否则窗口将一片空白且无法交互。
-
-- **示例：**
-
-  ```c++
-  Window win(640, 480, EW_SHOWCONSOLE, LIGHTGRAY, "Demo");
-  // ... 添加控件等初始化 ...
-  wni.draw();
-  return win.runEventLoop(); // 进入事件循环，阻塞直到窗口关闭
-  ```
-
-#### Window::addControl(std::unique_ptr<Control> control)
-
-- **用途：** 将一个新控件添加到窗口中进行管理和显示。可以添加诸如按钮、文本框、容器等任何继承自 `Control` 的控件。
-
-- **参数：** `control` 为一个指向待添加控件的 `unique_ptr` 智能指针。函数内部会接管该指针的所有权。
-
-- **返回值：** 无。
-
-- **行为细节：** 添加控件时，窗口会将控件纳入内部维护的控件列表中，不会i调用控件的 `setParent()` 。此后框架每次重绘和事件处理都会考虑该控件。控件在窗口坐标系中的初始位置和尺寸取决于控件自身的属性。如果需要移除控件，目前可以通过 `clearAllControls()`（在 `Canvas` 中）或销毁窗口实现。
-
-- **示例：**
-
-  ```c++
-  auto btn = std::make_unique<Button>(50, 50, 80, 30, "OK");
-  mainWin.addControl(std::move(btn)); // 将按钮添加到主窗口显示
-  ```
-
-#### Window::addDialog(std::unique_ptr<Control> dialog)
-
-- **用途：** 弹出一个对话框控件并添加到窗口。当添加对话框时使用。
-
-- **参数：** `dialog` 是指向 `Dialog` 或其他对话框控件对象的 `unique_ptr`。
-
-- **返回值：** 无。
-
-- **行为细节：** 该函数类似于 `addControl()`，但专门用于对话框控件。窗口会将对话框添加到内部对话框列表，并在事件循环中给予特殊处理（例如当存在模态对话框时，阻止其他控件交互）。框架还提供防重复机制：如果即将添加的对话框在当前已经存在（通过对话框的标题和消息匹配），可以避免重复添加。通常不直接使用此函数来添加模态对话框——而是通过 `MessageBox::showModal()` 简化调用。
-
-- **示例：**
-
-  ```c++
-  auto dlg = std::make_unique<Dialog>(mainWin, "警告", "出现错误", MessageBoxType::OKCancel);
-  mainWin.addDialog(std::move(dlg)); // 非模态对话框，异步显示
-  ```
-
-#### Window::hasNonModalDialogWithCaption(const std::string& caption, const std::string& message) const
-
-- **用途：** 检查当前窗口中是否已经存在指定标题和内容的非模态对话框。
-
-- **参数：** `caption` 为对话框标题文本；`message` 为对话框显示的消息内容。
-
-- **返回值：** `bool`，存在相同标题和内容的非模态对话框则返回 `true`，否则返回 `false`。
-
-- **行为细节：** 此方法用于防止重复弹出相同的提示框。当调用 `MessageBox::showAsync()` 显示非模态对话框时，内部会利用该函数判断是否已有相同内容的对话框未关闭，从而避免界面上出现多个重复对话框。一般用户不需要直接调用它，但了解其存在有助于理解框架的防重复机制。
-
-- **示例：** （框架内部用法）
-
-  ```c++
-  if (!hasNonModalDialogWithCaption("警告", "出现错误"))
-  {
-      // 安全弹出新对话框
-      addDialog(std::make_unique<Dialog>(...));
-  }
-  ```
-
-#### Window::draw()
-
-- **用途：** 手动触发窗口内容重绘。
-
-- **参数：** 无。
-
-- **返回值：** 无。
-
-- **行为细节：** 默认情况下，框架每帧都会自动调用内部的绘制逻辑，所以一般无需手动调用此函数。但在某些特殊情况下（如希望强制立即重绘某些内容），可以调用 `mainWin.draw()`。该函数会遍历所有已添加到窗口的控件并调用其 `draw()` 方法进行绘制。如果使用了双缓冲模式，则 draw() 将在后台完成绘制并更新屏幕。
-
-- **示例：**
-
-  ```c++
-  // 改变背景后立即刷新窗口显示
-  mainWin.setBkcolor(WHITE);
-  mainWin.draw();
-  ```
-
-#### Window::draw(const std::string& pImgFile)
-
-- **用途：** 将指定的图像文件绘制为窗口背景并刷新显示。
-
-- **参数：** `pImgFile`，图像文件路径（string）。
-
-- **返回值：** 无。
-
-- **行为细节：** 此函数提供简便途径设置窗口背景图。调用时，函数会加载指定路径的图像并铺满窗口背景，然后调用窗口的其他控件的 `draw()` 进行正常绘制。相当于设置背景图片后立即刷新。若指定的文件无法加载或非有效图像，将保持原背景不变。
-
-- **示例：**
-
-  ```c++
-  mainWin.draw("background.jpg"); // 以background.jpg作为背景并重绘窗口
-  ```
-
-#### Window::setBkImage(const std::string& pImgFile)
-
-- **用途：** 设置窗口背景图片，但不会立即绘制。
-
-- **参数：** `pImgFile`，图像文件路径。
-
-- **返回值：** 无。
-
-- **行为细节：** 该方法更改窗口背景图设置，但不会自动触发重绘（需等待下一次事件循环刷新或调用 `draw()`）。如果需要立即生效，可配合 `draw()` 使用。设置空字符串或无效路径将取消背景图片，仅保留背景色。
-
-- **示例：**
-
-  ```c++
-  mainWin.setBkImage("bg.png");
-  // 下一帧自动绘制新背景，或手动 mainWin.draw();
-  ```
-
-#### Window::setBkcolor(COLORREF c)
-
-- **用途：** 设置窗口背景颜色。
-
-- **参数：** `c`，颜色值（COLORREF，例如 `WHITE`、`RGB(255,255,255)` 等）。
-
-- **返回值：** 无。
-
-- **行为细节：** 修改窗口背景色，新的背景色会在下一次刷新时生效。如果之前设置了背景图片，新颜色会被背景图覆盖（除非移除背景图）。一般在创建窗口时可以通过构造函数参数直接指定背景色，此函数用于运行期间动态更改背景色。
-
-- **示例：**
-
-  ```c++
-  mainWin.setBkcolor(LIGHTGRAY);
-  ```
-
-#### Window::setHeadline(const std::string& headline)
-
-- **用途：** 设置窗口标题栏文本。
-
-- **参数：** `headline`，字符串，新标题文本。
-
-- **返回值：** 无。
-
-- **行为细节：** 调用此函数将更改窗口的标题栏内容（通过 Win32 API 调用 `SetWindowText` 实现）。该更改是即时的，无需刷新循环。
-
-- **示例：**
-
-  ```c++
-  mainWin.setHeadline("处理完成");
-  ```
-
-### 获取属性方法（Getters）
-
-#### Window::getWidth() / getHeight()
-
-- **用途：** 获取窗口的当前宽度或高度。
-
-- **参数：** 无。
-
-- **返回值：** 窗口宽度或高度（int）。
-
-- **行为细节：** 该尺寸为窗口绘图区域的大小（与创建时指定的尺寸一致，除非窗口在运行中被拉伸）。如果窗口支持拉伸并被用户调整大小，这两个值会动态更新。
-
-- **示例：**
-
-  ```c++
-  int w = mainWin.getWidth();
-  int h = mainWin.getHeight();
-  ```
-
-#### Window::getHeadline()
-
-- **用途：** 获取窗口当前的标题文本。
-
-- **参数：** 无。
-
-- **返回值：** 标题字符串 (`std::string`)。
-
-- **行为细节：** 如果未设置则返回默认标题（创建时指定或默认的“窗口”）。
-
-- **示例：**
-
-  ```c++
-  std::string title = mainWin.getHeadline();
-  ```
-
-#### Window::getBkcolor()
-
-- **用途：** 获取窗口当前背景颜色值。
-
-- **参数：** 无。
-
-- **返回值：** 背景色 (`COLORREF`)。
-
-- **行为细节：** 如窗口正使用背景图片，该颜色通常仍然返回最近设置的颜色值，但当前绘制时被背景图覆盖。
-
-- **示例：**
-
-  ```c++
-  COLORREF c = mainWin.getBkcolor();
-  ```
-
-#### Window::getBkImage()
-
-- **用途：** 获取窗口当前使用的背景图像对象。
-
-- **参数：** 无。
-
-- **返回值：** 指向背景 `IMAGE` 对象的指针，若无背景图片则可能返回 `nullptr`。
-
-- **行为细节：** 返回的 `IMAGE*` 受窗口内部管理，**请勿修改或释放**。仅用于只读场景（如根据背景图大小做布局等）。
-
-- **示例：**
-
-  ```c++
-  IMAGE* bg = mainWin.getBkImage();
-  if(bg) 
-  {
-      // 例如：获取背景图宽高
-      int bgW = bg->getwidth();
-      int bgH = bg->getheight();
-  }
-  ```
-
-#### Window::getHwnd()
-
-- **用途：** 获取窗口的操作系统句柄 (`HWND`)。
-
-- **参数：** 无。
-
-- **返回值：** Windows 窗口句柄 (`HWND`)。
-
-- **行为细节：** 这个句柄可用于调用底层 Win32 API 以实现框架未提供的窗口级功能。通常不建议直接操作窗口句柄，除非高级需求（如修改窗口样式等）。
-
-- **示例：**
-
-  ```c++
-  HWND hWnd = mainWin.getHwnd();
-  // 调用 Win32 API，例如改变窗口图标:
-  SendMessage(hWnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
-  ```
-
-#### Window::getControls()
-
-- **用途：** 获取对窗口内所有顶级控件容器的引用列表。
-
-- **参数：** 无。
-
-- **返回值：** `std::vector<std::unique_ptr<Control>>&`，窗口管理的控件列表引用。
-
-- **行为细节：** 返回窗口内部维护的控件容器，可以遍历其中的元素指针来检查或调试当前有哪些控件已经添加。请勿尝试修改此列表（例如插入/删除），以免破坏框架内部状态。
-
-- **示例：**
-
-  ```c++
-  for(const auto& ctrl : mainWin.getControls())
-  {
-      std::cout << typeid(*ctrl).name() << std::endl;
-  }
-  ```
-
-## Canvas 类 (容器控件)
-
-**描述：** `Canvas` 是一个容器类控件，用于分组和管理子控件。它自身也是一个可见控件，可以绘制背景和边框。典型用途是作为**布局面板**：将多个子控件添加到 Canvas 中，由 Canvas 统一处理子控件的事件分发和绘制顺序。Canvas 支持多种布局模式（绝对定位或简单的水平/垂直布局），从而简化界面布局工作。
-
-**特性：**
-
-- 支持四种矩形形状（矩形、圆角矩形，以及各自的无边框版本）作为容器外观，可设置边框有无和圆角程度等。
-- 提供自定义的填充方式（纯色填充或背景图片）和边框样式（颜色、线型、线宽）。
-- 自动管理子控件：接管子控件的生命周期，在 Canvas 析构时自动销毁其中的控件；同时在事件发生时将事件传递给合适的子控件处理。
-- 支持嵌套容器结构：Canvas 本身也可作为另一个 Canvas 的子控件，实现复杂布局。
-- 简易布局能力：当前支持**绝对布局**（通过直接设置子控件坐标）。**水平盒子HBox/垂直盒子VBox布局**）、Grid、Flow、Stack 等布局类型目前预留。
-
-### 公共成员函数
-
-#### Canvas() / Canvas(int x, int y, int width, int height) (构造函数)
-
-- **用途：** 创建一个容器控件。可以使用默认构造函数创建一个不可见的 Canvas，然后通过属性进行设置；也可以直接指定位置和尺寸进行构造。
-
-- **参数：**
-
-  - `x, y`：Canvas 左上角在父容器中的坐标（int）。
-  - `width, height`：Canvas 初始宽度和高度（int）。
-
-- **返回值：** 无（构造函数）。
-
-- **行为细节：** 默认构造的 Canvas 初始化为0大小，需要手动设置尺寸；指定坐标/尺寸的构造函数则创建一个相应大小的可见容器。Canvas 默认布局模式为 `LayoutKind::Absolute`（绝对定位），可通过其 `layoutKind` 属性改变（当前仅支持 HBox/VBox）。构造完成后，可使用 `addControl()` 添加子控件。
-
-- **示例：**
-
-  ```c++
-  Canvas panel(50, 50, 300, 200); // 在父容器(或窗口)坐标(50,50)处建立300x200的面板
-  panel.setCanvasBkColor(LIGHTGRAY);
-  ```
-
-#### Canvas::addControl(std::unique_ptr<Control> control)
-
-- **用途：** 将一个控件添加到当前 Canvas 容器中。
-
-- **参数：** `control`，要添加的控件的 `unique_ptr`。
-
-- **返回值：** 无。
-
-- **行为细节：** 调用此函数会将子控件纳入 Canvas 的管理：Canvas 会将子控件指针存入内部列表，并自动调用 `control->setParent(this)` 设定父子关系。添加后，子控件的位置以 Canvas 的左上角为参考原点（即其 `getLocalX()/getLocalY()` 会以Canvas为基准）。Canvas 不会自动布局绝对定位的子控件——需要手动设置其坐标；但如果Canvas使用 HBox/VBox布局模式，则添加控件后会按布局规则重新排列子控件位置。
-
-- **示例：**
-
-  ```c++
-  auto txt = std::make_unique<Label>(0, 0, "Hello");
-  canvas.addControl(std::move(txt)); // Label 将添加到 canvas 容器内
-  ```
-
-#### Canvas::clearAllControls()
-
-- **用途：** 移除并销毁 Canvas 容器内的所有子控件。
-
-- **参数：** 无。
-
-- **返回值：** 无。
-
-- **行为细节：** 该方法会遍历并删除内部保存的每个子控件指针（智能指针会自动析构对象），然后清空列表。在需要动态刷新界面或更换整个面板内容时很有用。**注意：** 移除控件后，相应控件不再显示，且其内存会被释放。
-
-- **示例：**
-
-  ```c++
-  canvas.clearAllControls(); // 清空所有已添加的子控件
-  ```
-
-#### Canvas::setShape(StellarX::ControlShape shape)
-
-- **用途：** 设置 Canvas 容器的外形（形状和边框类型）。
-
-- **参数：** `shape`，`ControlShape` 枚举值，指定容器的形状和边框样式。
-
-- **返回值：** 无。
-
-- **行为细节：** `ControlShape` 定义了多种形状，如有边框矩形、无边框矩形、有边框圆角矩形、无边框圆角矩形、圆形/椭圆等。调用此方法会改变 Canvas 在绘制时的外轮廓形状（例如如果设为圆角矩形，则绘制圆角边框等）。默认形状为 `ControlShape::RECTANGLE`（有边框矩形）。设置后应将 Canvas 标记 `dirty` 以便下次重绘呈现新形状。
-
-- **示例：**
-
-  ```c++
-  canvas.setShape(StellarX::ControlShape::B_ROUND_RECTANGLE); // 设置为无边框圆角矩形
-  ```
-
-#### Canvas::setCanvasFillMode(StellarX::FillMode mode)
-
-- **用途：** 设置 Canvas 背景的填充模式。
-
-- **参数：** `mode`，`FillMode` 枚举值。该枚举定义了背景填充方式，如纯色填充 (`Solid`)、填充当前背景图 (`Image`)、使用网格/线条图案等。
-
-- **返回值：** 无。
-
-- **行为细节：** 缺省为纯色填充。如果设置为 `Image`，则 Canvas 会使用其当前设置的背景图像绘制自身背景（可通过 Canvas 继承的接口设置背景图）。修改填充模式后需要重绘以生效。
-
-- **示例：**
-
-  ```c++
-  canvas.setCanvasFillMode(StellarX::FillMode::Solid); // 背景纯色填充
-  ```
-
-#### Canvas::setBorderColor(COLORREF color)
-
-- **用途：** 设置 Canvas 边框颜色。
-
-- **参数：** `color`，颜色值 (`COLORREF`)。
-
-- **返回值：** 无。
-
-- **行为细节：** 仅当 Canvas 当前形状含有边框时（如 `RECTANGLE` 或 `ROUND_RECTANGLE` 等），此颜色才会在绘制时用于边框。默认边框颜色通常为黑色。
-
-- **示例：**
-
-  ```c++
-  canvas.setBorderColor(RGB(0, 128, 255)); // 边框设置为蓝色
-  ```
-
-#### Canvas::setCanvasBkColor(COLORREF color)
-
-- **用途：** 设置 Canvas 背景色。
-
-- **参数：** `color`，颜色值 (`COLORREF`)，将用作容器区域的背景填充颜色。
-
-- **返回值：** 无。
-
-- **行为细节：** 若当前填充模式为纯色，则此颜色将用于填充整个 Canvas 区域背景；如果填充模式为图像且无背景图可用，也会退化使用此颜色填充。更改背景色后，需要重绘 Canvas 才能看到效果（框架会自动标记重绘）。
-
-- **示例：**
-
-  ```c++
-  canvas.setCanvasBkColor(DARKGRAY);
-  ```
-
-#### Canvas::setCanvasLineStyle(StellarX::LineStyle style)
-
-- **用途：** 设置 Canvas 边框线条的样式。
-
-- **参数：** `style`，`LineStyle` 枚举值（实线、虚线、点线等）。
-
-- **返回值：** 无。
-
-- **行为细节：** 当 Canvas 绘制边框时，将使用指定的线型来绘制。该属性可影响边框的视觉效果，比如 `LineStyle::Solid` 是实线（默认），`LineStyle::Dash` 是虚线等。
-
-- **示例：**
-
-  ```c++
-  canvas.setCanvasLineStyle(StellarX::LineStyle::Dash);
-  ```
-
-#### Canvas::setLinewidth(int width)
-
-- **用途：** 设置 Canvas 边框线条的宽度（粗细）。
-
-- **参数：** `width`，线宽，单位像素。
-
-- **返回值：** 无。
-
-- **行为细节：** 边框宽度默认为1像素。设置较大的值可以绘制厚边框。若 Canvas 当前为无边框形状，则此设置暂不生效，直到形状切换为有边框类型。
-
-- **示例：**
-
-  ```c++
-  canvas.setLinewidth(3); // 边框加粗为3像素
-  ```
-
-#### Canvas::setIsVisible(bool visible) (override)
-
-- **用途：** 重载自 `Control::setIsVisible`，用于显示或隐藏整个容器以及其内的所有子控件。
-
-- **参数：** `visible` 布尔值，`true` 显示容器，`false` 隐藏容器。
-
-- **返回值：** 无。
-
-- **行为细节：** 除了改变自身的可见状态外，`Canvas::setIsVisible` 会对容器内的每个子控件调用相同的 `setIsVisible(visible)`，确保子控件的可见性与容器保持一致。也就是说，隐藏一个 Canvas 容器将递归地隐藏其所有内容，重新显示则会显示全部内容。
-
-- **示例：**
-
-  ```c++
-  canvas.setIsVisible(false); // 隐藏整个容器和子控件
-  ```
-
-#### Canvas::setDirty(bool dirty) (override)
-
-- **用途：** 重载自 `Control::setDirty`，将容器及其子控件标记为需要重绘。
-
-- **参数：** `dirty` 布尔值，`true` 标记需要重绘。
-
-- **返回值：** 无。
-
-- **行为细节：** 当对 Canvas 容器调用 `setDirty(true)` 时，Canvas 自身和它包含的所有子控件都会在下一帧进行重绘。这在容器整体移动或背景改变时非常有用。通常框架会自动处理大部分情况，开发者很少需要手动调用。
-
-- **示例：**
-
-  ```c++
-  canvas.setDirty(true); // 整个容器及子元素将在下一次刷新时重绘
-  ```
-
-#### Canvas::onWindowResize() (override)
-
-- **用途：** 重载 `Control::onWindowResize`，在父窗口大小改变时进行处理，并将通知传递给所有子控件。
-- **参数：** 无。
-- **返回值：** 无。
-- **行为细节：** `Canvas` 覆盖该方法以在窗口尺寸变化时：首先调用自身基类逻辑处理（例如丢弃背景快照），然后遍历调用所有子控件的 `onWindowResize()`，使子控件也能感知到窗口的变化。这可确保在窗口尺寸变化后，容器内部布局能够更新（例如 HBox/VBox 布局会在下次绘制时自动重新计算排列）。
-- **示例：** *该方法由框架自动调用，无需用户直接使用。*
-
-#### Canvas::model() const (override)
-
-- **用途：** 判断 Canvas 是否为模态对话框容器。此方法是 `Dialog` 类特有的接口，在 Canvas 中不适用，恒定返回 false。
-- **参数：** 无。
-- **返回值：** `false`。
-- **行为细节：** 普通 Canvas 不是对话框，所以这个方法始终返回 false。可以忽略。
-
-### 示例
-
-```c++
-// 创建一个 Canvas 容器并添加子控件示例
-Canvas panel(10, 10, 400, 300);
-panel.setCanvasBkColor(LIGHTGRAY);
-panel.setShape(StellarX::ControlShape::ROUND_RECTANGLE);
-panel.setLinewidth(2);
-panel.setBorderColor(BLACK);
-
-// 向 Canvas 添加几个按钮，假设已创建 mainWin Window
-auto btn1 = std::make_unique<Button>(20, 20, 80, 30, "Btn1");
-auto btn2 = std::make_unique<Button>(20, 60, 80, 30, "Btn2");
-panel.addControl(std::move(btn1));
-panel.addControl(std::move(btn2));
-
-// 将 Canvas 添加到主窗口
-mainWin.addControl(std::make_unique<Canvas>(panel));
-```
-
-## Label 类 (静态文本标签)
-
-**描述：** `Label` 是用于显示静态文本的控件，不可交互。它可以在界面上显示一段文字，支持设置文字颜色、背景颜色以及背景透明与否等样式属性。Label 适合作为界面上的说明文字、标题文本或提示信息等。其特点是重量轻、无额外事件处理开销。
-
-**特性：**
-
-- 支持背景透明或不透明两种显示模式，可根据需要在文字后显示控件下层背景。
-- 提供完整的文本样式控制：包括字体、字号、颜色、粗体/斜体等效果（通过公开的 `textStyle` 成员结构进行设置）。
-- Label 会根据其文本内容自动调整显示（例如计算文本所占区域大小，用于布局）。
-- Label 本身不处理用户输入事件，因此不会干扰其他控件的交互。绘制简单高效。
-
-### 公共成员函数
-
-#### Label() / Label(int x, int y, std::string text = "标签", COLORREF textColor = BLACK, COLORREF bkColor = RGB(255,255,255)) (构造函数)
-
-- **用途：** 创建一个文本标签控件。可以使用默认构造然后设置属性，或直接指定位置、文本和颜色进行构造。
-
-- **参数：**
-
-  - `x, y`：Label 左上角位置坐标。
-  - `text`：初始显示的文本内容（默认为“标签”）。
-  - `textColor`：文本颜色（可选，默认黑色）。
-  - `bkColor`：背景颜色（可选，默认白色）。
-
-- **返回值：** 无。
-
-- **行为细节：** 构造函数根据提供的信息初始化 Label。若使用默认构造，则须调用 `setText()` 等设置内容。Label 初始背景不透明，如果需要透明背景需调用 `setTextdisap(true)` 开启。位置坐标相对于父容器或窗口。
-
-- **示例：**
-
-  ```c++
-  Label title(100, 20, "Hello, World", BLACK, WHITE);
-  title.setTextdisap(true); // 背景透明
-  ```
-
-#### Label::setText(const std::string& text)
-
-- **用途：** 设置 Label 显示的文本内容。
-
-- **参数：** `text`，新的文本字符串。
-
-- **返回值：** 无。
-
-- **行为细节：** 更新 Label 的内部文本，并将控件标记为需要重绘以显示新文本。如果文本长度发生变化，Label 本身尺寸不会自动改变——Label 始终按最初设定的大小显示文本，超出范围的文本将被裁剪或换行（Label 本身不自动换行，需显式增加 `'\n'`）。
-
-- **示例：**
-
-  ```c++
-  label.setText("欢迎使用 StellarX!");
-  ```
-
-#### Label::setTextBkColor(COLORREF color)
-
-- **用途：** 设置 Label 文本背景矩形区域的填充颜色。
-
-- **参数：** `color`，颜色值。
-
-- **返回值：** 无。
-
-- **行为细节：** 当 Label 背景不透明时，会使用该颜色填充文字背景区域。默认为白色。若 Label 背景被设置为透明（见 `setTextdisap`），则此颜色不会被绘制。更改背景色后需要刷新控件以生效（框架会自动重绘下一帧）。
-
-- **示例：**
-
-  ```c++
-  label.setTextBkColor(LIGHTBLUE);
-  ```
-
-#### Label::setTextdisap(bool transparent)
-
-- **用途：** 切换 Label 背景的透明/不透明模式。
-
-- **参数：** `transparent`，布尔值。`true` 表示背景透明，`false` 表示不透明（使用背景色填充）。
-
-- **返回值：** 无。
-
-- **行为细节：** 背景透明模式下，Label 绘制文字时不会覆盖底下的内容，文字周围区域完全透明；非透明模式下，则用当前背景色填充 Label 区域再绘制文字。默认情况下 Label 背景为不透明。设置透明后可再次设置回不透明以恢复背景色填充。
-
-- **示例：**
-
-  ```c++
-  label.setTextdisap(true); // 启用背景透明
-  ```
-
-#### Label::hide()
-
-- **用途：** 隐藏该 Label 控件。
-
-- **参数：** 无。
-
-- **返回值：** 无。
-
-- **行为细节：** 调用后，Label 将不再可见，相当于对该控件调用 `setIsVisible(false)`。框架将在下一次刷新时不绘制该 Label。可以通过 `setIsVisible(true)` 或将 Label 再次添加到父容器等方式使其重新可见。
-
-- **示例：**
-
-  ```c++
-  label.hide();
-  ```
-
-### 公共成员变量
-
-- **textStyle** (`StellarX::ControlText`)：Label 文本样式结构体，公有成员。包含字体名称、高度、宽度、颜色、斜体/下划线等属性。可以直接修改其中的字段自定义文本外观，例如 `label.textStyle.color = RED;` 改变文字颜色。修改后应将 Label 标记为需要重绘。
-
-### 示例
-
-```c++
-Label nameLabel(20, 20, "Name:", BLACK, WHITE);
-nameLabel.setTextdisap(false);                // 背景不透明
-nameLabel.setTextBkColor(RGB(240,240,240));   // 浅灰背景
-nameLabel.textStyle.lpszFace = "Consolas";    // 改变字体
-nameLabel.textStyle.nHeight = 20;             // 字号20
-nameLabel.textStyle.color = RGB(80,80,80);    // 深灰文字
-// 此时Name标签将以Consolas字体深灰色显示在浅灰底上
-```
-
-## Button 类 (按钮控件)
-
-**描述：** `Button` 是一个功能丰富的按钮控件，支持多种状态（普通、悬停、按下、禁用）和模式（普通按钮或切换开关）。它可以响应用户的鼠标点击等交互并触发回调。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) (构造函数 1)
-
-- **用途：** 创建一个按钮控件，指定位置、尺寸、显示文本，可选按钮模式和形状。
-
-- **参数：**
-
-  - `x, y`：按钮左上角坐标。
-  - `width, height`：按钮宽度和高度。
-  - `text`：按钮上显示的文字（默认为空字符串，即无文字）。
-  - `mode`：按钮工作模式，`ButtonMode` 枚举，默认普通按钮 (`NORMAL`)，可设为 `TOGGLE`（切换按钮）。
-  - `shape`：按钮外形，`ControlShape` 枚举，默认有边框矩形。
-
-- **返回值：** 无。
-
-- **行为细节：** 此构造函数创建一个具有默认颜色方案的按钮。普通模式下按钮每次点击触发一次点击事件；切换模式下按钮具有“按下/释放”两种状态，每次点击切换状态。按钮形状参数决定按钮是圆形、矩形还是其他形状，并结合边框有无。
-
-- **示例：**
-
-  ```c++
-  Button okBtn(50, 100, 80, 30, "OK", ButtonMode::NORMAL, ControlShape::RECTANGLE);
-  ```
-
-#### Button(int x, int y, int width, int height, const std::string& text, COLORREF colorDefault, COLORREF colorPressed, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE) (构造函数 2)
-
-- **用途：** 创建一个按钮，并自定义其默认和按下状态的底色。
-
-- **参数：**
-
-  - 前四项 `x, y, width, height, text` 同上。
-  - `colorDefault`：按钮未被按下时的背景填充颜色。
-  - `colorPressed`：按钮被按下时的背景填充颜色。
-  - `mode`：按钮模式（默认普通）。
-  - `shape`：按钮形状（默认有边框矩形）。
-
-- **返回值：** 无。
-
-- **行为细节：** 按钮在不同状态下会采用不同颜色，此构造允许直接设置普通和按下两种状态的颜色。悬停状态默认会使用介于两者之间的一个中间色（或通过内部算法计算），可通过进一步函数调用调整。文本颜色默认黑色，可另行设置。
-
-- **示例：**
-
-  ```c++
-  Button toggleBtn(10, 10, 60, 25, "On/Off", GREEN, RED, ButtonMode::TOGGLE);
-  // 未按下显示绿色，按下显示红色
-  ```
-
-#### Button(int x, int y, int width, int height, const std::string& text, COLORREF colorDefault, COLORREF colorPressed, COLORREF colorHover, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE) (构造函数 3)
-
-- **用途：** 创建一个按钮，手动指定普通、按下、悬停三种状态下的背景颜色。
-
-- **参数：**
-
-  - 前五项同上（含 `text`）。
-  - `colorDefault`：默认背景色。
-  - `colorPressed`：按下时背景色。
-  - `colorHover`：鼠标悬停时背景色。
-  - `mode`：模式（默认普通）。
-  - `shape`：形状（默认矩形）。
-
-- **返回值：** 无。
-
-- **行为细节：** 提供了对三态颜色的完全控制。若未单独指定悬停色（使用前一个构造），按钮内部会自动生成一个悬停颜色；使用此构造则以提供的 `colorHover` 为准。其它属性同上。
-
-- **示例：**
-
-  ```c++
-  Button customBtn(100,100,100,40,"Custom", RGB(0,200,0), RGB(0,150,0), RGB(0,220,0));
-  ```
-
-#### Button::setOnClickListener(const std::function<void()>&& callback)
-
-- **用途：** 为按钮设置点击事件的回调函数。当按钮在普通模式下被点击（或在切换模式下从未按下状态点击）时，将调用此回调。
-
-- **参数：** `callback`，一个无参数、无返回值的函数对象（`std::function<void()>`），可以是lambda或函数指针等。
-
-- **返回值：** 无。
-
-- **行为细节：** 一旦设置回调，当用户用鼠标左键点击按钮且该按钮事件被识别时，框架将在处理事件时自动执行此回调函数。请确保回调中执行的操作不会阻塞过久（以免影响UI响应）。可多次调用此方法更改回调，以最后一次设置为准。
-
-- **示例：**
-
-  ```c++
-  okBtn.setOnClickListener([](){
-      std::cout << "OK button clicked!" << std::endl;
-  });
-  ```
-
-#### Button::setOnToggleOnListener(const std::function<void()>&& callback)
-
-- **用途：** 为**切换模式**按钮设置“开启”状态的回调。当按钮由非按下状态转变为按下状态（切换打开）时调用。
-
-- **参数：** `callback`，`std::function<void()>` 类型的回调。
-
-- **返回值：** 无。
-
-- **行为细节：** 仅当按钮模式为 `TOGGLE` 时有效。当用户点击按钮使其进入“按下”（ON）状态时执行。典型用途如切换某功能开启：可以在回调中实现“打开”动作逻辑。
-
-- **示例：**
-
-  ```c++
-  toggleBtn.setOnToggleOnListener([](){
-      turnFeatureOn();
-  });
-  ```
-
-#### Button::setOnToggleOffListener(const std::function<void()>&& callback)
-
-- **用途：** 为**切换模式**按钮设置“关闭”状态的回调。当按钮由按下状态变为弹起状态（切换关闭）时调用。
-
-- **参数：** `callback`，`std::function<void()>` 类型的回调。
-
-- **返回值：** 无。
-
-- **行为细节：** 仅用于 `TOGGLE` 模式按钮。当用户再次点击按钮使其从ON状态切换回OFF状态时执行。例如关闭某项功能的逻辑应放在此回调中。
-
-- **示例：**
-
-  ```c++
-  toggleBtn.setOnToggleOffListener([](){
-      turnFeatureOff();
-  });
-  ```
-
-#### Button::setTooltipOffset(int dx, int dy)
-
-- **用途：** 设置按钮悬停提示框（Tooltip）相对于鼠标位置的偏移量。
-
-- **参数：** `dx, dy`，分别为提示框在X轴和Y轴方向的偏移像素。
-
-- **返回值：** 无。
-
-- **行为细节：** 当按钮启用了悬停提示（Tooltip）时，默认的提示框会在鼠标指针右下偏移一段距离显示。通过此函数可自定义偏移，`dx, dy` 为正表示向右下偏移。
-
-- **示例：**
-
-  ```c++
-  btn.setTooltipOffset(10, 15); // 提示框相对鼠标再向右10、下15像素
-  ```
-
-#### Button::setTooltipStyle(COLORREF textColor, COLORREF bkColor, bool transparent)
-
-- **用途：** 设置按钮悬停提示框的文本颜色、背景颜色和背景透明属性。
-
-- **参数：**
-
-  - `textColor`：提示文本颜色。
-  - `bkColor`：提示框背景填充颜色。
-  - `transparent`：是否背景透明，`true` 则提示框背景透明只显示文字。
-
-- **返回值：** 无。
-
-- **行为细节：** 可以定制提示框的外观，比如设置文字白色、背景黑色等。如果设为背景透明，则 `bkColor` 不起作用。调用此函数会立即影响后续出现的提示框样式。默认提示框样式通常为浅黄色背景、黑字、不透明。
-
-- **示例：**
-
-  ```c++
-  btn.setTooltipStyle(WHITE, BLUE, false); // 提示框白字蓝底
-  ```
-
-#### Button::setTooltipText(const std::string& text)
-
-- **用途：** 设置按钮的提示文本内容。
-
-- **参数：** `text`，字符串，新提示内容。
-
-- **返回值：** 无。
-
-- **行为细节：** 当鼠标悬停在按钮上一定时间，会出现一个小提示框显示此文本。默认情况下，若未设置提示文本，则会使用按钮自身的 `text` 作为提示。调用此函数可指定不同的提示内容。设为空字符串则表示不显示提示。
-
-- **示例：**
-
-  ```c++
-  btn.setTooltipText("点击此按钮提交表单");
-  ```
-
-#### Button::setTooltipTextsForToggle(const std::string& onText, const std::string& offText)
-
-- **用途：** 为切换模式按钮分别设置“开启状态”和“关闭状态”下悬停提示的文本。
-
-- **参数：**
-
-  - `onText`：按钮被按下（ON）时的提示文字。
-  - `offText`：按钮弹起（OFF）时的提示文字。
-
-- **返回值：** 无。
-
-- **行为细节：** 切换按钮可能在两种状态下需要不同提示信息，例如ON状态提示“点击关闭XXX”，OFF状态提示“点击开启XXX”。调用此函数分别提供两种状态的提示内容。调用后会覆盖先前通过 `setTooltipText` 设置的统一提示。
-
-- **示例：**
-
-  ```c++
-  toggleBtn.setTooltipTextsForToggle("当前已打开，点击关闭", "当前已关闭，点击开启");
-  ```
-
-### 示例
-
-```c++
-// 创建并设置一个按钮
-Button sendBtn(50, 50, 100, 40, "Send", BLUE, LIGHTBLUE, ButtonMode::NORMAL);
-sendBtn.setOnClickListener([](){
-    sendMessage();
-});
-sendBtn.setTooltipText("发送消息"); 
-sendBtn.setTooltipStyle(WHITE, BLACK, false);
-```
-
-## TextBox 类 (文本框控件)
-
-**描述：** `TextBox` 是一个单行文本输入框控件，支持用户输入和编辑文本，也可配置为只读模式用于显示不可编辑的文本内容。内部集成 EasyX 的输入框功能来处理文本输入，同时提供一定程度的外观定制。典型用途包括获取用户名、搜索框等。
-
-**特性：**
-
-- **输入/只读模式：** 提供两种模式，输入模式允许用户点击后弹出系统输入框录入文字，只读模式则显示文本但禁止用户修改。
-- **最大长度限制：** 可以设置输入文本的最大字符数，避免溢出。
-- **系统输入框集成：** 使用 Windows 输入法保证输入兼容性，通过 EasyX 的 `InputBox` 来获取用户输入。
-- **多种形状：** 支持矩形、圆角矩形等变体作为文本框边框形状，满足UI风格需求。
-
-### 公共成员函数
-
-#### TextBox(int x, int y, int width, int height, const std::string& text = "", StellarX::TextBoxMode mode = StellarX::TextBoxMode::INPUT) (构造函数)
-
-- **用途：** 创建一个文本框控件，指定位置、尺寸、初始文字和模式（输入或只读）。
-
-- **参数：**
-
-  - `x, y`：文本框左上角坐标。
-  - `width, height`：文本框宽度和高度。
-  - `text`：初始文本内容，默认空。
-  - `mode`：文本框模式，`TextBoxMode` 枚举，默认为可输入模式 (`INPUT`)，可选 `READONLY`。
-
-- **返回值：** 无。
-
-- **行为细节：** 构造时可提供一个初始显示文本（比如提示“请输入...”，或已有内容），以及模式。如果是 READONLY，则文本框不会响应点击输入，仅用于显示。默认背景为白色、有边框矩形。用户点击输入模式的文本框时，框架会自动调用 EasyX 的 `InputBox` 弹出输入对话框获取文本。
-
-- **示例：**
-
-  ```c++
-  TextBox nameField(100, 80, 150, 25, "", TextBoxMode::INPUT);
-  ```
-
-#### TextBox::setText(const std::string& text)
-
-- **用途：** 设置文本框当前显示的文本内容。
-
-- **参数：** `text`，字符串，新文本。
-
-- **返回值：** 无。
-
-- **行为细节：** 直接更改文本框内容，不经过用户输入。常用于初始化文本框内容或在程序运行过程中更新显示。若文本框当前是只读模式，则仅仅改变显示文字；如果是可输入模式，用户稍后仍可编辑/覆盖该文本。
-
-- **示例：**
-
-  ```c++
-  nameField.setText("Guest");
-  ```
-
-#### TextBox::getText() const
-
-- **用途：** 获取文本框当前包含的文本内容。
-
-- **参数：** 无。
-
-- **返回值：** `std::string`，文本框内容。
-
-- **行为细节：** 当用户通过输入框修改了文本，这里可以获取最新结果。即使在只读模式下，该方法也可以用于取得当前显示文本。
-
-- **示例：**
-
-  ```c++
-  std::string input = nameField.getText();
-  ```
-
-#### TextBox::setMaxCharLen(size_t len)
-
-- **用途：** 设置文本框可输入的最大字符数限制。
-
-- **参数：** `len`，最大字符长度。
-
-- **返回值：** 无。
-
-- **行为细节：** 通过此方法可以限制用户输入过长的文本。当调用 EasyX 输入框时，会将该值作为参数，确保用户不能输入超过指定长度的字符串（超过部分会被截断）。默认为某个内部预设值（例如 64）。
-
-- **示例：**
-
-  ```c++
-  nameField.setMaxCharLen(20); // 限制最多输入20字符
-  ```
-
-#### TextBox::setMode(StellarX::TextBoxMode mode)
-
-- **用途：** 切换文本框的工作模式：输入 (INPUT) 或只读 (READONLY)。
-
-- **参数：** `mode`，`TextBoxMode` 枚举值。
-
-- **返回值：** 无。
-
-- **行为细节：** 运行时调用此函数可以将文本框由可编辑切换为只读，或反之。切换为只读模式将禁止用户点击激活输入；切换为输入模式则恢复可交互。改变模式不会影响当前文本内容。
-
-- **示例：**
-
-  ```c++
-  nameField.setMode(TextBoxMode::READONLY); // 禁止编辑
-  ```
-
-### 示例
-
-```c++
-TextBox inputField(50, 50, 200, 25, "请输入名字");
-inputField.setMaxCharLen(30);
-inputField.setOnClickListener([](){
-    // TextBox 本身不支持直接 setOnClickListener，但可通过 handleEvent 处理
-});
-std::string text = inputField.getText(); // 读取用户输入结果
-```
-
-## Dialog 类 (对话框控件)
-
-**描述：** `Dialog` 是一个对话框控件，可以包含一段提示文本和若干按钮选项，支持模态和非模态两种显示方式。Dialog 通常通过 `MessageBox` 类的静态方法来创建并显示。它封装了对话框窗口的布局、按钮响应以及返回结果等逻辑。对话框可用于显示消息、警告、错误提示等，并收集用户的确认/取消等操作。
-
-**特性：**
-
-- 提供六种标准对话框类型（OK、YesNo、YesNoCancel 等），方便快速生成常用的确认提示框。
-- 支持**模态**（阻塞调用者直到对话框关闭）和**非模态**（对话框显示的同时程序继续运行，并通过回调获取结果）两种模式。
-- 自动根据文本长度和按钮数量计算窗口大小和布局，不需手工调整。
-- 内置背景快照保存与恢复机制，使对话框弹出时界面不闪烁，在关闭时恢复原界面。
-- 在使用工厂方法 (`MessageBox`) 创建时，框架会自动防止重复弹出相同内容的对话框。
-
-### 公共成员函数
-
-#### Dialog(Window& parent, const std::string& caption, const std::string& message = "对话框", StellarX::MessageBoxType type = StellarX::MessageBoxType::OK) (构造函数)
-
-- **用途：** 创建一个对话框控件，指定所属父窗口、标题、消息内容和对话框类型（按钮组合）。
-- **参数：**
-  - `parent`：所属的主窗口引用。对话框将以此窗口为依附。
-  - `caption`：对话框标题文本。
-  - `message`：对话框主体消息文本。默认显示“对话框”。
-  - `type`：对话框类型，`MessageBoxType` 枚举值，决定包含哪些按钮选项（如 `OK`、`YesNo` 等）。默认是 OK 型只有一个确定按钮。
-- **返回值：** 无。
-- **行为细节：** 构造函数根据 `type` 创建相应数量和文本的按钮，并布局在对话框底部；将 `message` 文本放置在对话框中部区域显示。对话框本身是一个特殊的窗口内控件，位置通常在窗口中央。一般不直接调用构造函数生成对话框，而通过 `MessageBox::showModal` 或 `showAsync` 来创建并显示。
-- **示例：** *通常由 MessageBox 调用，无需直接使用。*
-
-#### Dialog::draw() (override)
-
-- **用途：** 绘制对话框，包括背景、文本和按钮。
-- **参数：** 无。
-- **返回值：** 无。
-- **行为细节：** `Dialog::draw()` 会绘制对话框自身的半透明背景遮罩（模态情况下）或边框，以及内部的消息文本和按钮控件。模态对话框绘制时会首先绘制窗口的背景快照，然后叠加对话框内容，以突出对话框。用户无需直接调用，由框架自动处理。
-
-#### Dialog::handleEvent(const ExMessage& msg) (override)
-
-- **用途：** 处理对话框内部的按钮点击等事件。
-- **参数：** `msg`，事件消息。
-- **返回值：** `bool`，指示事件是否被对话框消费。
-- **行为细节：** Dialog 实现的 `handleEvent` 会将点击事件分派给其包含的按钮，并根据按钮（如“确定”或“取消”）点击来设置对话框结果。如果对话框在模态显示，则点击后会结束模态循环返回结果；如果是非模态，则会通过事先注册的回调函数传递结果。
-
-#### Dialog::model() const (override)
-
-- **用途：** 指示对话框是否为模态。
-- **参数：** 无。
-- **返回值：** `bool`，模态对话框返回 true，非模态返回 false。
-- **行为细节：** 框架根据 Dialog 的创建方式设置这个标志。模态对话框在 `showModal` 中创建，非模态在 `showAsync` 创建。这个标志用于在事件循环中判断是否需要拦截底层窗口的其他控件事件（当存在模态对话框时，底层控件事件被暂停）。
-
-#### Dialog::getResult()
-
-- **用途：** 获取对话框的返回结果。
-- **参数：** 无。
-- **返回值：** `MessageBoxResult` 枚举值，表示用户在对话框上最后点击的按钮结果。如 OK、Cancel、Yes、No 等。
-- **行为细节：** 仅对模态对话框有意义。在模态 `MessageBox::showModal` 返回前，会将结果保存在 Dialog 对象中并返回给调用者。在非模态模式下结果通过回调获得，这个函数不被直接使用。
-
-### 示例
-
-```c++
-// （一般不直接使用Dialog类，而是通过MessageBox）
-// 这里演示非模态对话框的手动创建和添加：
-Dialog* dlg = new Dialog(mainWin, "标题", "内容", MessageBoxType::YesNo);
-mainWin.addDialog(std::unique_ptr<Dialog>(dlg));
-// Dialog 将显示，用户点击按钮后自动销毁。结果可通过 dlg->getResult() 查询或回调获取。
-```
-
-## MessageBox 工具类
-
-**描述：** `MessageBox` 提供简化的对话框创建接口，以**静态方法**的形式让用户快速弹出消息框，而不必直接操纵 `Dialog` 类。它支持模态对话框（阻塞式）和非模态对话框（异步通过回调）。典型调用非常简洁，例如一行代码即可弹出一个“确认”对话框等待用户点确定。
-
-**特性：**
-
-- 静态方法调用，无需实例化对象即可使用，方便全局调用。
-- 自动处理模态与非模态的区别逻辑；模态对话框会阻塞等待结果，非模态则立即返回并通过回调在用户选择后得到结果。
-- 与 `Window` 紧密集成：MessageBox 内部会使用主窗口的对话框管理机制，确保一个窗口内不会重复弹出相同内容的对话框。
-- 提供防重复弹出的机制：对于内容相同的非模态提示，第二次调用时可以选择不再弹出新的。
-
-### 公共静态函数
-
-#### MessageBox::showModal(Window& wnd, const std::string& text, const std::string& caption = "提示", MessageBoxType type = MessageBoxType::OK)
-
-- **用途：** 弹出一个**模态**对话框，阻塞当前线程直到用户关闭对话框，并返回用户选择的结果。
-
-- **参数：**
-
-  - `wnd`：所属的 `Window` 引用，指定在哪个主窗口中弹出对话框。
-  - `text`：对话框显示的主体消息文本。
-  - `caption`：对话框标题（可选，默认为“提示”）。
-  - `type`：对话框类型（可选，`MessageBoxType` 枚举，默认为 `OK` 类型）。
-
-- **返回值：** `MessageBoxResult` 枚举，表示用户点击的按钮结果。如 `MessageBoxResult::OK`、`MessageBoxResult::Cancel` 等。
-
-- **行为细节：** 该函数在内部创建一个 `Dialog` 对象，配置好内容和按钮后，以模态形式显示。调用线程将被阻塞，进入一个内部消息循环，只响应对话框相关事件，直到用户点击按钮或关闭对话框。然后函数返回相应结果。模态对话框期间，父窗口的其他控件将暂时失去响应（被遮罩）。这是一个同步调用，简单易用。
-
-- **示例：**
-
-  ```c++
-  MessageBoxResult res = MessageBox::showModal(mainWin, "确定要退出吗？", "退出确认", MessageBoxType::YesNo);
-  if(res == MessageBoxResult::Yes) {
-      // 用户选择是，执行退出逻辑
-  }
-  ```
-
-#### MessageBox::showAsync(Window& wnd, const std::string& text, const std::string& caption = "提示", MessageBoxType type = MessageBoxType::OK, std::function<void(MessageBoxResult)> onResult = nullptr)
-
-- **用途：** 以**非模态**方式弹出一个对话框，函数会立即返回，同时通过回调函数异步获取用户选择结果。
-
-- **参数：**
-
-  - `wnd`：所属的 `Window` 引用。
-  - `text`：消息文本。
-  - `caption`：标题文本（默认为“提示”）。
-  - `type`：对话框类型（默认为 OK）。
-  - `onResult`：结果回调，可选。类型为 `std::function<void(MessageBoxResult)>`。当用户点击按钮关闭对话框时，框架将调用此回调并传入结果。如果传入 `nullptr` 则不使用回调。
-
-- **返回值：** 无。
-
-- **行为细节：** 函数立即返回，调用线程不会阻塞。对话框以非模态形式显示，父窗口上的其它控件仍可交互（除非对话框独占区域）。当用户做出选择（点击按钮）或关闭对话框时，如果提供了回调，则调用之并传递结果枚举。同时，对话框对象自行销毁。内部使用 `Window::addDialog()` 添加对话框到窗口管理。框架具有**去重**机制：如果当前已有一个内容完全相同的非模态对话框未关闭，再次调用 `showAsync` 时将避免弹出新的（即函数会直接返回且不再创建新对话框）。
-
-- **示例：**
-
-  ```c++
-  MessageBox::showAsync(mainWin, "文件保存成功！", "通知", MessageBoxType::OK, 
-      [](MessageBoxResult res){
-          // 非模态对话框关闭时的回调逻辑
-          if(res == MessageBoxResult::OK) {
-              // 用户点了OK
-          }
-      });
-  ```
-
-## TabControl 类 (选项卡容器控件)
-
-**描述：** `TabControl` 是一个选项卡容器控件，管理"页签按钮 + 对应页面(Canvas)"的配对组合。它提供页签栏在四个方向的布局（上/下/左/右）、选中切换功能以及页内容区域的精确定位。该控件支持窗口大小变化时的自适应、可见性联动与脏区重绘，是在同一区域内承载多张页面的理想解决方案。
-
-**特性：**
-
-- **四向页签布局：** 支持页签栏在顶部、底部、左侧、右侧四种排列方式。
-- **页签-页面配对管理：** 每个选项卡由按钮页签和对应的Canvas页面组成，支持一键添加。
-- **智能切换机制：** 与Button的TOGGLE模式深度集成，点击页签自动显示/隐藏对应页面。
-- **自适应布局：** 自动计算页签和页面区域，响应窗口大小变化。
-- **子控件管理：** 支持为特定页签添加子控件，自动处理坐标转换。
-- **状态管理：** 提供当前激活页签的索引获取和设置功能。
-
-### 公共成员函数
-
-#### TabControl() (构造函数 1)
-
-- **用途：** 创建一个默认的TabControl控件，使用默认位置和尺寸。
-
-- **参数：** 无
-
-- **返回值：** 无
-
-- **行为细节：** 此构造函数创建一个位置和尺寸为默认值的TabControl。控件ID设置为"TabControl"，页签默认排列在顶部，页签栏高度使用默认值。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  TabControl tabCtrl;
-  ```
-
-  
-
-#### TabControl(int x, int y, int width, int height) (构造函数 2)
-
-- **用途：** 创建一个指定位置和尺寸的TabControl控件。
-
-- **参数：**
-
-  - `x, y`：控件左上角坐标
-  - `width, height`：控件的宽度和高度
-
-- **返回值：** 无
-
-- **行为细节：** 使用指定位置和尺寸创建TabControl，控件ID设置为"TabControl"，页签默认排列在顶部，页签栏高度使用默认值。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  TabControl tabCtrl(10, 10, 400, 300);
-  ```
-
-  
-
-#### ~TabControl() (析构函数)
-
-- **用途：** 销毁TabControl实例并释放相关资源。
-- **参数：** 无
-- **返回值：** 无
-- **行为细节：** 自动清理所有页签按钮和页面Canvas对象，确保无内存泄漏。
-
-#### void draw() override
-
-- **用途：** 绘制TabControl及其所有子控件。
-
-- **参数：** 无
-
-- **返回值：** 无
-
-- **行为细节：** 重写Canvas的draw方法。首先检查脏标志和可见性，如果需要重绘，则先保存/恢复背景，然后调用基类绘制方法，最后绘制所有页签按钮和当前可见的页面。绘制完成后重置脏标志。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  tabCtrl.draw();
-  ```
-
-  
-
-#### bool handleEvent(const ExMessage& msg) override
-
-- **用途：** 处理输入事件并分发给子控件。
-
-- **参数：**
-
-  - `msg`：输入事件消息
-
-- **返回值：** `bool` - 如果事件被消费返回true，否则返回false
-
-- **行为细节：** 将事件依次传递给所有页签按钮和当前可见的页面进行处理。如果有任何子控件消费了事件，则立即返回true。如果控件状态变脏，会请求重绘。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  ExMessage msg;
-  if (tabCtrl.handleEvent(msg))
-  {
-      // 事件已被处理
-  }
-  ```
-
-  
-
-#### void add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>&& control)
-
-- **用途：** 添加一个页签和对应的页面到TabControl。
-
-- **参数：**
-
-  - `control`：包含按钮页签和Canvas页面的pair对象，使用移动语义传递
-
-- **返回值：** 无
-
-- **行为细节：** 将新的页签-页面对添加到控件列表中，初始化页签栏和页面布局。为新页签设置父控件、启用工具提示、设置为切换模式，并注册切换状态的监听器。新添加的页面默认不可见。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  auto tabPair = std::make_pair(std::make_unique<Button>(), std::make_unique<Canvas>());
-  tabPair.first->setButtonText("Tab 1");
-  tabCtrl.add(std::move(tabPair));
-  ```
-
-  
-
-#### void add(std::string tabText, std::unique_ptr<Control> control)
-
-- **用途：** 为指定页签添加子控件。
-
-- **参数：**
-
-  - `tabText`：目标页签的文本标识
-  - `control`：要添加的子控件
-
-- **返回值：** 无
-
-- **行为细节：** 根据页签文本查找对应的页面Canvas，将子控件添加到该页面中。子控件的可见性会与目标页面同步。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  auto button = std::make_unique<Button>(20, 20, 80, 30, "Click me");
-  tabCtrl.add("Tab 1", std::move(button));
-  ```
-
-  
-
-#### void setTabPlacement(StellarX::TabPlacement placement)
-
-- **用途：** 设置页签的排列位置。
-
-- **参数：**
-
-  - `placement`：页签排列方式，为TabPlacement枚举值
-
-- **返回值：** 无
-
-- **行为细节：** 设置页签在顶部、底部、左侧或右侧排列，会触发页签栏和页面的重新布局，并标记控件为脏状态需要重绘。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  tabCtrl.setTabPlacement(StellarX::TabPlacement::Left);
-  ```
-
-  
-
-#### void setTabBarHeight(int height)
-
-- **用途：** 设置页签栏的高度（对于左右排列时为宽度）。
-
-- **参数：**
-
-  - `height`：页签栏的新高度值
-
-- **返回值：** 无
-
-- **行为细节：** 修改页签栏的尺寸，触发页签栏和页面的重新布局，并标记控件为脏状态需要重绘。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  tabCtrl.setTabBarHeight(30);
-  ```
-
-  
-
-#### void setIsVisible(bool visible) override
-
-- **用途：** 设置控件的可见性，并同步所有子控件的可见状态。
-
-- **参数：**
-
-  - `visible`：是否可见
-
-- **返回值：** 无
-
-- **行为细节：** 重写基类方法，首先调用Canvas的setIsVisible处理背景快照逻辑，然后设置自身可见性，最后同步所有页签按钮和页面的可见状态。页面设为不可见时会清除其背景快照。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  tabCtrl.setIsVisible(false); // 隐藏整个TabControl及其所有子控件
-  ```
-
-  
-
-#### void onWindowResize() override
-
-- **用途：** 响应窗口大小变化事件。
-
-- **参数：** 无
-
-- **返回值：** 无
-
-- **行为细节：** 重写基类方法，调用父类的窗口大小变化处理，然后通知所有页签按钮和页面进行自适应调整。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  tabCtrl.onWindowResize();
-  ```
-
-  
-
-#### int getActiveIndex() const
-
-- **用途：** 获取当前激活页签的索引。
-
-- **参数：** 无
-
-- **返回值：** `int` - 当前激活页签的索引，如果没有激活的页签返回-1
-
-- **行为细节：** 遍历所有页签按钮，返回第一个处于点击状态（激活状态）的页签索引。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  int activeIndex = tabCtrl.getActiveIndex();
-  ```
-
-  
-
-#### void setActiveIndex(int idx)
-
-- **用途：** 设置指定索引的页签为激活状态。
-
-- **参数：**
-
-  - `idx`：要激活的页签索引
-
-- **返回值：** 无
-
-- **行为细节：** 如果索引有效且对应页签未被禁用，则将其设置为激活状态。如果页签已经是激活状态但页面不可见，会显示页面；如果不是激活状态，则模拟点击激活它。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  tabCtrl.setActiveIndex(2); // 激活第三个页签
-  ```
-
-  
-
-#### int count() const
-
-- **用途：** 获取TabControl中的页签数量。
-
-- **参数：** 无
-
-- **返回值：** `int` - 页签的总数
-
-- **行为细节：** 返回控件中页签-页面对的数量。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  int tabCount = tabCtrl.count();
-  ```
-
-  
-
-#### int indexOf(const std::string& tabText) const
-
-- **用途：** 通过页签文本查找对应的索引。
-
-- **参数：**
-
-  - `tabText`：要查找的页签文本
-
-- **返回值：** `int` - 匹配页签的索引，如果未找到返回-1
-
-- **行为细节：** 遍历所有页签按钮，比较按钮文本与目标文本，返回第一个匹配的页签索引。
-
-- **示例：**
-
-  c++
-
-  ```c++
-  int index = tabCtrl.indexOf("Settings");
-  ```
-
-  
-
-#### 使用示例
-
-c++
-
-```c++
-//创建选项卡控件
-auto ta = std::make_unique<TabControl>(10, 10, 950, 240);
-//创建页签按钮
-auto but = std::make_unique<Button>(0, 0, 100, 15, "按钮1");
-//创建一个pair用来包页签和页整体添加到选项卡
-std::pair<std::unique_ptr<Button>,std::unique_ptr<Canvas>> p;
-p.first =std::move( but);
-p.second = std::make_unique<Canvas>(200, 200, 100, 100);
-p.second->setCanvasBkColor(RGB(0,255,0));
-p.second->addControl(std::move(table));
-
-std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>> p1;
-p1.first = std::make_unique<Button>(0, 0, 100, 15, "按钮2");
-p1.second = std::make_unique<Canvas>(200, 200, 100, 100);
-p1.second->setCanvasBkColor(RGB(255,200,0));
-//设置页签栏位置
-ta->setTabPlacement(StellarX::TabPlacement::Bottom);
-//为选项卡添加控件
-ta->add(std::move(p))；
-ta->add(std::move(p1));
-ta->setCanvasfillMode(StellarX::FillMode::Null);
-//将选项卡添加到窗口控件列表
-mainWindow.addControl(std::move(ta));
-```
\ No newline at end of file
diff --git a/CHANGELOG.en.md b/CHANGELOG.en.md
index ddf601e..81eb593 100644
--- a/CHANGELOG.en.md
+++ b/CHANGELOG.en.md
@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [中文文档](CHANGELOG.md)
 
+## [v2.3.0] - 2025-11-18
+
+### ✨ Added
+
+- Introduced `LayoutMode` adaptive layout mode and `Anchor` anchor points. Controls can now call `setLayoutMode` to set layout mode and `steAnchor` to set anchor points, enabling controls to adapt to window changes during resizing. Dialog controls only recalculate their position during window resizing to maintain center alignment.
+- Added `adaptiveLayout()` API to `Window`, called by the main event loop to recalculate control positions and sizes based on anchor points during window resizing, enabling dual-anchored controls (left-right or top-bottom) to automatically stretch with window changes.
+
+### ⚙️ Changed
+
+- **Optimized Window Resizing Mechanism**: Refactored `WndProcThunk`, `runEventLoop`, and `pumpResizeIfNeeded` to uniformly record window size changes and perform one-time repainting at the end of the event loop, preventing jitter and sequencing issues caused by repeated drawing during resizing.
+- **Added Dialog Size Scheduling Interface**: Introduced `Window::scheduleResizeFromModal()`, used in conjunction with `pumpResizeIfNeeded()`. During modal dialog display, the parent window can update client area size in real time and relayout child controls during unified finalization, while the dialog maintains its original size.
+- **Redraw Sequence Optimization**: Replaced `InvalidateRect` with `ValidateRect` during the finalization phase after window size changes, preventing the system from sending additional `WM_PAINT` messages that could cause reentrant drawing.
+- **Other Improvements**: Fixed delayed background snapshot updates for table pagination buttons and page number labels; improved dialog background capture logic.
+
+### ✅ Fixed
+
+- **Modal Dialog Resizing Fix**: Resolved the issue where window resizing during modal dialog display prevented underlying controls from updating their sizes and positions according to anchor points; simultaneously eliminated ghosting artifacts caused by repeated dialog redrawing.
+- **Drawing Sequence Disorder Fix**: Addressed sporadic drawing sequence disorders, control ghosting, and border flickering during window resizing, ensuring controls are drawn in the order they were added.
+- **Stability Fixes**: Corrected abnormal frames caused by sudden window size changes in certain scenarios; resolved delayed background snapshot updates for tables and dialogs under edge conditions.
+
 ## [v2.2.2] - 2025 - 11- 08
 
 ### ⚙️ Changes
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bee759e..e27f0a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,27 @@ StellarX 项目所有显著的变化都将被记录在这个文件中。
 
 [English document](CHANGELOG.en.md)
 
+## [v2.3.0] - 2025 - 11 - 18
+
+### ✨ 新增
+
+- 新增`LayoutMode `自适应布局模式和`Anchor`锚点，控件中可以调用 `setLayoutMode`
+   设置布局模式以及`steAnchor`设置锚点，达到窗口拉伸时控件自适应窗口变化。对话框控件在窗口变化时只会重新计算位置，来保证居中显示
+- `Window`新增`adaptiveLayout()`这个API由主事件循环调用，在窗口拉伸时根据锚点重新计算控件位置和尺寸，使左右/上下双锚定控件随窗口变化自动伸缩。
+
+### ⚙️ 变更
+
+- **优化窗口尺寸调整机制**：重构 `WndProcThunk`、`runEventLoop` 和 `pumpResizeIfNeeded`，统一记录窗口尺寸变化并在事件循环尾部一次性重绘，避免拉伸过程中重复绘制引发抖动与顺序错乱。
+- **新增对话框尺寸调度接口**：引入 `Window::scheduleResizeFromModal()`，配合 `pumpResizeIfNeeded()` 使用。模态对话框显示期间，父窗口可实时更新客户区尺寸并在统一收口时重新布局子控件，对话框自身尺寸保持不变。
+- **重绘顺序优化**：在窗口尺寸变化后的收口阶段使用 `ValidateRect` 代替 `InvalidateRect`，避免系统再次发送 `WM_PAINT` 导致重入绘制。
+- **其他改进**：修复表格翻页按钮与页码标签等元素背景快照更新不及时的问题；改进对话框背景捕捉逻辑。
+
+### ✅ 修复
+
+- **模态对话框拉伸修复**：解决了模态对话框弹出时，窗口拉伸无法让底层控件按照锚点更新尺寸和位置的问题；同时避免对话框反复重绘导致残影。
+- **绘制顺序错乱修复**：解决窗口拉伸时偶发的绘制顺序紊乱、控件残影和边框闪烁问题，确保控件按添加顺序依次绘制。
+- **稳定性修复**：修正某些情况下窗口尺寸突变导致的异常帧；解决表格和对话框背景快照在边界条件下未及时更新的问题。
+
 ## [v2.2.2] - 2025 - 11- 08
 
 ### ⚙️ 变更
diff --git a/README.en.md b/README.en.md
index 6a414ed..4d4ae44 100644
--- a/README.en.md
+++ b/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.2.1-brightgreen.svg)
- ![Download](https://img.shields.io/badge/Download-2.2.1_Release-blue.svg)
+![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)
 
 ![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,12 +25,25 @@ This is a **teaching-grade and tooling-grade** framework that helps developers u
 
 ------
 
-## 🆕 v2.2.2 — Stable Release
+## 🆕 V2.3.0 - Major Update
 
-- In the next planned update, control states will synchronize in real-time during window resizing operations.
-- Modified the coordinate transfer method for Canvas containers. Child control coordinates are now passed as relative coordinates (with the origin at the top-left corner of the container, obtainable via the `getX`/`getY` interface) instead of global coordinates. Child control coordinates can now be set to negative values.
-- The example under `examples\register-viewer` has been updated to the latest version, aligning container child controls to use relative coordinates.
-- Addressed issues related to window resizing and dialog boxes as mentioned above.
+**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).
 
@@ -174,6 +187,11 @@ int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
 | `MessageBoxResult` | Result           | `OK`, `Cancel`, `Yes`, `No`, `Abort`, `Retry`, `Ignore`      |
 | `TabPlacement`     | Tab position     | `Top`, `Bottom`, `Left`, `Right`                             |
 
+| Enum         | Description            | Common values                                |
+| ------------ | ---------------------- | -------------------------------------------- |
+| `LayoutMode` | 窗口布局模式           | `Fixed`,  `AnchorToEdges`                    |
+| `Anchor`     | 控件相对于父容器的锚点 | `NoAnchor` ,`Left` , `Right`, `Top`,`Bottom` |
+
 ### Structs
 
 | Struct         | Description                                          |
diff --git a/README.md b/README.md
index 6f8300c..f6fceb9 100644
--- a/README.md
+++ b/README.md
@@ -12,8 +12,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.2.1-brightgreen.svg)
-![Download](https://img.shields.io/badge/Download-2.2.1_Release-blue.svg)
+![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)
 
 ![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,14 +30,27 @@
 
 ---
 
-## 🆕v2.2.2 ——稳定版本
+## 🆕V2.3.0——重要更新
 
-- 预计下次版本更新，将同步窗口拉伸时，控件同步更新状态
+**本版本是一次重大更新，增加了响应式布局系统，由静态布局转变为动态布局，并且彻底修复了之前存在的由重入重绘导致的概率出现的渲染错乱问题**
 
-- Canvas容器坐标传递方式改变，子控件坐标由原来的传递全局坐标改为传递相对坐标（坐标原点为容器的左上角坐标可通过getX/Y接口获得）可以设置子控件坐标为负值
-- examples\register-viewer下的案例已同步修改为最新，同步容器子控件为相对坐标
-- 对于窗口拉伸和对话框问题进行了修复
-- 详情参考[更新日志](CHANGELOG.md)
+- **优化窗口尺寸调节机制**：重构 `WndProcThunk`、`runEventLoop` 和 `pumpResizeIfNeeded`，统一记录尺寸变化并在事件循环末尾集中重绘，避免重复重绘导致的抖动和顺序错乱。
+
+- **新增对话框尺寸调度接口**：引入 `Window::scheduleResizeFromModal()` 与 `pumpResizeIfNeeded()` 的组合，模态对话框在拉伸期间也可通知父窗口更新尺寸。底层控件将在统一收口时重新布局，而对话框自身保持尺寸不变。
+
+- **自适应布局改进**：内部新增 `adaptiveLayout()` 函数，按照锚点重新计算控件位置和尺寸，使双锚定（左右或上下）控件随窗口变化自适应伸缩。
+
+- **修复模态对话框拉伸问题**：解决模态对话框打开时，窗口拉伸导致底层控件无法根据锚点更新的位置和尺寸的问题；同时避免对话框反复重绘导致的残影。
+
+- **进一步解决绘制顺序错乱**：拉伸过程中采用 `ValidateRect` 替代 `InvalidateRect`，确保窗口仅在一次统一收口绘制后标记为有效，杜绝系统再次触发 `WM_PAINT` 造成重入。
+
+- 其他修复：修正表格和对话框背景快照某些边界情况下的更新不及时问题。
+
+  ![](image/1.png)
+
+![](image/2.png)
+
+详细变更请参阅[更新日志](CHANGELOG.md)
 
 ---
 
@@ -179,6 +192,13 @@ int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
 | `MessageBoxResult` | 结果       | `OK`, `Cancel`, `Yes`, `No`, `Abort`, `Retry`, `Ignore`      |
 | `TabPlacement`     | 页签位置   | `Top`,`Bottom`,`Left`,`Right`                                |
 
+| 枚举         | 描述                   | 常用值                                       |
+| ------------ | ---------------------- | -------------------------------------------- |
+| `LayoutMode` | 窗口布局模式           | `Fixed`,  `AnchorToEdges`                    |
+| Anchor       | 控件相对于父容器的锚点 | `NoAnchor` ,`Left` , `Right`, `Top`,`Bottom` |
+
+
+
 ### 结构体
 
 | 结构体         | 描述                                   |
diff --git a/examples/register-viewer/main.cpp b/examples/register-viewer/main.cpp
index 3211ca8..8b71660 100644
--- a/examples/register-viewer/main.cpp
+++ b/examples/register-viewer/main.cpp
@@ -90,12 +90,18 @@ int main()
 		selectionArea->addControl(std::move(s));
 	//功能区控件
 	//功能区总容器
-	auto function = std::make_unique<Canvas>(0, 0, 0, 0);
+	auto function = std::make_unique<Canvas>(10, 170, 680, 70);
 	function->setCanvasfillMode(StellarX::FillMode::Null);
+	function->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
+	function->setCanvasBkColor(blackColor);
+	auto bitInvert_que = std::make_unique<Canvas>(0, 0, 220, 70);
+	auto leftShift_que = std::make_unique<Canvas>(230, 0, 220, 70);
+	auto rightShift_que = std::make_unique<Canvas>(460, 0, 220, 70);
+
+	auto bitInvert = bitInvert_que.get();
+	auto leftShift = leftShift_que.get();
+	auto rightShift = rightShift_que.get();
 
-	auto bitInvert = std::make_unique<Canvas>(10, 170, 220, 70);
-	auto leftShift = std::make_unique<Canvas>(240, 170, 220, 70);
-	auto rightShift = std::make_unique<Canvas>(470, 170, 220, 70);
 	bitInvert->setCanvasBkColor(blackColor);
 	bitInvert->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
 	leftShift->setCanvasBkColor(blackColor);
@@ -103,6 +109,9 @@ int main()
 	rightShift->setCanvasBkColor(blackColor);
 	rightShift->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
 
+	function->addControl(std::move(bitInvert_que));
+	function->addControl(std::move(leftShift_que));
+	function->addControl(std::move(rightShift_que));
 
 	auto bitInvertLabel = std::make_unique<Label>(13, -10, "位取反");
 	bitInvertLabel->setTextdisap(true);
@@ -139,7 +148,7 @@ int main()
 
 	//取反区控件
 	std::array<std::unique_ptr<Label>, 4> bitInvertFunctionLabel;
-	bitInvertFunctionLabel[0] = std::make_unique<Label>(35, 10, "低位");
+	bitInvertFunctionLabel[0] = std::make_unique<Label>(30, 10, "低位");
 	bitInvertFunctionLabel[1] = std::make_unique<Label>(90, 10, "高位");
 	bitInvertFunctionLabel[2] = std::make_unique<Label>(15, 38, "从");
 	bitInvertFunctionLabel[3] = std::make_unique<Label>(75, 38, "到");
@@ -217,9 +226,6 @@ int main()
 	rightShift->addControl(std::move(rightShiftLabel));
 	rightShift->addControl(std::move(rightShiftFunctionLabel));
 
-	function->addControl(std::move(bitInvert));
-	function->addControl(std::move(leftShift));
-	function->addControl(std::move(rightShift));
 
 	//显示区控件
 	//数值显示
@@ -428,7 +434,7 @@ int main()
 	signedTogglePtr->setOnToggleOnListener([&]() {
 		gSigned = true;
 		signedTogglePtr->setButtonText("有符号");
-		StellarX::MessageBox::showAsync(mainWindow, "有符号模式下，\n最高位为符号位，\n其余位为数值位。", "有符号模式");
+		StellarX::MessageBox::showModal(mainWindow, "有符号模式下，\n最高位为符号位，\n其余位为数值位。", "有符号模式");
 		// 立即刷新十进制显示：用当前位图算出新值，仅改 dec
 		auto cur = snapshotBits();
 		const uint32_t u = [&] { uint32_t v = 0; for (int b = 0; b < 32; ++b) if (cur[b]) v |= (1u << b); return v; }();
@@ -443,6 +449,7 @@ int main()
 		const uint32_t u = [&] { uint32_t v = 0; for (int b = 0; b < 32; ++b) if (cur[b]) v |= (1u << b); return v; }();
 		dec->setText(std::to_string(u));
 		});
+
 	signedTogglePtr->enableTooltip(true);
 	signedTogglePtr->setTooltipTextsForToggle("切换无符号模式", "切换有符号模式");
 
@@ -451,7 +458,6 @@ int main()
 	configuration->addControl(std::move(signedToggle));
 	configuration->addControl(std::move(configurationLabel));
 
-
 	mainWindow.addControl(std::move(selectionArea));
 	mainWindow.addControl(std::move(function));
 	mainWindow.addControl(std::move(NumericalDisplayArea));
@@ -460,4 +466,4 @@ int main()
 
 	mainWindow.draw();
 	return mainWindow.runEventLoop();
-}
+}
\ No newline at end of file
diff --git a/image/1.png b/image/1.png
new file mode 100644
index 0000000..7517b05
Binary files /dev/null and b/image/1.png differ
diff --git a/image/2.png b/image/2.png
new file mode 100644
index 0000000..80f508a
Binary files /dev/null and b/image/2.png differ
diff --git a/include/StellarX/Canvas.h b/include/StellarX/Canvas.h
index 0b5003a..ca0da44 100644
--- a/include/StellarX/Canvas.h
+++ b/include/StellarX/Canvas.h
@@ -18,6 +18,7 @@
 
 #pragma once
 #include "Control.h"
+#include"Table.h"
 
 class Canvas : public Control
 {
@@ -39,6 +40,7 @@ public:
     Canvas();
     Canvas(int x, int y, int width, int height);
     ~Canvas() {}
+
     //绘制容器及其子控件
     void draw() override;
     bool handleEvent(const ExMessage& msg) override;
diff --git a/include/StellarX/Control.h b/include/StellarX/Control.h
index f2d621d..05ef525 100644
--- a/include/StellarX/Control.h
+++ b/include/StellarX/Control.h
@@ -42,6 +42,11 @@ protected:
     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::Left; // 锚点
+
     /* == 背景快照 ==  */
     IMAGE* saveBkImage = nullptr;
     int saveBkX = 0, saveBkY = 0;      // 快照保存起始坐标
@@ -115,8 +120,8 @@ public:
 
     void setX(int x) { this->x = x; dirty = true; }
     void setY(int y) { this->y = y; dirty = true; }
-    void setWidth(int width) { this->width = width; dirty = true; }
-    void setHeight(int height) { this->height = height; 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;
@@ -127,7 +132,6 @@ public:
     void setParent(Control* parent) { this->parent = parent; }
     //设置是否重绘
     virtual void setDirty(bool dirty) { this->dirty = dirty; }
-
     //检查控件是否可见
     bool IsVisible() const { return show; };
     //获取控件id
@@ -136,6 +140,12 @@ public:
     bool isDirty() { return dirty; }
     //用来检查对话框是否模态，其他控件不用实现
     virtual bool model()const = 0;
+    //布局
+    void setLayoutMode(StellarX::LayoutMode layoutMode_);
+    void steAnchor(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();
diff --git a/include/StellarX/CoreTypes.h b/include/StellarX/CoreTypes.h
index cf451f3..3038717 100644
--- a/include/StellarX/CoreTypes.h
+++ b/include/StellarX/CoreTypes.h
@@ -343,4 +343,47 @@ namespace StellarX
         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
+    };
 }
\ No newline at end of file
diff --git a/include/StellarX/StellarX.h b/include/StellarX/StellarX.h
index 2d23b67..55f5a5d 100644
--- a/include/StellarX/StellarX.h
+++ b/include/StellarX/StellarX.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * @文件: StellarX.h
  * @摘要: 星垣(StellarX) GUI框架 - 主包含头文件
- * @版本: v2.2.2
+ * @版本: v2.3.0
  * @描述:
  *     一个为Windows平台打造的轻量级、模块化C++ GUI框架。
  *     基于EasyX图形库，提供简洁易用的API和丰富的控件。
diff --git a/include/StellarX/table.h b/include/StellarX/table.h
index 70c50ab..62eefef 100644
--- a/include/StellarX/table.h
+++ b/include/StellarX/table.h
@@ -69,6 +69,7 @@ private:
 	bool isShowPageButton = true;			    // 是否显示翻页按钮
 	bool isNeedDrawHeaders = true;              // 是否需要绘制表头
 	bool isNeedCellSize = true;                 // 是否需要计算单元格尺寸
+	bool isNeedButtonAndPageNum = true;         // 是否需要计算翻页按钮和页码信息
 
 	Button* prevButton = nullptr;               // 上一页按钮
 	Button* nextButton = nullptr;			    // 下一页按钮
@@ -98,7 +99,8 @@ private:
 	bool model() const override { return false; };
 public:
 	StellarX::ControlText textStyle; // 文本样式
-
+	void setWidth(int width) override;
+	void setHeight(int height) override;
 public:
 	Table(int x, int y);
 	~Table();
@@ -154,6 +156,9 @@ public:
 	std::vector<std::vector<std::string>> getData() const;
 	//获取表格边框宽度
 	int getTableBorderWidth() const;
+	//获取表格尺寸
+	int getTableWidth() const;
+	int getTableHeight() const;
 
 
 };
diff --git a/include/StellarX/window.h b/include/StellarX/window.h
index 31b30ac..6ba212f 100644
--- a/include/StellarX/window.h
+++ b/include/StellarX/window.h
@@ -25,7 +25,9 @@ class Window
 {
     // —— 尺寸状态 ——（绘制尺寸与待应用尺寸分离；收口时一次性更新）
     int           width;                 // 当前有效宽（已应用到画布/控件的客户区宽）
-    int           height;                // 当前有效高（已应用到画布/控件的客户区高）
+    int           height;                // 当前有效高（已应用到画布/控件的客户区高） 
+    int           localwidth;            // 基准宽（创建时的宽度）
+    int           localheight;           // 基准高（创建是的高度）
     int           pendingW;              // 待应用宽（WM_SIZE/拉伸中记录用）
     int           pendingH;              // 待应用高
     int           minClientW;            // 业务设定的最小客户区宽（用于 GETMINMAXINFO 与 SIZING 夹紧）
@@ -102,4 +104,7 @@ public:
     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);
+
 };
diff --git a/src/Button.cpp b/src/Button.cpp
index b418e1a..eaba829 100644
--- a/src/Button.cpp
+++ b/src/Button.cpp
@@ -22,7 +22,7 @@ static inline int gbk_char_len(const std::string& s, size_t i)
 {
 	unsigned char b = (unsigned char)s[i];
 	if (b <= 0x7F) return 1; // ASCII
-	if (b >= 0x81 && b <= 0xFE && i + 1 < s.size()) 
+	if (b >= 0x81 && b <= 0xFE && i + 1 < s.size())
 	{
 		unsigned char b2 = (unsigned char)s[i + 1];
 		if (b2 >= 0x40 && b2 <= 0xFE && b2 != 0x7F) return 2; // 合法双字节
@@ -30,10 +30,10 @@ static inline int gbk_char_len(const std::string& s, size_t i)
 	return 1; // 容错
 }
 
-static inline void rtrim_spaces_gbk(std::string& s) 
+static inline void rtrim_spaces_gbk(std::string& s)
 {
 	while (!s.empty() && s.back() == ' ') s.pop_back();           // ASCII 空格
-	while (s.size() >= 2) 
+	while (s.size() >= 2)
 	{                                       // 全角空格 A1 A1
 		unsigned char a = (unsigned char)s[s.size() - 2];
 		unsigned char b = (unsigned char)s[s.size() - 1];
@@ -42,26 +42,26 @@ static inline void rtrim_spaces_gbk(std::string& s)
 	}
 }
 
-static inline bool is_ascii_only(const std::string& s) 
+static inline bool is_ascii_only(const std::string& s)
 {
 	for (unsigned char c : s) if (c > 0x7F) return false;
 	return true;
 }
 
-static inline bool is_word_boundary_char(unsigned char c) 
+static inline bool is_word_boundary_char(unsigned char c)
 {
 	return c == ' ' || c == '-' || c == '_' || c == '/' || c == '\\' || c == '.' || c == ':';
 }
 
 // 英文优先策略：优先在“词边界”回退，再退化到逐字符；省略号为 "..."
-static std::string ellipsize_ascii_pref(const std::string& text, int maxW) 
+static std::string ellipsize_ascii_pref(const std::string& text, int maxW)
 {
 	if (maxW <= 0) return "";
 	if (textwidth(LPCTSTR(text.c_str())) <= maxW) return text;
 
 	const std::string ell = "...";
 	int ellW = textwidth(LPCTSTR(ell.c_str()));
-	if (ellW > maxW) 
+	if (ellW > maxW)
 	{ // 连 ... 都放不下
 		std::string e = ell;
 		while (!e.empty() && textwidth(LPCTSTR(e.c_str())) > maxW) e.pop_back();
@@ -71,7 +71,7 @@ static std::string ellipsize_ascii_pref(const std::string& text, int maxW)
 
 	// 先找到能放下的最长前缀
 	size_t i = 0, lastFit = 0;
-	while (i < text.size()) 
+	while (i < text.size())
 	{
 		int clen = gbk_char_len(text, i);
 		size_t j = text.size() < i + (size_t)clen ? text.size() : i + (size_t)clen;
@@ -83,7 +83,7 @@ static std::string ellipsize_ascii_pref(const std::string& text, int maxW)
 
 	// 在已适配前缀范围内，向左找最近的词边界
 	size_t cutPos = lastFit;
-	for (size_t k = lastFit; k > 0; --k) 
+	for (size_t k = lastFit; k > 0; --k)
 	{
 		unsigned char c = (unsigned char)text[k - 1];
 		if (c <= 0x7F && is_word_boundary_char(c)) { cutPos = k - 1; break; }
@@ -96,14 +96,14 @@ static std::string ellipsize_ascii_pref(const std::string& text, int maxW)
 }
 
 // 中文优先策略：严格逐“字符”(1/2字节)回退；省略号用全角 "…"
-static std::string ellipsize_cjk_pref(const std::string& text, int maxW, const char* ellipsis = "…") 
+static std::string ellipsize_cjk_pref(const std::string& text, int maxW, const char* ellipsis = "…")
 {
 	if (maxW <= 0) return "";
 	if (textwidth(LPCTSTR(text.c_str())) <= maxW) return text;
 
 	std::string ell = ellipsis ? ellipsis : "…";
 	int ellW = textwidth(LPCTSTR(ell.c_str()));
-	if (ellW > maxW) 
+	if (ellW > maxW)
 	{ // 连省略号都放不下
 		std::string e = ell;
 		while (!e.empty() && textwidth(LPCTSTR(e.c_str())) > maxW) e.pop_back();
@@ -112,7 +112,7 @@ static std::string ellipsize_cjk_pref(const std::string& text, int maxW, const c
 	const int limit = maxW - ellW;
 
 	size_t i = 0, lastFit = 0;
-	while (i < text.size()) 
+	while (i < text.size())
 	{
 		int clen = gbk_char_len(text, i);
 		size_t j = text.size() < i + (size_t)clen ? text.size() : i + (size_t)clen;
@@ -166,8 +166,8 @@ void Button::initButton(const std::string text, StellarX::ButtonMode mode, Stell
 
 Button::~Button()
 {
-    if (buttonFileIMAGE) 
-        delete buttonFileIMAGE;
+	if (buttonFileIMAGE)
+		delete buttonFileIMAGE;
 	buttonFileIMAGE = nullptr;
 }
 
@@ -314,7 +314,7 @@ bool Button::handleEvent(const ExMessage& msg)
 	// 处理鼠标点击事件
 	if (msg.message == WM_LBUTTONDOWN && hover && mode != StellarX::ButtonMode::DISABLED)
 	{
-		
+
 		if (mode == StellarX::ButtonMode::NORMAL)
 		{
 			click = true;
@@ -327,7 +327,7 @@ bool Button::handleEvent(const ExMessage& msg)
 		}
 	}
 	// NORMAL 模式：鼠标在按钮上释放时才触发点击回调，如果移出区域则取消点击状态。
-    // TOGGLE 模式：在释放时切换状态，并触发相应的开/关回调。
+	// TOGGLE 模式：在释放时切换状态，并触发相应的开/关回调。
 	else if (msg.message == WM_LBUTTONUP && hover && mode != StellarX::ButtonMode::DISABLED)
 	{
 		hideTooltip();  // 隐藏悬停提示
@@ -349,7 +349,7 @@ bool Button::handleEvent(const ExMessage& msg)
 			dirty = true;
 			consume = true;
 			refreshTooltipTextForState();
-			hideTooltip();            
+			hideTooltip();
 			// 清除消息队列中积压的鼠标和键盘消息，防止本次点击事件被重复处理
 			flushmessage(EX_MOUSE | EX_KEY);
 		}
@@ -367,23 +367,23 @@ bool Button::handleEvent(const ExMessage& msg)
 			dirty = true;
 	}
 
-	if (tipEnabled) 
+	if (tipEnabled)
 	{
-		if (hover && !oldHover) 
+		if (hover && !oldHover)
 		{
 			// 刚刚进入悬停：开计时，暂不显示
 			tipHoverTick = GetTickCount64();
 			tipVisible = false;
 		}
-		if (!hover && oldHover) 
+		if (!hover && oldHover)
 		{
 			// 刚移出：立即隐藏
 			hideTooltip();
 		}
-		if (hover && !tipVisible) 
+		if (hover && !tipVisible)
 		{
 			// 到点就显示
-			if (GetTickCount64() - tipHoverTick >= (ULONGLONG)tipDelayMs) 
+			if (GetTickCount64() - tipHoverTick >= (ULONGLONG)tipDelayMs)
 			{
 				tipVisible = true;
 
@@ -420,18 +420,18 @@ bool Button::handleEvent(const ExMessage& msg)
 
 	if (tipEnabled && tipVisible)
 		tipLabel.draw();
-	
+
 	return consume;
 }
 
 void Button::setOnClickListener(const std::function<void()>&& callback)
 {
-    this->onClickCallback = callback;
+	this->onClickCallback = callback;
 }
 
 void Button::setOnToggleOnListener(const std::function<void()>&& callback)
 {
-    this->onToggleOnCallback = callback;
+	this->onToggleOnCallback = callback;
 }
 void Button::setOnToggleOffListener(const std::function<void()>&& callback)
 {
@@ -443,37 +443,37 @@ void Button::setbuttonMode(StellarX::ButtonMode mode)
 	if (this->mode == StellarX::ButtonMode::DISABLED && mode != StellarX::ButtonMode::DISABLED)
 		textStyle.bStrikeOut = false;
 	//取值范围参考 buttMode的枚举注释
-    this->mode = mode;
+	this->mode = mode;
 	dirty = true; // 标记需要重绘
 }
 
 void Button::setROUND_RECTANGLEwidth(int width)
 {
-     rouRectangleSize.ROUND_RECTANGLEwidth = width;
+	rouRectangleSize.ROUND_RECTANGLEwidth = width;
 	this->dirty = true; // 标记需要重绘
 
 }
 
 void Button::setROUND_RECTANGLEheight(int height)
 {
-    rouRectangleSize.ROUND_RECTANGLEheight = height;
+	rouRectangleSize.ROUND_RECTANGLEheight = height;
 	this->dirty = true; // 标记需要重绘
 }
 
 bool Button::isClicked() const
 {
-    return this->click;
+	return this->click;
 }
 
 void Button::setFillMode(StellarX::FillMode mode)
 {
-    this->buttonFillMode = mode;
+	this->buttonFillMode = mode;
 	this->dirty = true; // 标记需要重绘
 }
 
 void Button::setFillIma(StellarX::FillStyle ima)
 {
-    buttonFillIma = ima;
+	buttonFillIma = ima;
 	this->dirty = true;
 }
 
@@ -484,8 +484,8 @@ void Button::setFillIma(std::string imaNAme)
 		delete buttonFileIMAGE;
 		buttonFileIMAGE = nullptr;
 	}
-    buttonFileIMAGE = new IMAGE;
-    loadimage(buttonFileIMAGE, imaNAme.c_str(),width,height);
+	buttonFileIMAGE = new IMAGE;
+	loadimage(buttonFileIMAGE, imaNAme.c_str(), width, height);
 	this->dirty = true;
 }
 
@@ -493,7 +493,7 @@ void Button::setFillIma(std::string imaNAme)
 void Button::setButtonBorder(COLORREF Border)
 {
 	buttonBorderColor = Border;
-		this->dirty = true;
+	this->dirty = true;
 }
 
 void Button::setButtonFalseColor(COLORREF color)
@@ -504,7 +504,7 @@ void Button::setButtonFalseColor(COLORREF color)
 
 void Button::setButtonText(const char* text)
 {
-    this->text = std::string(text);
+	this->text = std::string(text);
 	this->text_width = textwidth(LPCTSTR(this->text.c_str()));
 	this->text_height = textheight(LPCTSTR(this->text.c_str()));
 	this->dirty = true;
@@ -526,7 +526,7 @@ void Button::setButtonText(std::string text)
 
 void Button::setButtonShape(StellarX::ControlShape shape)
 {
-    this->shape = shape;
+	this->shape = shape;
 	this->dirty = true;
 	this->needCutText = true;
 }
@@ -535,7 +535,7 @@ void Button::setButtonShape(StellarX::ControlShape shape)
 void Button::setButtonClick(BOOL click)
 {
 	this->click = click;
-	
+
 	if (mode == StellarX::ButtonMode::NORMAL && click)
 	{
 		if (onClickCallback) onClickCallback();
@@ -550,7 +550,7 @@ void Button::setButtonClick(BOOL click)
 		else if (!click && onToggleOffCallback) onToggleOffCallback();
 		dirty = true;
 		refreshTooltipTextForState();
-		hideTooltip();                
+		hideTooltip();
 		// 清除消息队列中积压的鼠标和键盘消息，防止本次点击事件被重复处理
 		flushmessage(EX_MOUSE | EX_KEY);
 	}
@@ -561,52 +561,52 @@ void Button::setButtonClick(BOOL click)
 
 std::string Button::getButtonText() const
 {
-    return this->text;
+	return this->text;
 }
 
 const char* Button::getButtonText_c() const
 {
-    return this->text.c_str();
+	return this->text.c_str();
 }
 
 StellarX::ButtonMode Button::getButtonMode() const
 {
-    return this->mode;
+	return this->mode;
 }
 
 StellarX::ControlShape Button::getButtonShape() const
 {
-    return this->shape;
+	return this->shape;
 }
 
 StellarX::FillMode Button::getFillMode() const
 {
-    return this->buttonFillMode;
+	return this->buttonFillMode;
 }
 
 StellarX::FillStyle Button::getFillIma() const
 {
-    return this->buttonFillIma;
+	return this->buttonFillIma;
 }
 
 IMAGE* Button::getFillImaImage() const
 {
-    return this->buttonFileIMAGE;
+	return this->buttonFileIMAGE;
 }
 
 COLORREF Button::getButtonBorder() const
 {
-    return this->buttonBorderColor;
+	return this->buttonBorderColor;
 }
 
 COLORREF Button::getButtonTextColor() const
 {
-    return this->textStyle.color;
+	return this->textStyle.color;
 }
 
 StellarX::ControlText Button::getButtonTextStyle() const
 {
-    return this->textStyle;
+	return this->textStyle;
 }
 
 int Button::getButtonWidth() const
@@ -623,11 +623,11 @@ int Button::getButtonHeight() const
 
 bool Button::isMouseInCircle(int mouseX, int mouseY, int x, int y, int radius)
 {
-    double dis = sqrt(pow(mouseX - x, 2) + pow(mouseY - y, 2));
-    if (dis <= radius)
-        return true;
-    else 
-        return false;
+	double dis = sqrt(pow(mouseX - x, 2) + pow(mouseY - y, 2));
+	if (dis <= radius)
+		return true;
+	else
+		return false;
 }
 
 bool Button::isMouseInEllipse(int mouseX, int mouseY, int x, int y, int width, int height)
@@ -636,15 +636,15 @@ bool Button::isMouseInEllipse(int mouseX, int mouseY, int x, int y, int width, i
 	int centerY = (y + height) / 2;
 	int majorAxis = (width - x) / 2;
 	int minorAxis = (height - y) / 2;
-    double dx = mouseX - centerX;
-    double dy = mouseY - centerY;
-    double normalizedDistance = (dx * dx) / (majorAxis * majorAxis) + (dy * dy) / (minorAxis * minorAxis);
+	double dx = mouseX - centerX;
+	double dy = mouseY - centerY;
+	double normalizedDistance = (dx * dx) / (majorAxis * majorAxis) + (dy * dy) / (minorAxis * minorAxis);
 
-    // 判断鼠标是否在椭圆内
-    if (normalizedDistance <= 1.0)
-        return true;
-    else
-        return false;
+	// 判断鼠标是否在椭圆内
+	if (normalizedDistance <= 1.0)
+		return true;
+	else
+		return false;
 }
 
 void Button::cutButtonText()
@@ -659,18 +659,18 @@ void Button::cutButtonText()
 	}
 
 	// 放不下：按语言偏好裁切（ASCII→词边界；CJK→逐字符，不撕裂双字节）
-	if (is_ascii_only(this->text)) 
+	if (is_ascii_only(this->text))
 	{
 		cutText = ellipsize_ascii_pref(this->text, contentW);   // "..."
 	}
 	else
 	{
 		cutText = ellipsize_cjk_pref(this->text, contentW, "…"); // 全角省略号
-		
+
 	}
 	isUseCutText = true;
 	needCutText = false;
-	
+
 }
 
 void Button::hideTooltip()
@@ -686,9 +686,9 @@ void Button::hideTooltip()
 void Button::refreshTooltipTextForState()
 {
 	if (tipUserOverride)   return; // 用户显式设置过 tipText，保持不变
-	if(mode==StellarX::ButtonMode::NORMAL)
+	if (mode == StellarX::ButtonMode::NORMAL)
 		tipLabel.setText(tipTextClick);
-	else if(mode==StellarX::ButtonMode::TOGGLE)
+	else if (mode == StellarX::ButtonMode::TOGGLE)
 		tipLabel.setText(click ? tipTextOn : tipTextOff);
 }
 
diff --git a/src/Canvas.cpp b/src/Canvas.cpp
index 4d953e8..658b7c1 100644
--- a/src/Canvas.cpp
+++ b/src/Canvas.cpp
@@ -17,21 +17,43 @@ void Canvas::clearAllControls()
 	controls.clear();
 }
 
-
 void Canvas::draw()
 {
-	if (!dirty||!show)return;
+	if (!dirty || !show)
+	{
+		for (auto& control : controls)
+			if (auto c = dynamic_cast<Table*>(control.get()))
+				c->draw();
+		return;
+	}
 	saveStyle();
-
 	setlinecolor(canvasBorderClor);//设置线色
-	setfillcolor(canvasBkClor);//设置填充色
+    if(StellarX::FillMode::Null != canvasFillMode)
+        setfillcolor(canvasBkClor);//设置填充色
 	setfillstyle((int)canvasFillMode);//设置填充模式
 	setlinestyle((int)canvasLineStyle, canvaslinewidth);
 	
-	if ((saveBkX != this->x) || (saveBkY != this->y) || (!hasSnap) || (saveWidth != this->width) || (saveHeight != this->height) || !saveBkImage)
-		saveBackground(x, y, width, height);
-	// 恢复背景（清除旧内容）
-	restBackground();
+    // 在绘制画布之前，先恢复并更新背景快照：
+    // 1. 如果已有快照，则先回贴旧快照以清除之前的内容。
+    // 2. 当坐标或尺寸变化，或缓存图像无效时，丢弃旧快照并重新抓取新的背景。
+    if (hasSnap)
+    {
+        // 恢复旧快照，清除上一次绘制
+        restBackground();
+        // 如果位置或尺寸变了，或没有有效缓存，则重新抓取
+        if (!saveBkImage || saveBkX != this->x || saveBkY != this->y || 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();
 	//根据画布形状绘制
 	switch (shape)
 	{
@@ -158,9 +180,173 @@ void Canvas::setDirty(bool dirty)
 
 void Canvas::onWindowResize()
 {
-	Control::onWindowResize();          // 先处理自己
-	for (auto& ch : controls)          // 再转发给所有子控件
-		ch->onWindowResize();
+    // 首先处理自身的快照等逻辑
+    Control::onWindowResize();
+
+    // 记录父容器原始尺寸（用于计算子控件的右/下边距）
+    int origParentW = this->localWidth;
+    int origParentH = this->localHeight;
+
+    // 当前容器的新尺寸
+    int finalW = this->width;
+    int finalH = this->height;
+
+    // 当前容器的新坐标（全局坐标）
+    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);
+
+            // 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);
+
+            // 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 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)
diff --git a/src/Control.cpp b/src/Control.cpp
index 0b5dd6c..91a5d61 100644
--- a/src/Control.cpp
+++ b/src/Control.cpp
@@ -54,6 +54,27 @@ void Control::onWindowResize()
 	discardBackground();
 	setDirty(true);
 }
+void Control::setLayoutMode(StellarX::LayoutMode layoutMode_)
+{
+	this->layoutMode = layoutMode_;
+}
+void Control::steAnchor(StellarX::Anchor anchor_1, StellarX::Anchor anchor_2)
+{
+	this->anchor_1 = anchor_1;
+	this->anchor_2 = anchor_2;
+}
+StellarX::Anchor Control::getAnchor_1() const
+{
+	return this->anchor_1;
+}
+StellarX::Anchor Control::getAnchor_2() const
+{
+	return this->anchor_2;
+}
+StellarX::LayoutMode Control::getLayoutMode() const
+{
+	return this->layoutMode;
+}
 // 保存当前的绘图状态（字体、颜色、线型等）
 // 在控件绘制前调用，确保不会影响全局绘图状态
 void Control::saveStyle()
diff --git a/src/Dialog.cpp b/src/Dialog.cpp
index 8672688..cbca809 100644
--- a/src/Dialog.cpp
+++ b/src/Dialog.cpp
@@ -59,7 +59,7 @@ void Dialog::draw()
 		
 		
 		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()));
@@ -555,7 +555,7 @@ void Dialog::getTextSize()
 	settextstyle(textStyle.nHeight, textStyle.nWidth, textStyle.lpszFace,
 		textStyle.nEscapement, textStyle.nOrientation, textStyle.nWeight,
 		textStyle.bItalic, textStyle.bUnderline, textStyle.bStrikeOut);
-	for (auto text : lines)
+	for (auto& text : lines)
 	{
 		int w = textwidth(LPCTSTR(text.c_str()));
 		int h = textheight(LPCTSTR(text.c_str()));
diff --git a/src/TabControl.cpp b/src/TabControl.cpp
index 3bf9d55..e726b4f 100644
--- a/src/TabControl.cpp
+++ b/src/TabControl.cpp
@@ -165,22 +165,37 @@ TabControl::~TabControl()
 void TabControl::draw()
 {
 	if (!dirty || !show)return;
-	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();
-	Canvas::draw();
+    // 在绘制 TabControl 之前，先恢复并更新背景快照：
+    if (hasSnap)
+    {
+        // 先回贴旧快照，清除之前的绘制
+        restBackground();
+        // 如位置或尺寸变化，丢弃旧快照并重新抓取
+        if (!saveBkImage || saveBkX != this->x || saveBkY != this->y || 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();
+    // 绘制画布背景和基本形状及其子画布控件
+    Canvas::draw();
 	for (auto& c : controls)
 	{
 		c.first->setDirty(true);
 		c.first->draw();
 	}
 	for (auto& c : controls)
-		if(c.second->IsVisible())
-		{
-			c.second->setDirty(true);
-			c.second->draw();
-		}
+	{
+		c.second->setDirty(true);
+		c.second->draw();
+	}
 	dirty = false;
 
 }
@@ -216,6 +231,7 @@ void TabControl::add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>
 	controls[idx].first->setParent(this);
 	controls[idx].first->enableTooltip(true);
 	controls[idx].first->setbuttonMode(StellarX::ButtonMode::TOGGLE);
+
 	controls[idx].first->setOnToggleOnListener([this,idx]()
 		{
 			controls[idx].second->setIsVisible(true);
@@ -291,12 +307,19 @@ void TabControl::setIsVisible(bool visible)
 
 void TabControl::onWindowResize()
 {
-	Control::onWindowResize();
-	for (auto& c : controls)
-	{
-		c.first->onWindowResize();
-		c.second->onWindowResize();
-	}
+    // 调用基类的窗口变化处理，丢弃快照并标记脏
+    Control::onWindowResize();
+    // 根据当前 TabControl 的新尺寸重新计算页签栏和页面区域
+    initTabBar();
+    initTabPage();
+    // 转发窗口尺寸变化给所有页签按钮和页面
+    for (auto& c : controls)
+    {
+        c.first->onWindowResize();
+        c.second->onWindowResize();
+    }
+    // 尺寸变化后需要重绘自身
+    dirty = true;
 }
 
 int TabControl::getActiveIndex() const
diff --git a/src/table.cpp b/src/table.cpp
index b06295d..b84d599 100644
--- a/src/table.cpp
+++ b/src/table.cpp
@@ -87,28 +87,35 @@ void Table::initTextWaH()
 		if (h > maxLineH) 
 			maxLineH = h;
 
-	// 列的像素宽 = 内容宽 + 左右 padding
-	// 表内容总宽 = Σ(列宽 + 列间距)
-	int contentW = 0;
-	for (size_t j = 0; j < colWidths.size(); ++j)
-		contentW += (colWidths[j] + 2 * padX) + colGap;
+    // 列宽包含左右 padding：在计算完最大文本宽度后，加上 2*padX 作为单元格内边距
+    for (size_t j = 0; j < colWidths.size(); ++j) {
+        colWidths[j] += 2 * padX;
+    }
 
-	// 表头高 & 行高（与 drawHeader/drawTable 内部一致：+上下 padding）
-	const int headerH = maxLineH + 2 * padY;
-	const int rowH = maxLineH + 2 * padY;
-	const int rowsH = rowH * rowsPerPage;
+    // 表内容总宽 = Σ(列宽 + 列间距)
+    int contentW = 0;
+    for (size_t j = 0; j < colWidths.size(); ++j)
+        contentW += colWidths[j] + colGap;
 
-	// 页脚：
-	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;
+    // 表头高 & 行高（与 drawHeader/drawTable 内部一致：+上下 padding）
+    const int headerH = maxLineH + 2 * padY;
+    const int rowH    = maxLineH + 2 * padY;
+    const int rowsH   = rowH * rowsPerPage;
 
-	// 最终表宽/高：内容 + 对称边框
-	this->width = contentW + (border << 1);
-	this->height = headerH + rowsH + footerH + (border << 1);
+    // 页脚：
+    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;
 }
 
 void Table::initButton()
@@ -171,6 +178,7 @@ void Table::initButton()
 			if (pageNum) pageNum->setDirty(true);
 		}
 		});
+	isNeedButtonAndPageNum = false;
 }
 
 void Table::initPageNum()
@@ -214,7 +222,7 @@ void Table::drawPageNum()
 	pageNumtext += "页/共";
 	pageNumtext += std::to_string(totalPages);
 	pageNumtext += "页";
-	if (nullptr == pageNum)
+	if (nullptr == pageNum || isNeedButtonAndPageNum)
 		initPageNum();
 	pageNum->setText(pageNumtext);
 	pageNum->textStyle = this->textStyle;
@@ -226,7 +234,7 @@ void Table::drawPageNum()
 
 void Table::drawButton()
 {
-	if (nullptr == prevButton || nullptr == nextButton)
+	if ((nullptr == prevButton || nullptr == nextButton)|| isNeedButtonAndPageNum)
 		initButton();
 
 	this->prevButton->textStyle = this->textStyle;
@@ -242,6 +250,43 @@ void Table::drawButton()
 
 }
 
+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;
+}
+
+void Table::setHeight(int height)
+{
+}
+
 Table::Table(int x, int y)
 	:Control(x, y, 0, 0)
 {
@@ -317,13 +362,27 @@ void Table::draw()
 			setfillstyle((int)tableFillMode);
 			setbkmode(TRANSPARENT);
 		}
-		//确保在绘制任何表格内容之前捕获背景
-	   // 临时恢复样式，确保捕获正确的背景
-		if ((!hasSnap) || (saveWidth != this->width) || (saveHeight != this->height)||!saveBkImage)
-			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;
@@ -365,7 +424,7 @@ bool Table::handleEvent(const ExMessage& msg)
 void Table::setHeaders(std::initializer_list<std::string> headers)
 {
 	this->headers.clear();
-	for (auto lis : headers)
+	for (auto& lis : headers)
 		this->headers.push_back(lis);
 	isNeedCellSize = true; // 标记需要重新计算单元格尺寸
 	isNeedDrawHeaders = true; // 标记需要重新绘制表头
@@ -467,9 +526,12 @@ void Table::setTableBorderWidth(int width)
 void Table::onWindowResize()
 {
 	Control::onWindowResize();          // 先处理自己
-	prevButton->onWindowResize();
-	nextButton->onWindowResize();
-	pageNum->onWindowResize();
+	if (this->prevButton && this->nextButton && this->pageNum)
+	{
+		prevButton->onWindowResize();
+		nextButton->onWindowResize();
+		pageNum->onWindowResize();
+	}
 }
 
 int Table::getCurrentPage() const
@@ -527,4 +589,17 @@ int Table::getTableBorderWidth() const
 	return this->tableBorderWidth;
 }
 
+int Table::getTableWidth() const
+{
+	int temp = 0;
+	for (auto& w : colWidths)
+		temp += w;
+	return temp;
+}
+
+int Table::getTableHeight() const
+{
+	return 0;
+}
+
 
diff --git a/src/window.cpp b/src/window.cpp
index 93324b4..b7b18cd 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -1,7 +1,7 @@
 #include "Window.h"
 #include "Dialog.h"
 
-#include <graphics.h>
+#include <easyx.h>
 #include <algorithm>
 
 /**
@@ -95,23 +95,23 @@ static void ApplyMinSizeOnSizing(RECT* prc, WPARAM edge, HWND hWnd, int minClien
  */
 Window::Window(int w, int h, int mode)
 {
-    minClientW = pendingW = width = w;
-    minClientH = pendingH = height = h;
+    localwidth  = minClientW = pendingW = width = w;
+    localheight = minClientH = pendingH = height = h;
     windowMode = mode;
 }
 
 Window::Window(int w, int h, int mode, COLORREF bk)
 {
-    minClientW = pendingW = width = w;
-    minClientH = pendingH = height = h;
+    localwidth = minClientW = pendingW = width = w;
+    localheight = minClientH = pendingH = height = h;
     windowMode = mode;
     wBkcolor = bk;
 }
 
 Window::Window(int w, int h, int mode, COLORREF bk, std::string title)
 {
-    minClientW = pendingW = width = w;
-    minClientH = pendingH = height = h;
+    localwidth = minClientW = pendingW = width = w;
+    localheight = minClientH = pendingH = height = h;
     windowMode = mode;
     wBkcolor = bk;
     headline = std::move(title);
@@ -128,7 +128,7 @@ Window::~Window()
 // ---------------- 原生消息钩子----------------
 
 /**
- * WndProcThunk
+ * WndProcThun
  * 作用：替换 EasyX 的窗口过程，接管关键消息。
  * 关键处理：
  *  - WM_ERASEBKGND：返回 1，交由自绘清屏，避免系统擦背景造成闪烁。
@@ -191,18 +191,10 @@ LRESULT CALLBACK Window::WndProcThunk(HWND h, UINT m, WPARAM w, LPARAM l)
             self->needResizeDirty = true;
         }
 
-        // 关键：立刻做统一收口，不用等下一条消息
-        self->pumpResizeIfNeeded();
-
-        // 不擦背景、不触发立即 WM_PAINT
-        // InvalidateRect(h, nullptr, TRUE);
-        // UpdateWindow(h);
-        InvalidateRect(h, nullptr, FALSE);
-
-        // 解冻 + 触发一次刷新（InvalidateRect TRUE 会擦背景；如需无擦背景可传 FALSE）
+        // 结束拉伸后不立即执行重绘，待事件循环统一收口。
+        // 立即解冻重绘标志，同时标记区域为有效，避免触发额外 WM_PAINT。
         SendMessage(h, WM_SETREDRAW, TRUE, 0);
-        InvalidateRect(h, nullptr, TRUE);
-        UpdateWindow(h);
+        ValidateRect(h, nullptr);
         return 0;
     }
 
@@ -510,8 +502,8 @@ int Window::runEventLoop()
                 // 批量通知控件“窗口尺寸变化”，并标记重绘
                 for (auto& c : controls)
                 {
+                    adaptiveLayout(c,finalH,finalW);
                     c->onWindowResize();
-                    c->setDirty(true);
                 }
                 for (auto& d : dialogs)
                 {
@@ -528,9 +520,9 @@ int Window::runEventLoop()
 
                 EndBatchDraw();
 
-                // 解冻并触发一次无效化（这里 TRUE 表示会擦背景；如要避免闪白可改 FALSE）
+                // 解冻后标记区域有效，避免系统再次触发 WM_PAINT 覆盖自绘内容。
                 SendMessage(hWnd, WM_SETREDRAW, TRUE, 0);
-                InvalidateRect(hWnd, nullptr, TRUE);
+                ValidateRect(hWnd, nullptr);
             }
 
             needResizeDirty = false; // 收口完成，清标志
@@ -595,9 +587,7 @@ void Window::setHeadline(std::string title)
     // 设置窗口标题（仅改文本，不触发重绘）
     headline = std::move(title);
     if (hWnd)
-    {
         SetWindowText(hWnd, headline.c_str());
-    }
 }
 
 void Window::addControl(std::unique_ptr<Control> control)
@@ -711,13 +701,20 @@ void Window::pumpResizeIfNeeded()
         loadimage(background, bkImageFile.c_str(), rc.right - rc.left, rc.bottom - rc.top, true);
         putimage(0, 0, background);
     }
-    else { setbkcolor(wBkcolor); cleardevice(); }
+    else
+    {
+        setbkcolor(wBkcolor);
+        cleardevice();
 
+    }
     width = rc.right - rc.left; height = rc.bottom - rc.top;
 
     // 通知控件/对话框
     for (auto& c : controls)
+    {
+        adaptiveLayout(c, finalH, finalW);
         c->onWindowResize();
+    }
     for (auto& d : dialogs)
         if (auto* dd = dynamic_cast<Dialog*>(d.get()))
             dd->setInitialization(true); // 强制对话框在新尺寸下重建布局/快照
@@ -729,9 +726,10 @@ void Window::pumpResizeIfNeeded()
     EndBatchDraw();
     SendMessage(hWnd, WM_SETREDRAW, TRUE, 0);
 
-    // 原来是 TRUE：会擦背景再触发 WM_PAINT，容易把刚画好的层“盖掉”
-    // InvalidateRect(hWnd, nullptr, TRUE);
-    InvalidateRect(hWnd, nullptr, FALSE);
+    // 原实现在此调用 InvalidateRect 导致系统再次发送 WM_PAINT，从而重复绘制，
+    // 这里改为 ValidateRect：直接标记区域为有效，通知系统我们已完成绘制，不必再触发 WM_PAINT。
+    // 这样可以避免收口阶段的绘制与系统重绘叠加造成顺序错乱。
+    ValidateRect(hWnd, nullptr);
 
     needResizeDirty = false;
 }
@@ -750,3 +748,72 @@ void Window::scheduleResizeFromModal(int w, int h)
     }
 }
 
+void Window::adaptiveLayout(std::unique_ptr<Control>& c, const int finalH, const int finalW)
+{
+    int origParentW = this->localwidth;
+    int origParentH = this->localheight;
+    if (c->getLayoutMode() == StellarX::LayoutMode::AnchorToEdges)
+    {
+        if ((StellarX::Anchor::Left == c->getAnchor_1() && StellarX::Anchor::Right == c->getAnchor_2())
+            || (StellarX::Anchor::Right == c->getAnchor_1() && StellarX::Anchor::Left == c->getAnchor_2()))
+        {
+            int origRightDist = origParentW - (c->getLocalX() + c->getLocalWidth());
+            int newWidth = finalW - c->getLocalX() - origRightDist;
+            c->setWidth(newWidth);
+            // 左侧距离固定，ctrl->x 保持为 localx 相对窗口左侧（父容器为窗口，偏移0）
+            c->setX(c->getLocalX());
+        }
+        else if ((StellarX::Anchor::Left == c->getAnchor_1() && StellarX::Anchor::NoAnchor == c->getAnchor_2())
+            || (StellarX::Anchor::NoAnchor == c->getAnchor_1() && StellarX::Anchor::Left == c->getAnchor_2())
+            || (StellarX::Anchor::Left == c->getAnchor_1() && StellarX::Anchor::Left == c->getAnchor_2()))
+        {
+            // 仅左锚定：宽度固定不变
+            c->setX(c->getLocalX());
+            c->setWidth(c->getLocalWidth());
+        }
+        else if ((StellarX::Anchor::Right == c->getAnchor_1() && StellarX::Anchor::NoAnchor == c->getAnchor_2())
+            || (StellarX::Anchor::NoAnchor == c->getAnchor_1() && StellarX::Anchor::Right == c->getAnchor_2())
+            || (StellarX::Anchor::Right == c->getAnchor_1() && StellarX::Anchor::Right == c->getAnchor_2()))
+        {
+            int origRightDist = origParentW - (c->getLocalX() + c->getLocalWidth());
+            c->setWidth(c->getLocalWidth()); // 宽度不变
+            c->setX(finalW - origRightDist - c->getWidth());
+        }
+        else if (StellarX::Anchor::NoAnchor == c->getAnchor_1() && StellarX::Anchor::NoAnchor == c->getAnchor_2())
+        {
+            c->setX(c->getLocalX());
+            c->setWidth(c->getLocalWidth());
+        }
+
+        if ((StellarX::Anchor::Top == c->getAnchor_1() && StellarX::Anchor::Bottom == c->getAnchor_2())
+            || (StellarX::Anchor::Bottom == c->getAnchor_1() && StellarX::Anchor::Top == c->getAnchor_2()))
+        {
+            // 上下锚定：高度随窗口变化
+            int origBottomDist = origParentH - (c->getLocalY() + c->getLocalHeight());
+            int newHeight = finalH - c->getLocalY() - origBottomDist;
+            c->setHeight(newHeight);
+            c->setY(c->getLocalY());
+        }
+        else if ((StellarX::Anchor::Top == c->getAnchor_1() && StellarX::Anchor::NoAnchor == c->getAnchor_2())
+            || (StellarX::Anchor::NoAnchor == c->getAnchor_1() && StellarX::Anchor::Top == c->getAnchor_2())
+            || (StellarX::Anchor::Top == c->getAnchor_1() && StellarX::Anchor::Top == c->getAnchor_2()))
+        {
+            c->setY(c->getLocalY());
+            c->setHeight(c->getLocalHeight());
+        }
+        else if ((StellarX::Anchor::Bottom == c->getAnchor_1() && StellarX::Anchor::NoAnchor == c->getAnchor_2())
+            || (StellarX::Anchor::NoAnchor == c->getAnchor_1() && StellarX::Anchor::Bottom == c->getAnchor_2())
+            || (StellarX::Anchor::Bottom == c->getAnchor_1() && StellarX::Anchor::Bottom == c->getAnchor_2()))
+        {
+            int origBottomDist = origParentH - (c->getLocalY() + c->getLocalHeight());
+            c->setHeight(c->getLocalHeight());
+            c->setY(finalH - origBottomDist - c->getHeight());
+        }
+        else {
+            // 垂直无锚点：默认为顶部定位，高度固定
+            c->setY(c->getLocalY());
+            c->setHeight(c->getLocalHeight());
+        }
+    }
+}
+
diff --git a/控件 API 文档 (StellarX GUI Framework Controls API Documentation).md b/控件 API 文档 (StellarX GUI Framework Controls API Documentation).md
new file mode 100644
index 0000000..4d591b6
--- /dev/null
+++ b/控件 API 文档 (StellarX GUI Framework Controls API Documentation).md	
@@ -0,0 +1,2651 @@
+# StellarX GUI 框架控件 API 文档 (StellarX GUI Framework Controls API Documentation)
+
+## Control 类 (抽象基类)
+
+**描述：** `Control` 是所有控件的抽象基类，定义了通用的属性和接口，包括位置、尺寸、可见性、重绘标记等基础功能。它提供绘图状态的保存与恢复机制，确保控件的绘制操作不影响全局绘图状态。此外还声明了一系列供子类实现的纯虚函数（如 `draw()` 和 `handleEvent()`），并禁止拷贝（支持移动语义）以防止意外的复制开销。一般情况下，`Control` 不直接实例化，而是作为其他具体控件的父类存在。
+
+**Description:** `Control` is the abstract base class for all controls, defining common properties and interfaces such as position, size, visibility, and the “dirty” flag for redraw. It provides mechanisms to save and restore drawing state to ensure a control’s drawing operations do not affect the global canvas state. It also declares a set of pure virtual functions for subclasses to implement (e.g. `draw()` for rendering and `handleEvent()` for event handling), and it disables copying (but supports move semantics) to prevent accidental heavy copy operations. Typically, `Control` is not instantiated directly; it serves as a base class for concrete controls.
+
+**特性 (Features):**
+
+- 定义控件的基本属性（坐标、尺寸、脏标记等）并提供对应的存取方法 *(Defines basic properties of a control – position, size, “dirty” redraw flag, etc. – and provides getters/setters for them.)*
+- 提供绘图状态管理接口（如 `saveStyle()` / `restoreStyle()`）用于在控件绘制前后保存和恢复全局画笔状态 *(Provides drawing state management (e.g. `saveStyle()` / `restoreStyle()`) to save and restore the global drawing state before and after control rendering.)*
+- 声明纯虚函数接口，如 `draw()`（绘制控件）和 `handleEvent()`（处理事件），所有具体控件都需实现 *(Declares pure virtual functions such as `draw()` (to draw the control) and `handleEvent()` (to handle input events), which all concrete control subclasses must implement.)*
+- 禁止拷贝构造和赋值（但支持移动语义），防止控件被不小心复制 *(Copy construction and assignment are disabled (move semantics are supported) to prevent unintended copying of controls.)*
+
+```mermaid
+classDiagram
+    class Control {
+        +int getX()
+        +int getY()
+        +int getWidth()
+        +int getHeight()
+        +int getRight()
+        +int getBottom()
+        +int getLocalX()
+        +int getLocalY()
+        +int getLocalWidth()
+        +int getLocalHeight()
+        +void setX(int)
+        +void setY(int)
+        +void setWidth(int)
+        +void setHeight(int)
+        +void setIsVisible(bool)
+        +bool isVisible()
+        +void setDirty(bool)
+        +bool isDirty()
+        +void updateBackground()
+        +virtual void draw() = 0
+        +virtual bool handleEvent(const ExMessage&) = 0
+        <<abstract>>
+    }
+    class Canvas {
+        +void addControl(std::unique_ptr<Control>)
+        +void removeControl(Control*)
+        +void clearAllControls()
+        +void setCanvasBkColor(COLORREF)
+        +void setBorderColor(COLORREF)
+        +void setShape(ControlShape)
+        +void setCanvasFillMode(FillMode)
+        +void setCanvasLineStyle(LineStyle)
+        +void setAnchor(AnchorMode)
+        +void adaptiveLayout()
+    }
+    class Label {
+        +void setText(string)
+        +void setTextBkColor(COLORREF)
+        +void setTextdisap(bool)
+    }
+    class Button {
+        +void setOnClickListener(function<void()>)
+        +void setOnToggleOnListener(function<void()>)
+        +void setOnToggleOffListener(function<void()>)
+        +void setTooltipText(string)
+        +void setTooltipOffset(int, int)
+    }
+    class TextBox {
+        +string getText()
+        +void setText(string)
+        +void setMaxCharLen(size_t)
+        +void setMode(TextBoxMode)
+    }
+    class TabControl {
+        +void add(pair< unique_ptr<Button>, unique_ptr<Canvas> >)
+        <<extends Canvas>>
+    }
+    class Dialog {
+        +void close()
+        <<extends Canvas>>
+    }
+    class Table {
+        +void setGridSize(int, int)
+        +void addControl(unique_ptr<Control>)
+        +void setCellSpan(Control&, int, int)
+        <<extends Control>>
+    }
+    class Window {
+        +void addControl(unique_ptr<Control>)
+        +void addDialog(unique_ptr<Control>)
+        +int runEventLoop()
+        +void draw()
+        * controls[0..*] --> Control
+        * dialogs[0..*] --> Dialog
+    }
+    Control <|-- Canvas
+    Control <|-- Label
+    Control <|-- Button
+    Control <|-- TextBox
+    Control <|-- Table
+    Canvas <|-- Dialog
+    Canvas <|-- TabControl
+```
+
+*(上述类图展示了 Control 类体系的继承关系。其中 Window 并非 Control 的子类，但它包含并管理多个 Control 对象。MessageBox 为对话框的工厂类，未在图中展示。/ The above class diagram shows the inheritance hierarchy of the Control system. Note that `Window` is not a subclass of `Control`, but contains and manages multiple Control objects. `MessageBox` is a utility factory class for dialogs and is not shown in the diagram.)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### Control::getX() / getY() / getWidth() / getHeight()
+
+- **用途：** 获取控件的全局坐标位置（左上角 `x, y`）或当前尺寸（宽度、高度）。
+
+- **Purpose:** Returns the control’s global position (coordinates of its top-left corner) or its current size (width and height).
+
+- **参数：** 无。
+
+- **Parameters:** None.
+
+- **返回值：** 分别返回控件的全局 X 坐标、全局 Y 坐标、当前宽度和高度，类型均为 `int`。
+
+- **Return:** The control’s global X coordinate, global Y coordinate, current width, and height, respectively (each as an `int`).
+
+- **行为细节：** 这些方法提供控件在应用窗口坐标系下的位置和大小，通常用于布局计算或调试。注意，全局坐标是相对于整个应用窗口的原点 (0,0)。
+
+- **Details:** These methods give the control’s position and size in the application’s coordinate system (window coordinates). They are often used for layout calculations or debugging. Note that the global coordinates are relative to the application window’s origin (0,0).
+
+- **示例:** 取得控件的位置和高度：
+
+  ```
+  int x = ctrl.getX();
+  int h = ctrl.getHeight();
+  std::cout << "Control at X = " << x << ", height = " << h << std::endl;
+  ```
+
+#### Control::getRight() / getBottom()
+
+- **用途：** 获取控件右边缘的 X 坐标 (`getRight()`) 和底边缘的 Y 坐标 (`getBottom()`)，以全局坐标计算。
+
+- **Purpose:** Returns the X coordinate of the control’s right edge (`getRight()`) and the Y coordinate of its bottom edge (`getBottom()`), in global coordinates.
+
+- **参数：** 无。
+
+- **Parameters:** None.
+
+- **返回值：** 控件右边缘的全局 X 坐标、底边缘的全局 Y 坐标，类型为 `int`。
+
+- **Return:** The control’s right-edge X coordinate and bottom-edge Y coordinate in global coordinates (both `int`).
+
+- **行为细节：** 这两个方法相当于 `getX() + getWidth()` 和 `getY() + getHeight()`，用于方便地获取控件在窗口坐标系中所覆盖的边界位置。
+
+- **Details:** These are convenience methods equivalent to `getX() + getWidth()` and `getY() + getHeight()`, respectively, to easily determine the boundaries of the control in window coordinates.
+
+- **示例:** 判断光标是否在控件矩形范围内：
+
+  ```
+  if (cursorX < ctrl.getRight() && cursorY < ctrl.getBottom()) {
+      // Cursor is within ctrl's bounding box
+  }
+  ```
+
+#### Control::getLocalX() / getLocalY() / getLocalWidth() / getLocalHeight()
+
+- **用途：** 获取控件相对于**父容器**坐标系的位置 (`LocalX, LocalY`) 以及在父容器内的尺寸 (`LocalWidth, LocalHeight`)。
+
+- **Purpose:** Returns the control’s position relative to its **parent container** (`LocalX, LocalY`) and its size within the parent container (`LocalWidth, LocalHeight`).
+
+- **参数：** 无。
+
+- **Parameters:** None.
+
+- **返回值：** 控件在父容器中的 X 坐标、Y 坐标，以及宽度、高度，类型均为 `int`。
+
+- **Return:** The control’s X and Y coordinates within its parent container, and its width and height in that container, all as `int`.
+
+- **行为细节：** 当控件被添加到某个容器（例如 `Canvas`）时，其本地坐标是以该容器的左上角为原点计算的。如果控件没有父容器（直接隶属于窗口），那么本地坐标等同于全局坐标。这些方法对于在容器内部进行控件布局计算非常有用。
+
+- **Details:** If a control is added to a container (e.g. a `Canvas`), its local coordinates are measured from the top-left corner of that container. If the control has no parent container (i.e. it belongs directly to the Window), then its local coordinates are the same as its global coordinates. These methods are useful for layout calculations inside a container.
+
+- **示例:** 获取子控件的本地和全局 X 坐标：
+
+  ```
+  int localX  = childCtrl.getLocalX();
+  int globalX = childCtrl.getX();
+  std::cout << "Child global X: " << globalX 
+            << ", local X in parent: " << localX << std::endl;
+  ```
+
+#### Control::setX(int x) / setY(int y) / setWidth(int w) / setHeight(int h)
+
+- **用途：** 设置控件的全局坐标位置（左上角的 X 或 Y）或调整控件的尺寸（宽度或高度）。
+
+- **Purpose:** Sets the control’s global position (X or Y coordinate of its top-left corner) or adjusts the control’s size (width or height).
+
+- **参数：** `x` 或 `y` 为新的全局横坐标或纵坐标；`w` 为新的宽度；`h` 为新的高度（类型均为 `int`）。
+
+- **Parameters:** `x` or `y` is the new global X or Y coordinate; `w` is the new width; `h` is the new height (all of type `int`).
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 调用这些方法将直接修改控件的位置或大小，并自动将控件标记为“需要重绘”（`dirty` 标志会被置为 `true`），使得在下一次刷新时控件会按照更新后的位置或尺寸重绘。若控件位于某容器中，设置全局坐标会改变它在窗口中的位置，同时其相对父容器的位置也会相应更新。调整尺寸可能需要控件自身处理其内容布局。
+
+- **Details:** These methods immediately update the control’s position or size and mark the control as “dirty” (needs redraw) so that it will be redrawn at the new position or size on the next refresh cycle. If the control is inside a container, changing its global coordinates will move its position within the window, and the control’s local position relative to the parent container will also update accordingly. Resizing a control might require the control to re-layout its content (if applicable).
+
+- **示例:** 将控件移动到窗口坐标 (100, 100) 并将宽度调整为 200：
+
+  ```
+  ctrl.setX(100);
+  ctrl.setY(100);
+  ctrl.setWidth(200);
+  // 高度保持不变，如需调整高度也可调用 ctrl.setHeight(newH);
+  ```
+
+#### Control::isVisible() / setIsVisible(bool visible)
+
+- **用途：** 获取或设置控件的可见状态。当设置为不可见时，控件将不再绘制也不响应事件。
+
+- **Purpose:** Gets or sets the control’s visibility. If a control is set to invisible, it will no longer be drawn or respond to events.
+
+- **参数：** `visible` 为布尔值，`true` 表示控件可见，`false` 表示隐藏控件。
+
+- **Parameters:** `visible` is a boolean; `true` to make the control visible, or `false` to hide it.
+
+- **返回值：** `isVisible()` 返回 `bool`，表示当前可见状态；`setIsVisible()` 无返回值。
+
+- **Return:** `isVisible()` returns a `bool` indicating the current visibility state; `setIsVisible()` returns nothing.
+
+- **行为细节：** 隐藏控件相当于将其 `visible` 状态置为 false，并触发重绘逻辑：被隐藏时控件内容将不再绘制；再次显示（visible=true）时控件会被标记为需要重绘。对于容器控件（如 `Canvas`），该方法被重写以**递归地影响其子控件**：隐藏一个容器时，其所有子控件也随之隐藏；再次显示容器时，子控件也一并显示。
+
+- **Details:** Hiding a control sets its internal visibility to false and triggers the repaint logic: when hidden, the control’s content is not drawn; when made visible again, the control is marked dirty for redraw on the next frame. For container controls (e.g. `Canvas`), this method is overridden to **affect all child controls recursively**: hiding a container will hide all its children; showing the container again will also show its children.
+
+- **示例:**
+
+  ```
+  button.setIsVisible(false);  // Hide the button
+  // ... some operations ...
+  button.setIsVisible(true);   // Show the button again
+  ```
+
+#### Control::setParent(Control* parent)
+
+- **用途：** 设置控件的父容器指针。通常由容器在添加子控件时自动调用，用户很少需要手动调用此函数。
+
+- **Purpose:** Sets the parent container pointer of the control. This is usually called internally when a container adds a child control, and users rarely need to call it manually.
+
+- **参数：** `parent` 为指向新的父容器控件（如 `Canvas` 等）的指针。传入 `nullptr` 则清除父容器关联。
+
+- **Parameters:** `parent` is a pointer to the new parent container (e.g. a `Canvas`). Pass `nullptr` to clear the parent association.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 此方法将内部的父指针设置为指定容器，并相应地改变控件坐标解释方式（有父容器时，本地坐标相对于父容器计算）。当使用容器的 `addControl()` 将控件添加到某容器时，框架内部会自动调用该函数，无需用户干预。**注意：** 如果需要将控件从一个容器转移到另一个容器，除了调用 `setParent()` 之外，还必须在旧容器中移除控件并在新容器中添加控件，否则界面状态将不一致。
+
+- **Details:** This method sets the control’s internal `parent` pointer to the given container and changes how the control’s coordinates are interpreted (with a parent, local coordinates are relative to the parent’s origin). The framework automatically calls this when adding a control to a container via the container’s `addControl()` method, so manual use is seldom needed. **Note:** To move a control from one container to another, you must not only call `setParent()` but also remove the control from the old container and add it to the new one (e.g. via the containers’ `removeControl()` and `addControl()`), otherwise the UI state will be inconsistent.
+
+- **示例:** 将控件从一个 Canvas 转移到另一个：
+
+  ```
+  canvas1.addControl(std::move(ctrl));    // internally calls ctrl.setParent(&canvas1)
+  // ... later, to move ctrl from canvas1 to canvas2:
+  canvas1.removeControl(ctrlPtr);
+  canvas2.addControl(std::move(ctrlPtr)); // internally calls ctrl.setParent(&canvas2)
+  ```
+
+#### Control::setDirty(bool dirty)
+
+- **用途：** 手动设置控件的“需要重绘”标记。当控件的内容或属性改变但没有自动标记时，可调用此函数要求框架在下次刷新时重绘该控件。
+
+- **Purpose:** Manually marks the control as “dirty” (needing redraw). If a control’s content or properties change and it is not automatically flagged, this function can be used to request the framework to redraw the control on the next update.
+
+- **参数：** `dirty` 布尔值；传入 `true` 标记控件需要重绘，传入 `false` 清除重绘标记。
+
+- **Parameters:** `dirty` (bool); pass `true` to mark the control for redraw, or `false` to clear the redraw flag.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 将控件标记为需要重绘 (`dirty = true`) 后，在随后的屏幕刷新循环中，系统将调用该控件的 `draw()` 方法进行重新绘制。通常在更改控件状态后框架会自动标记脏区，无需用户手动调用；但某些情况下（如自定义控件内部状态改变），可通过此方法强制刷新。
+
+- **Details:** After marking a control as dirty (`true`), the framework will invoke the control’s `draw()` on the next refresh to redraw it. Typically, changing a control’s state will automatically mark it dirty, so manual calls are seldom required; however, in some cases (e.g. custom control internal state changes), this method can be used to force a refresh.
+
+- **示例:**
+
+  ```
+  // After updating some internal state of the control:
+  ctrl.setDirty(true);  // request to redraw this control on next frame
+  ```
+
+#### Control::updateBackground()
+
+- **用途：** 释放之前保存的背景快照并重新捕获当前背景，用于在控件尺寸变化或内容变化后更新其背景缓存。调用此函数可确保控件背景的正确性，避免因为尺寸变化导致的背景错位。
+
+- **Purpose:** Discards the previously saved background snapshot and captures the current background behind the control. This is used to update the control’s cached background after its size or content changes, ensuring the control’s background is correct and avoiding misaligned backgrounds due to size changes.
+
+- **参数：** 无。
+
+- **Parameters:** None.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 缺省实现中，`updateBackground()` 先丢弃旧的背景位图（相当于调用内部的 `discardBackground()`），然后在控件新位置和尺寸范围内重新保存一份背景快照。通常在控件大小改变或需要重绘时会自动调用，一般不需要用户手动调用。对于某些自定义控件，在调整大小后可显式调用此方法以刷新背景。
+
+- **Details:** In the default implementation, `updateBackground()` will discard the old background bitmap (essentially calling an internal `discardBackground()`), then capture a fresh snapshot of the background under the control’s current position and new size. This is usually called automatically when a control’s size changes or a redraw is needed, so manual calls are generally not required. In custom controls, you might call this after resizing to refresh the background.
+
+- **示例：** 在自定义控件调整尺寸后更新其背景：
+
+  ```
+  myControl.setWidth(newW);
+  myControl.setHeight(newH);
+  myControl.updateBackground();
+  ```
+
+#### Control::draw() (纯虚函数)
+
+- **用途：** 绘制控件的抽象接口，由具体控件类实现实际的绘图逻辑。
+- **Purpose:** Abstract interface for drawing the control, to be implemented by concrete control classes with the actual rendering logic.
+- **参数：** 无（绘制所需信息由控件的内部状态确定）。
+- **Parameters:** None (drawing is based on the control’s internal state).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** `draw()` 通常由框架在重绘时自动调用，具体控件应在此方法中完成自身内容的绘制。实现时应首先检查控件是否需要绘制（如是否可见、是否脏），然后保存当前绘图状态（如颜色、裁剪区域等），再进行绘制，结束后恢复绘图状态。大多数控件的实现会调用 `Control::saveStyle()` 和 `Control::restoreStyle()` 来保护全局状态。
+- **Details:** The `draw()` method is typically called by the framework when a redraw is required. A concrete control class should implement this to render its content. Implementations should usually check whether the control needs drawing (e.g. visible and dirty flags), then save the current global drawing state (colors, clipping, etc.), perform the control-specific drawing, and finally restore the previous drawing state. Most control implementations will use `Control::saveStyle()` and `Control::restoreStyle()` to preserve the global state during drawing.
+
+#### Control::handleEvent(const ExMessage& msg) (纯虚函数)
+
+- **用途：** 处理输入事件的抽象接口，由具体控件类实现实际的事件响应逻辑。
+
+- **Purpose:** Abstract interface for handling input events, to be implemented by concrete controls with their event response logic.
+
+- **参数：** `msg`，事件消息结构 (`ExMessage`)，包含鼠标、键盘等输入事件的信息。
+
+- **Parameters:** `msg` – an event message (`ExMessage`), containing information about input events (mouse, keyboard, etc.).
+
+- **返回值：** `bool`，指示事件是否被该控件消费处理。返回 `true` 表示事件已被处理（不需要向其他控件继续传递），返回 `false` 则表示控件未处理该事件。
+
+- **Return:** `bool` indicating whether the event was handled/consumed by this control. Returns `true` if the event was handled (and should not propagate further to other controls), or `false` if this control did not handle the event.
+
+- **行为细节：** 框架在捕获到用户输入事件时，会依次将事件传递给窗口内各控件的 `handleEvent()` 方法。每个控件实现应根据事件类型和自身状态决定是否处理该事件。如果控件对事件作出了响应（例如按钮检测到点击），应执行相应逻辑并返回 `true`，否则返回 `false` 让框架继续将事件传递给其他控件。通常情况下，容器控件会先让其子控件有机会处理事件，再根据需要进行额外处理。
+
+- **Details:** When the framework captures an input event, it passes it to each control’s `handleEvent()` in turn. Each control’s implementation should determine whether to act on the event based on the event type and the control’s state. If the control responds to the event (e.g. a Button detects a click inside its bounds), it should perform the appropriate action and return `true`. If not, it returns `false` so the framework knows to continue propagating the event to other controls. Container controls typically give their child controls a chance to handle the event first, and then perform any additional handling if needed.
+
+- **示例：** 在事件循环中检查事件处理结果：
+
+  ```
+  ExMessage msg;
+  // ... get message from system (via peekMessage) ...
+  if (ctrl.handleEvent(msg)) {
+      // The event was handled by ctrl, no further processing
+  }
+  ```
+
+#### Control::setLayoutMode(StellarX::LayoutMode layoutMode_)
+
+- **用途：** 设置控件的布局模式。
+
+- **Purpose:** Set the layout mode of the control.
+
+- **参数：** `layoutMode_`，`StellarX::LayoutMode` 枚举值，定义了两种布局模式：`Fixed`（固定布局）和 `AnchorToEdges`（锚点布局）。默认为固定布局。当布局模式为锚点布局时，根据设置的锚点不同，控件在窗口拉伸时会自动调整位置或尺寸。
+
+- **Parameters:** `layoutMode_` is a value from the `StellarX::LayoutMode` enum defining two layout modes: `Fixed` layout and `AnchorToEdges` anchor layout. By default, controls use Fixed layout. When the layout mode is AnchorToEdges, the control will automatically adjust its position or size when the window is resized, according to the specified anchors.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 当希望某个控件在窗口某一边或者两边与容器的距离保持不变时，可以将其布局模式设置为锚定布局，并通过锚点参数指定锁定的边。设置为固定布局则表示窗口拉伸时控件不自动调整。此函数调用会更新控件内部的布局模式标志。
+
+- **Details:** Use anchor layout mode when you want a control’s distance to one or two edges of its parent (window or container) to remain constant as the window resizes. In anchor mode, the control may move or stretch when the parent is resized, depending on which edges are anchored. Fixed layout (the default) means the control will not move or resize automatically on window resize. Calling this function updates the control’s internal layout mode setting.
+
+- **示例:** 设置控件的布局模式：
+
+  ```
+  button.setLayoutMode(StellarX::LayoutMode::Fixed);          // 固定模式
+  button.setLayoutMode(StellarX::LayoutMode::AnchorToEdges);  // 锚点模式
+  ```
+
+#### Control::steAnchor(StellarX::Anchor anchor_1, StellarX::Anchor anchor_2)
+
+- **用途：** 设置控件的锚点（Anchor）。仅当布局模式为 `AnchorToEdges` 时生效。通过传入两个锚点常量，将控件锁定在父容器的相应边缘或同时锁定两侧。
+
+- **Purpose:** Set the anchor points of the control. This takes effect only when the layout mode is `AnchorToEdges`. By specifying up to two anchor constants, the control can be fixed to corresponding edges of the parent container (one horizontal and/or one vertical edge).
+
+- **参数：** `anchor_1`，`anchor_2`：锚点常量，取值为 `StellarX::Anchor` 枚举的值，包括 `Top`（顶边）, `Bottom`（底边）, `Left`（左边）, `Right`（右边）以及 `NoAnchor`（不锚定）。可以传入一个或两个不同方向的锚点（如一个水平锚点加一个垂直锚点）。如果传入 `NoAnchor`，则表示不在对应方向锚定。
+
+- **Parameters:** `anchor_1` and `anchor_2` are constants from the `StellarX::Anchor` enum: possible values are `Top`, `Bottom`, `Left`, `Right`, or `NoAnchor`. You may provide one or two anchors (typically one horizontal and one vertical) to lock the control’s sides. Providing `NoAnchor` for an argument means no anchor on that axis.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 当控件布局模式为锚定时，锚点设定决定了窗口或容器大小变化时控件的调整行为。例如锚定 `Top` 和 `Bottom` 则控件在垂直方向随容器高度伸展；锚定 `Left` 和 `Right` 则在水平方向随容器宽度伸展；锚定单一边（如 `Top`）则控件保持与容器顶边距离不变。一般应选择最多两个正交方向的锚点进行组合。如果锚点未设置（或为 `NoAnchor`），控件在该方向不随父容器变化。
+
+- **Details:** When using anchor layout, the specified anchors determine how the control reacts to parent size changes. For example, anchoring to `Top` and `Bottom` will make the control stretch vertically with the container’s height; anchoring to `Left` and `Right` will stretch it horizontally with the container’s width. Anchoring to only one edge (e.g. `Top`) means the control stays a fixed distance from that edge and does not resize along that axis. Typically you choose up to two perpendicular edges to anchor. If an anchor is not set (or `NoAnchor`), the control will not adjust on that axis when the parent resizes.
+
+- **示例:** 设置控件同时锚定在容器上下边缘或左右边缘：
+
+  ```
+  button.setLayoutMode(StellarX::LayoutMode::AnchorToEdges);  
+  button.steAnchor(StellarX::Anchor::Top, StellarX::Anchor::Bottom);   // 同时锚定上下（垂直方向随容器改变）
+  // 或锚定左右：
+  button.steAnchor(StellarX::Anchor::Left, StellarX::Anchor::Right);   // 同时锚定左右（水平方向随容器改变）
+  ```
+
+#### Control::getAnchor_1() / getAnchor_2() / getLayoutMode()
+
+- **用途：** 获取控件当前设置的第一个锚点、第二个锚点，以及布局模式。
+
+- **Purpose:** Returns the control’s currently set first anchor, second anchor, and layout mode.
+
+- **参数：** 无。
+
+- **Parameters:** None.
+
+- **返回值：** `getAnchor_1()` 和 `getAnchor_2()` 返回 `StellarX::Anchor` 枚举值，表示控件锚定的两个边（如果未设置则可能返回 `NoAnchor`）。`getLayoutMode()` 返回 `StellarX::LayoutMode` 枚举值，表示控件的布局模式（固定或锚定）。
+
+- **Return:** `getAnchor_1()` and `getAnchor_2()` return a `StellarX::Anchor` value indicating which edges the control is anchored to (returns `NoAnchor` if none set on that slot). `getLayoutMode()` returns a `StellarX::LayoutMode` value indicating the control’s current layout mode (Fixed or AnchorToEdges).
+
+- **行为细节：** 当控件布局模式为固定时，锚点设置通常为 `NoAnchor`（不生效）；当布局模式为锚定时，这两个锚点值决定控件如何响应容器尺寸变化。开发者可通过这些方法查询控件的布局设定，以便在调整布局或调试时使用。
+
+- **Details:** If the control’s layout mode is Fixed, the anchor values will typically be `NoAnchor` (not used). In AnchorToEdges mode, the two anchor values determine how the control responds to parent size changes. These getters allow developers to query the control’s layout configuration, which can be useful for adjusting layouts or debugging.
+
+- **示例:** 检查一个控件是否使用锚定布局：
+
+  ```
+  if (ctrl.getLayoutMode() == StellarX::LayoutMode::AnchorToEdges) {
+      std::cout << "Anchors: " 
+                << ctrl.getAnchor_1() << " and " 
+                << ctrl.getAnchor_2() << std::endl;
+  }
+  ```
+
+### 私有成员函数 (Private/Protected Member Functions)
+
+*(Control 类的大部分私有函数仅供框架内部使用。例如，Control 内部有辅助函数如 `saveStyle()` 和 `restoreStyle()`（用于保存和恢复绘图状态）以及 `discardBackground()`（用于背景管理），还有被禁止的拷贝构造函数等。这些内部接口不对外公开，开发者通常不需要直接调用。/ Most private functions of the Control class are for internal framework use only. For instance, Control has helper functions like `saveStyle()` and `restoreStyle()` for preserving drawing state, `discardBackground()` for background management, and a deleted copy constructor to prevent copying. These internal interfaces are not exposed publicly, and developers do not normally call them directly.)*
+
+## Canvas 类 (画布容器控件)
+
+**描述：** `Canvas` 是一个容器控件，用于分组和管理多个子控件。它作为其他控件的父容器存在，为子控件提供统一的背景和边框样式。Canvas 负责将输入事件传递给其包含的子控件，并按照添加顺序绘制子控件。它本身也继承了 Control 的属性，可以设置背景颜色、边框和形状等。通常用于实现复杂布局或作为对话框等的基础容器。
+
+**Description:** `Canvas` is a container control used for grouping and managing multiple child controls. It acts as a parent for other controls, providing a unified background and border style for its children. The Canvas propagates input events to the controls it contains and draws its child controls in the order they were added. It inherits properties from `Control` and allows customization of background color, border, shape, etc. Canvas is typically used to create complex layouts or serve as a base container for dialogs and other composite interfaces.
+
+**特性 (Features):**
+
+- 支持四种矩形形状（普通矩形、圆角矩形，以上各有边框和无边框版本） *(Supports four rectangle shape variants (standard rectangle and rounded rectangle, each with bordered and borderless options).)*
+- 可自定义填充模式、边框颜色和背景颜色 *(Customizable fill mode, border color, and background color.)*
+- 自动管理子控件的生命周期和事件传递 *(Automatically manages the lifetime of child controls and propagates events to them.)*
+- 支持嵌套容器结构（Canvas 内可再包含 Canvas 等） *(Supports nested container structures (a Canvas can contain other Canvas controls, etc.).)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### Canvas::Canvas(int x, int y, int width, int height)
+
+- **用途：** Canvas 构造函数，创建一个指定位置 (`x, y`) 和尺寸 (`width x height`) 的空白画布容器。
+
+- **Purpose:** Constructor for a Canvas. Creates a blank canvas container at the specified position (`x, y`) with the given width and height.
+
+- **参数：** `x`, `y` 为画布左上角的初始坐标；`width`, `height` 为画布初始宽度和高度。
+
+- **Parameters:** `x`, `y` are the initial coordinates of the canvas’s top-left corner; `width`, `height` are the canvas’s initial width and height.
+
+- **返回值：** 无（构造函数）。
+
+- **Return:** None (constructor).
+
+- **行为细节：** 新建的 Canvas 默认具有无填充、无边框的矩形形状背景（具体取决于默认设置），且初始状态下没有任何子控件。构造后可以使用 `addControl()` 方法向其中添加子控件。Canvas 默认可见，除非显式调用 `setIsVisible(false)`。
+
+- **Details:** The newly created Canvas defaults to a rectangular background (with default fill and no border unless otherwise specified) and initially contains no child controls. After construction, you can add child controls to it using `addControl()`. The Canvas is visible by default unless you explicitly hide it with `setIsVisible(false)`.
+
+- **示例:** 创建一个大小为 300x200 的画布并添加子控件：
+
+  ```
+  Canvas panel(10, 10, 300, 200);
+  panel.setCanvasBkColor(RGB(240, 240, 240));  // 浅灰背景
+  panel.setBorderColor(BLACK);
+  panel.setLinewidth(1);
+  panel.addControl(std::make_unique<Label>(50, 50, "Hello", BLACK));
+  ```
+
+#### Canvas::draw()  (重写自 Control)
+
+- **用途：** 绘制 Canvas 背景并递归绘制其包含的子控件。
+- **Purpose:** Renders the Canvas background and then draws all the child controls contained within it (recursively).
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** Canvas 的 `draw()` 实现会先绘制自身的背景（根据设置的背景颜色、填充模式以及边框样式绘制一个矩形或圆角矩形区域）。然后，Canvas 按照子控件添加的顺序调用每个子控件的 `draw()` 方法进行绘制。绘制时会确保将绘图剪辑限制在 Canvas 区域内，以免子控件绘制越界。
+- **Details:** The Canvas’s `draw()` implementation first draws its own background (filling a rectangle or rounded rectangle area with the configured background color or pattern, and drawing the border if applicable). It then iterates through its child controls in the order they were added, calling each child’s `draw()` method to render them. The rendering is typically clipped to the Canvas’s area to prevent children from drawing outside the canvas bounds.
+
+#### Canvas::handleEvent(const ExMessage& msg)  (重写自 Control)
+
+- **用途：** 将输入事件分发给 Canvas 的子控件处理，并根据需要进行容器自身的处理。
+- **Purpose:** Dispatches input events to the Canvas’s child controls for handling, and performs any container-specific handling if needed.
+- **参数：** `msg`，输入事件信息。
+- **Parameters:** `msg` – input event message (e.g. mouse or keyboard event).
+- **返回值：** 布尔值，指示事件是否被处理。Canvas 会先将事件传递给其子控件按顺序处理，如果有子控件处理了事件则 Canvas 返回 `true`；如果没有子控件处理且 Canvas 本身不需要特殊处理，则返回 `false`。
+- **Return:** Boolean indicating whether the event was handled. The Canvas will pass the event to its children in order; if any child handles the event, Canvas returns `true`. If no child handles it and the Canvas itself has no special handling for the event, it returns `false`.
+- **行为细节：** 当事件（如鼠标点击或键盘按键）发生在 Canvas 区域内时，Canvas 的 `handleEvent` 会遍历所有子控件，调用它们各自的 `handleEvent()`。如果某个子控件报告处理了事件（返回 `true`），Canvas 则停止向后分发并返回 `true`。如果所有子控件都未处理该事件，Canvas 可能针对容器区域进行处理（例如点击空白处取消选中等），若无特殊处理则最终返回 `false`。这种机制保证了子控件有优先响应输入的机会。
+- **Details:** When an event (such as a mouse click or key press) occurs within the Canvas’s area, the Canvas `handleEvent` will iterate through its children and call each child’s `handleEvent()`. If any child returns `true` (indicating the event was handled), the Canvas will stop propagation and return `true` as well. If no child handles the event, the Canvas may perform its own handling for the container area if needed (for example, detecting clicks on empty space to clear a selection), and if no special handling is required it will return `false`. This mechanism ensures child controls get the first chance to respond to input.
+
+#### Canvas::addControl(std::unique_ptr<Control> control)
+
+- **用途：** 将一个子控件添加到 Canvas 容器中进行管理和显示。
+
+- **Purpose:** Adds a child control to the Canvas for management and display.
+
+- **参数：** `control`，一个指向待添加控件的 `unique_ptr`。该控件的生命周期将由 Canvas 接管。
+
+- **Parameters:** `control` – a `unique_ptr` to the control to add. After adding, the Canvas takes ownership of this control’s lifetime.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 该方法会将控件的父指针设置为当前 Canvas（内部调用 `control->setParent(this)`），并将控件存储在 Canvas 的子控件列表中。新增的控件在下一次界面刷新时会被绘制出来。如果 Canvas 当前不可见，添加控件后需要将 Canvas 设为可见才能看到控件。子控件添加后，其位置坐标通常设定为相对于 Canvas 的本地坐标。
+
+- **Details:** This method sets the control’s parent to the current Canvas (calling `control->setParent(this)` internally) and stores the control in the Canvas’s list of child controls. The new child control will be drawn on the next UI update. If the Canvas is currently invisible, you must make it visible for the child to be seen. The child’s position is interpreted as coordinates local to the Canvas.
+
+- **示例:**
+
+  ```
+  auto btn = std::make_unique<Button>(0, 0, 80, 30, "OK");
+  panel.addControl(std::move(btn));  // adds a Button at panel's top-left corner
+  ```
+
+#### Canvas::setShape(StellarX::ControlShape shape)
+
+- **用途：** 设置 Canvas 的外观形状。可以选择矩形或圆角矩形，以及是否绘制边框。
+- **Purpose:** Sets the geometric shape of the Canvas. You can choose a rectangular or rounded-rectangle shape, with or without a border.
+- **参数：** `shape`，`StellarX::ControlShape` 枚举值。对于 Canvas，一般支持的值包括 `RECTANGLE`/`B_RECTANGLE`（有边框/无边框矩形）和 `ROUND_RECTANGLE`/`B_ROUND_RECTANGLE`（有边框/无边框圆角矩形）。
+- **Parameters:** `shape` – a value from the `StellarX::ControlShape` enum. For Canvas, typically supported options are `RECTANGLE`/`B_RECTANGLE` (bordered/borderless rectangle) and `ROUND_RECTANGLE`/`B_ROUND_RECTANGLE` (bordered/borderless rounded rectangle).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 该方法会改变 Canvas 绘制背景和边框的方式。例如选择无边框的形状时，Canvas 绘制时将不描绘边框线。若选择圆角矩形，则绘制时使用预设的圆角半径（可通过相关接口调整圆角大小）。调用此方法会使 Canvas 标记为脏，需要重绘以应用新形状。
+- **Details:** This method changes how the Canvas draws its background and border. For example, choosing a borderless shape means the Canvas will not draw a border line when rendering. If a rounded rectangle shape is selected, the Canvas will draw with rounded corners (using a preset corner radius which may be adjustable through related functions). Calling this method marks the Canvas as dirty for redraw so that the new shape takes effect.
+
+#### Canvas::setCanvasfillMode(StellarX::FillMode mode) / setCanvasBkColor(COLORREF color)
+
+- **用途：** 设置 Canvas 的填充模式和背景颜色。
+- **Purpose:** Sets the Canvas’s fill mode and background color.
+- **参数：** `mode` 为填充模式枚举，表示画布背景的填充样式；`color` 为颜色值（COLORREF），表示画布背景颜色。
+- **Parameters:** `mode` is a fill mode (from `StellarX::FillMode`) determining the canvas background’s brush style; `color` is a COLORREF value specifying the canvas background color.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** `setCanvasfillMode` 可以设置画布背景是纯色填充 (`Solid`)、无填充 (`Null`)、还是使用系统图案 (`Hatched`) 等等。`setCanvasBkColor` 则指定填充颜色（当模式为纯色或作为图案底色时起作用）。通常两者结合使用：先设置填充模式，再设置颜色。例如，对于纯色背景，设置模式为 `Solid` 并指定颜色；对于图案填充，设置模式为 `Hatched` 并指定前景色，再通过其他接口指定具体图案类型（如水平线、网格等）。调用这些方法会使 Canvas 标记为需要重绘。
+- **Details:** `setCanvasfillMode` selects how the canvas background is filled: for example, `Solid` for a solid color fill, `Null` for no fill (transparent background), or `Hatched` for a hatched pattern fill. `setCanvasBkColor` sets the background color (used for solid fills or as the base color for patterns). Typically you use these together: e.g., to get a solid colored background, set fill mode to `Solid` and pick a color; for a hatched pattern, set mode to `Hatched`, pick a color (as the pattern’s color), and use other interfaces to choose the specific pattern style (horizontal lines, crosshatch, etc.). Calling these marks the Canvas as dirty so it will redraw with the new settings.
+
+#### Canvas::setBorderColor(COLORREF color) / setCanvasLineStyle(StellarX::LineStyle style) / setLinewidth(int width)
+
+- **用途：** 设置 Canvas 边框的颜色、线条样式和边框线宽度。
+- **Purpose:** Sets the Canvas border’s color, line style, and border line width.
+- **参数：** `color` 为边框颜色 (COLORREF)；`style` 为线条样式枚举 (`StellarX::LineStyle`，如实线、虚线等)；`width` 为边框线的像素宽度。
+- **Parameters:** `color` is the border color (COLORREF); `style` is the border line style (`StellarX::LineStyle` enum, e.g. solid, dashed); `width` is the border line thickness in pixels.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 这些方法定制 Canvas 边框的外观。`setBorderColor` 会改变边框绘制的颜色；`setCanvasLineStyle` 改变边框线型，例如虚线或点线；`setLinewidth` 则调整边框线粗细。如果 Canvas 当前形状是无边框变体（如 `B_RECTANGLE`），即使设置了颜色和线宽，在形状不变的情况下边框仍不会绘制。需要将形状切换为有边框的类型才能看到边框效果。修改边框属性后，Canvas 会被标记为脏以在下次重绘时应用变化。
+- **Details:** These methods customize the appearance of the Canvas’s border. `setBorderColor` changes the border’s color; `setCanvasLineStyle` changes the border’s line pattern (e.g. solid or dashed); `setLinewidth` adjusts the border line thickness. Note that if the Canvas’s current shape is a borderless variant (e.g. `B_RECTANGLE`), then the border will not be drawn even if a color or width is set — you would need to switch to a bordered shape for the border to become visible. After changing any border property, the Canvas is marked dirty so the changes will show on the next redraw.
+
+#### Canvas::setIsVisible(bool visible) (重写自 Control)
+
+- **用途：** 重写 `Control::setIsVisible`，以在更改 Canvas 可见性时同步影响其所有子控件。
+- **Purpose:** Overrides `Control::setIsVisible` to ensure that changing the Canvas’s visibility also affects all its child controls.
+- **参数：** `visible`，布尔值。`true` 表示显示 Canvas（及其子控件），`false` 表示隐藏 Canvas（其子控件也一并隐藏）。
+- **Parameters:** `visible` (bool). `true` to show the Canvas (and its children), or `false` to hide the Canvas (and hide all its children).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 当 Canvas 被隐藏时，它所包含的所有子控件将自动不可见并停止响应事件；当 Canvas 再次显示时，其子控件也会重新显示并可以响应事件。Canvas 的此实现通过遍历所有子控件，将它们的可见状态与 Canvas 保持一致。这对于整个容器一起显示/隐藏非常方便。例如隐藏一个对话框 Canvas，会一并隐藏对话框上的所有按钮和文本。
+- **Details:** When a Canvas is hidden, all controls it contains become invisible and stop receiving events. When the Canvas is shown again, its children become visible and active once more. This override works by iterating through all child controls and syncing their visibility to match the Canvas’s visibility. This is convenient for showing or hiding a whole group of controls at once. For example, hiding a dialog’s Canvas will hide all the buttons and text on that dialog as well.
+
+#### Canvas::setDirty(bool dirty) (重写自 Control)
+
+- **用途：** 重写 `Control::setDirty`，在标记 Canvas 自身需要重绘的同时，确保其子控件也适当标记为需要重绘。
+- **Purpose:** Overrides `Control::setDirty`. In addition to marking the Canvas itself as needing redraw, it ensures its child controls are also marked appropriately.
+- **参数：** `dirty`，布尔值。`true` 表示将 Canvas（和潜在需要的子控件）标记为需要重绘，`false` 表示清除重绘标记。
+- **Parameters:** `dirty` (bool). `true` to mark the Canvas (and potentially its children) as needing redraw, `false` to clear the redraw flag.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** Canvas 实现的 `setDirty(true)` 会将容器内所有子控件的脏标记也设为 true，以便在下一帧对整个容器区域重绘。这样可以确保如果 Canvas 的整体外观需要更新（例如背景改变），其子控件在新背景上重新绘制，从而避免残影。清除脏标记时（传入 false），Canvas 会清除自身以及所有子元素的需要重绘标记。一般情况下，开发者无需直接调用此函数，因为添加子控件或修改 Canvas 属性时框架会自动处理重绘。
+- **Details:** The Canvas’s implementation of `setDirty(true)` will mark all child controls as dirty as well, so that the entire container area (background and children) will be redrawn on the next frame. This ensures that if the Canvas’s overall appearance changes (e.g. background color changes), its children will redraw on the new background to avoid artifacts. When clearing the dirty flag (`false`), the Canvas clears its own and all children’s dirty flags. Typically, developers don’t need to call this directly, as adding/removing children or changing Canvas properties will automatically trigger the necessary redraws.
+
+#### Canvas::onWindowResize() (重写自 Control)
+
+- **用途：** 当父窗口大小改变时，调整 Canvas 及其子控件的布局。
+- **Purpose:** Adjusts the Canvas and its children’s layout when the parent window (or container) is resized.
+- **参数：** 无（由框架在窗口尺寸变化时调用）。
+- **Parameters:** None (called by the framework when the parent window/container is resized).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 当应用窗口大小变化时，框架会调用所有控件的 `onWindowResize`。Canvas 的实现会检查自身及子控件的锚点设置或其它依赖容器尺寸的属性，调整它们的位置和大小。例如，如果 Canvas 本身被父窗口锚定左右边缘，则窗口变大时 Canvas 宽度相应增大；如果 Canvas 的某个子控件锚定在 Canvas 的右边缘，当 Canvas 拉伸时，该子控件会相应移动或扩展。通常该方法内部会调用每个子控件的 `onWindowResize` 来递归传递尺寸变化事件。
+- **Details:** When the application window is resized, the framework calls `onWindowResize` on all controls. The Canvas implementation will examine its own anchor settings and those of its child controls, adjusting positions and sizes as needed. For example, if the Canvas itself is anchored to the left and right edges of its parent window, its width will increase as the window gets larger; if a child control of the Canvas is anchored to the Canvas’s right edge, that child will move or resize accordingly when the Canvas expands. The Canvas’s `onWindowResize` typically calls each child’s `onWindowResize` in turn, propagating the resize event recursively.
+
+#### Canvas::requestRepaint(Control* parent) (重写自 Control)
+
+- **用途：** 当 Canvas 的某个子控件需要父级容器重绘时调用，用于将重绘请求向上传递至更高层容器或窗口。
+- **Purpose:** Called when a child control of the Canvas requests the parent container to repaint; it propagates the repaint request upward to higher-level containers or the window.
+- **参数：** `parent`，指向请求重绘的子控件的指针。
+- **Parameters:** `parent` – pointer to the child control that is requesting its parent to repaint (usually `this` Canvas in context).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** Canvas 覆盖了 `requestRepaint` 以便在其子控件（如 Canvas 内的某控件）的重绘需求超出该子控件自身区域时，通知上层需要重绘更大的区域。例如一个子控件动画可能需要整个 Canvas 重绘背景，Canvas 会通过调用其父容器（可能是 Window）的 `requestRepaint` 或直接标记父窗口脏区的方式，确保重绘覆盖整个 Canvas 区域。对于最终的应用窗口，实现上通常会将此请求转化为对窗口的刷新调用。
+- **Details:** The Canvas overrides `requestRepaint` so that if one of its child controls needs a repaint beyond its own area (for example, an animation or effect that affects the background of the Canvas), the Canvas can inform its own parent that a larger area needs redrawing. In practice, the Canvas might call its parent container’s `requestRepaint` or mark the parent (e.g. the `Window`) as dirty to ensure the entire Canvas area gets refreshed. At the top level (the application window), this typically results in scheduling a window repaint/update call.
+
+## Label 类 (简单文本标签控件)
+
+**描述：** `Label` 是用于显示静态文本的简单控件，提供基本的文本显示功能。它支持设置文本内容、文字颜色、背景颜色，以及是否透明背景。Label 不处理用户输入事件，是一种只读、不可交互的控件类型，常用于显示说明、标题或状态信息。
+
+**Description:** `Label` is a simple control for displaying static text. It provides basic text display functionality, allowing you to set the text content, text color, background color, and toggle a transparent background. The Label does not handle user input events (it is read-only and non-interactive), and is typically used to display descriptive text, titles, or status information.
+
+**特性 (Features):**
+
+- 支持背景透明/不透明模式 *(Supports either transparent or opaque background for the text.)*
+- 完整的文本样式控制（字体、颜色、效果等） *(Offers full text style control including font, color, and effects.)*
+- 自动适应文本内容（根据内容调整控件大小） *(Automatically adjusts to fit the text content.)*
+- 轻量级，无额外事件处理开销 *(Lightweight control with no event-handling overhead.)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### Label::Label(int x, int y, std::string text = "标签", COLORREF textColor = BLACK, COLORREF bkColor = RGB(255,255,255))
+
+- **用途：** Label 构造函数，在指定位置创建一个文本标签，带有初始文本和颜色设置。
+
+- **Purpose:** Constructor for a Label. Creates a text label at the specified position with initial text and color settings.
+
+- **参数：** `x`, `y` 为标签左上角坐标；`text` 为显示的文本（默认为 "标签"）；`textColor` 为文字颜色（默认黑色）；`bkColor` 为背景颜色（默认白色）。
+
+- **Parameters:** `x`, `y` are the coordinates of the label’s top-left corner; `text` is the text to display (default "标签"); `textColor` is the text color (default BLACK); `bkColor` is the background color (default white).
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 创建 Label 时，可选地指定文本内容及颜色。默认情况下，Label 背景不透明，使用提供的背景色填充。Label 会根据文本长度和当前字体计算自身宽度和高度以适应文本完全显示。
+
+- **Details:** When constructing a Label, you can optionally specify the text content and colors. By default, the Label’s background is opaque and filled with the given background color. The Label will calculate its own width and height based on the text length and current font so that the entire text is visible.
+
+- **示例:** 创建一个带有蓝色文字、白底的标签：
+
+  ```
+  Label lbl(50, 50, "Status: Ready", BLUE, WHITE);
+  ```
+
+#### Label::draw()  (重写自 Control)
+
+- **用途：** 绘制标签的文本内容，以及（如果非透明）绘制背景矩形。
+- **Purpose:** Renders the label’s text content and, if the background is opaque, draws a background rectangle behind the text.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** Label 的 `draw()` 先根据 `textBkDisap`（文本背景是否透明）决定是否填充背景色：如果不透明，则绘制一个背景色矩形；如果透明，则跳过背景填充，让父容器的背景透过。随后，使用控件的字体和文字颜色在指定位置绘制文本。Label 不包含复杂图形，仅绘制单行文本（如果文本过长可能自动截断或换行，具体取决于实现）。
+- **Details:** In `draw()`, the Label checks its `textBkDisap` flag (which indicates whether the text background is transparent). If the background is opaque, it fills a rectangle with the label’s background color; if transparent, it skips filling, allowing the parent’s background to show through. Then the Label draws its text string at its position using the label’s font and text color. The Label typically handles only a single line of text (if the text is too long, it may be truncated or wrapped depending on the implementation).
+
+#### Label::hide()
+
+- **用途：** 快速隐藏标签控件并恢复其背景。
+- **Purpose:** Quickly hides the label control and restores the background that was behind it.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 调用 `hide()` 将使该 Label 控件立即从界面上消失：它会先将控件当前背景区域恢复（绘制回之前保存的父背景像素），然后将自身标记为隐藏状态（等效于 `setIsVisible(false)`）。这样一来，标签文字消失，原先其所在位置将显示出父容器的背景。与直接调用 `setIsVisible(false)` 相比，`hide()` 方法保证了背景立即恢复，从而避免控件隐藏后留下空白区域直到下一帧重绘。
+- **Details:** Calling `hide()` causes the Label to disappear from the interface immediately. The method restores the pixels of the background that were behind the label (painting back the saved parent background in the label’s area), then marks the label as not visible (equivalent to `setIsVisible(false)`). As a result, the label text vanishes and the area where it was returns to showing the parent container’s background. Compared to directly calling `setIsVisible(false)`, the `hide()` method ensures the background is immediately restored, avoiding a blank region where the label was, up until the next frame redraw.
+
+#### Label::setTextdisap(bool key)
+
+- **用途：** 设置标签文本背景是否透明显示。
+
+- **Purpose:** Configures whether the label’s text background is transparent.
+
+- **参数：** `key` 布尔值；`true` 表示背景透明（不绘制背景颜色），`false` 表示使用当前背景色填充文字背景。
+
+- **Parameters:** `key` (bool); `true` to make the background transparent (no background color drawn), `false` to use the current background color behind the text.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 将此属性设为 true 后，Label 在绘制时将不再绘制背景矩形，文本将直接绘制在父容器背景上，使文字背景呈透明效果。设为 false 则会用 `setTextBkColor` 设置的颜色（或构造时提供的背景色）填充文字背景区域。修改此属性会将 Label 标记为需要重绘。
+
+- **Details:** Setting this property to true means the Label will not draw its background rectangle when rendering, so the text will appear directly over whatever is behind the label, giving a transparent background effect. If set to false, the Label will fill the background behind the text with the color specified by `setTextBkColor` (or the background color provided at construction). Changing this setting marks the Label as dirty for redraw.
+
+- **示例:** 将标签设置为透明背景：
+
+  ```
+  lbl.setTextBkColor(YELLOW);    // 设置背景色为黄色
+  lbl.setTextdisap(true);       // 开启背景透明（将不实际绘制黄色背景）
+  ```
+
+#### Label::setTextBkColor(COLORREF color)
+
+- **用途：** 更改标签文字背景矩形的颜色。
+- **Purpose:** Changes the background color rectangle behind the label’s text.
+- **参数：** `color`，COLORREF 格式的颜色值。
+- **Parameters:** `color` – a COLORREF color value.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 此方法设置 Label 背景矩形的颜色，仅当 `textBkDisap` 为 false（不透明背景）时有效。修改背景颜色会触发重绘，使新的颜色生效。如果希望完全透明背景，应使用 `setTextdisap(true)` 而不是将背景色设置为与父色相同。
+- **Details:** This method sets the color of the rectangle drawn behind the label’s text. It takes effect only if `textBkDisap` is false (i.e., the background is opaque). Changing the background color will mark the label for redraw so the new color is shown. If a fully transparent background is desired, use `setTextdisap(true)` rather than trying to match the background color to the parent.
+
+#### Label::setText(std::string text)
+
+- **用途：** 更新标签显示的文本内容。
+
+- **Purpose:** Updates the text content displayed by the label.
+
+- **参数：** `text`，要设置的新文本字符串。
+
+- **Parameters:** `text` – the new text string to display.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 修改 Label 的文本后，控件会重新计算自身尺寸以适应新文本（如果实现支持自动尺寸调整），然后标记为需要重绘以显示新的文本内容。文本更改不会影响字体和颜色等样式，这些属性保持不变。
+
+- **Details:** Changing the label’s text will cause the control to recalculate its size to fit the new content (if it is implemented to auto-size), and then mark itself dirty to redraw the updated text. The text change does not affect style properties like font or color; those remain as previously set.
+
+- **示例:**
+
+  ```
+  lbl.setText("Processing...");
+  // Label will resize (if needed) and display "Processing..."
+  ```
+
+## Button 类 (多功能按钮控件)
+
+**描述：** `Button` 是一个多功能的按钮控件，支持多种交互模式和视觉样式。它提供普通按钮的点击功能，也可以配置为切换（开/关）模式，并包含禁用状态的处理。Button 支持多种几何形状（矩形、圆角矩形、圆形、椭圆形，均有有无边框版本）以及丰富的样式自定义选项，如不同状态下的颜色、填充模式和文字提示等。典型应用场景包括窗体中的确认/取消按钮、开关按钮等。
+
+**Description:** `Button` is a versatile button control that supports multiple interaction modes and visual styles. It provides the functionality of a standard clickable button, can be configured as a toggle (on/off) button, and handles a disabled state. The Button supports various geometric shapes (rectangle, rounded rectangle, circle, ellipse – each available with or without border) and rich style customization options, such as different colors for different states, fill patterns, and tooltip text. Typical use cases include OK/Cancel buttons in forms, toggle switches, etc.
+
+**特性 (Features):**
+
+- 支持三种工作模式：普通、切换、禁用 *(Supports three operating modes: normal, toggle, and disabled.)*
+- 提供八种几何形状（矩形、圆角矩形、圆形、椭圆形，各有带边框和无边框版本） *(Offers eight geometric shape options: rectangle, rounded-rectangle, circle, ellipse – each in bordered or borderless form.)*
+- 可自定义不同状态下的颜色（默认状态、悬停高亮、按下/选中状态等） *(Customizable colors for different states – e.g. default, hover highlight, pressed/selected state.)*
+- 多种背景填充模式（纯色填充、图案填充、图像填充） *(Multiple background fill modes: solid color, hatched pattern, or image fill.)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### Button::Button(...) 构造函数重载 (Button Constructors)
+
+- **用途：** 初始化一个按钮控件，指定位置、尺寸、显示文本，以及可选的颜色和模式参数。Button 提供多个重载构造函数，用于不同程度的定制。
+
+- **Purpose:** Initializes a new Button control at a given position and size with display text, along with optional color and mode parameters. Multiple overloaded constructors are provided for different levels of customization.
+
+- **构造函数 1 参数：** `(int x, int y, int width, int height, const std::string text, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE)` - 创建一个按钮，使用默认颜色，指定按钮模式（默认为普通按钮）和形状（默认为有边框矩形）。
+
+- **Constructor 1 Parameters:** `(int x, int y, int width, int height, const std::string text, StellarX::ButtonMode mode = StellarX::ButtonMode::NORMAL, StellarX::ControlShape shape = StellarX::ControlShape::RECTANGLE)` – Creates a button at (`x, y`) with given size and text, using default colors. You can specify the button’s mode (defaults to normal push-button) and shape (defaults to a bordered rectangle).
+
+- **构造函数 2 参数：** `(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)` - 创建一个按钮，并指定两种颜色：`ct` 和 `cf`。通常用于切换按钮的两种状态颜色或普通按钮的默认色和按下时高亮色。
+
+- **Constructor 2 Parameters:** Same as above, plus `COLORREF ct, COLORREF cf` – Creates a button allowing specification of two custom colors (`ct` and `cf`). These could represent two state colors (e.g. for toggle on/off states) or a default and pressed color for a normal button.
+
+- **构造函数 3 参数：** `(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)` - 创建一个按钮，并指定三种颜色：例如默认颜色 (`ct`)、悬停或按下时的高亮颜色 (`ch`)、以及切换关闭状态颜色 (`cf`) 等。
+
+- **Constructor 3 Parameters:** Same as above, plus a third color `COLORREF ch` – Creates a button with three custom colors. For instance, you might use one for the default state (`ct`), one for hover/pressed highlight (`ch`), and one for an alternate or “off” state (`cf`) in toggle mode.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** Button 在创建时会初始化其文字样式（使用默认字体，文本颜色取决于提供的参数或默认值）。默认情况下，各状态颜色采用框架预设或由参数指定。如果按钮模式为 TOGGLE，初始化时会设定一个“未按下”（off）状态。构造完成后，按钮立即可见和可交互（前提是它被添加到 Window 或 Canvas 中并且容器可见）。
+
+- **Details:** When constructed, the Button initializes its text style (using a default font, with text color based on provided parameters or defaults). By default, the button’s various state colors are set to framework defaults unless overridden by constructor parameters. If the button mode is TOGGLE, it starts in the “unpressed” (off) state initially. After construction, the button is ready to be displayed and interact with the user (provided it’s added to a Window or Canvas that is visible).
+
+- **示例:**
+
+  ```
+  // 普通按钮，默认颜色
+  Button btn1(100, 50, 80, 30, "OK");  
+  // 切换按钮，自定义两种状态颜色（绿色表示ON，红色表示OFF）
+  Button toggleBtn(200, 50, 80, 30, "Switch", 
+                   RGB(0,255,0), RGB(255,0,0), 
+                   StellarX::ButtonMode::TOGGLE);
+  ```
+
+#### Button::draw()  (重写自 Control)
+
+- **用途：** 绘制按钮的外观，包括背景形状、填充和文字。根据按钮的当前状态（正常、悬停、按下、禁用等）使用不同的样式绘制。
+- **Purpose:** Renders the button’s appearance, including its background shape, fill, and text. The drawing adapts to the button’s current state (normal, hovered, pressed, disabled, etc.), using the appropriate style for each state.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** Button 的 `draw()` 会根据控件的 `ButtonMode` 和当前状态选择颜色和填充：例如在普通模式下，未按下时使用默认底色，按下时使用高亮/按下颜色；在 TOGGLE 模式下，根据按钮 on/off 状态采用不同的底色。绘制流程通常包括：填充背景（纯色或图案或图像，根据设置的 FillMode），绘制边框（如果形状是带边框类型），然后绘制按钮文本。禁用状态下通常会以灰度或半透明效果绘制使其外观变暗。整个绘制过程中会调用 `saveStyle()` / `restoreStyle()` 以确保绘图属性不会泄漏影响其他控件。
+- **Details:** The Button’s `draw()` selects colors and fills based on the `ButtonMode` and the current state of the control. For example, in normal mode when not pressed, it uses the default background color; when pressed or hovered, it may use a highlight color. In TOGGLE mode, the background color will depend on whether the button is toggled on or off. The drawing routine typically: fills the background (with a solid color, hatched pattern, or image as configured via FillMode), draws the border if the shape has one, and then draws the button’s text centered in the control. If the button is disabled, the rendering may use grayed-out or semi-transparent effects to make it appear inactive. The `saveStyle()` and `restoreStyle()` are used around the drawing code to ensure that graphics settings do not bleed over to other controls.
+
+#### Button::handleEvent(const ExMessage& msg)  (重写自 Control)
+
+- **用途：** 响应用户输入事件，实现按钮的点击和切换等交互行为。
+- **Purpose:** Handles user input events to implement the button’s click and toggle interactions.
+- **参数：** `msg`，事件消息（通常是鼠标事件）。
+- **Parameters:** `msg` – the event message (typically a mouse event).
+- **返回值：** 布尔值，表示事件是否被按钮处理。鼠标按下和释放在按钮区域内将被按钮消费并返回 `true`，否则返回 `false`。
+- **Return:** Boolean indicating whether the event was handled by the button. A mouse down/up within the button’s area will be consumed (returning `true`), otherwise the function returns `false`.
+- **行为细节：** 当鼠标在按钮区域按下、释放时，按钮的 `handleEvent` 会捕获这些事件：
+  - 对于普通按钮模式（NORMAL），在检测到一次完整的点击（鼠标按下并在按钮内释放）时，触发一次点击动作（执行已注册的 onClick 回调）并将按钮临时绘制为按下状态。
+  - 对于切换模式（TOGGLE），在鼠标点击释放时切换按钮状态：如果之前处于 OFF，则变为 ON（并执行 onToggleOn 回调）；反之变为 OFF（执行 onToggleOff 回调）。切换后按钮会保持在新状态。
+  - 若按钮被禁用（DISABLED 模式或显式禁用），则不会处理任何事件，直接返回 `false`。
+     按钮处理了事件后会调用 `flushmessage` 清除多余的鼠标或键盘事件，防止重复触发。未点击在按钮上的事件（例如鼠标在按钮外释放）则不会被按钮处理。
+- **Details:** When the mouse is pressed or released over the button, the button’s `handleEvent` will react:
+  - In NORMAL mode, if it detects a full click (mouse down and then up inside the button bounds), it triggers a click action (invokes the registered onClick callback) and visually shows a pressed state momentarily.
+  - In TOGGLE mode, when the mouse click is released on the button, it toggles the button’s state: if it was OFF, it switches to ON (and invokes the onToggleOn callback); if it was ON, it switches to OFF (invoking onToggleOff). The button remains in the new state after the click, indicating its toggled position.
+  - If the button is disabled (in DISABLED mode or explicitly made inactive), it ignores events and returns `false` (no handling).
+     After handling a click, the button may call `flushmessage` to clear any additional mouse/keyboard events in the queue to prevent multiple processing of the same user action. Events that do not result in a click on the button (e.g., releasing the mouse outside the button) are not handled by the button (function returns `false`).
+
+#### Button::setOnClickListener(std::function<void()>&& callback)
+
+- **用途：** 为按钮设置点击事件的回调函数。当按钮以普通模式被点击时调用此回调。
+
+- **Purpose:** Assigns a callback function to be invoked when the button is clicked (in normal mode).
+
+- **参数：** `callback`，右值引用的函数对象或 lambda，参数为 void，无返回值。
+
+- **Parameters:** `callback` – an rvalue reference to a function object or lambda with signature `void()` (no parameters, no return).
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 通过此方法可以为按钮注册一个函数，当按钮在 NORMAL 模式下被按下并释放时（完成一次点击）执行该函数。对于 TOGGLE 模式，此回调不会被调用（应使用切换回调）。可以传入 lambda 表达式或函数指针。注意存储的是 std::function，因此也可以绑定成员函数。调用此方法会替换之前设置的点击回调。
+
+- **Details:** This method registers a function to be called when the button is clicked in NORMAL mode (mouse pressed and released on the button). In TOGGLE mode, this callback is not used (use toggle callbacks instead). You can pass a lambda or function pointer; it is stored internally as an `std::function<void()>` so you can also bind member functions. Calling this replaces any previously set click callback.
+
+- **示例:**
+
+  ```
+  btn1.setOnClickListener([](){
+      std::cout << "Button clicked!" << std::endl;
+  });
+  ```
+
+#### Button::setOnToggleOnListener(std::function<void()>&& callback) / Button::setOnToggleOffListener(std::function<void()>&& callback)
+
+- **用途：** 为切换按钮模式设置打开/关闭状态切换时的回调函数。
+- **Purpose:** Sets callback functions to be called when a toggle-mode button switches to the ON state or OFF state.
+- **参数：** `callback`，右值引用的函数对象或 lambda，签名为 `void()`，无参数。使用 `setOnToggleOnListener` 为按钮切换到 ON 时设置回调；使用 `setOnToggleOffListener` 为切换到 OFF 时设置回调。
+- **Parameters:** `callback` – an rvalue reference to a function object or lambda with signature `void()`. Use `setOnToggleOnListener` to set the callback for when the button switches to ON, and `setOnToggleOffListener` for when it switches to OFF.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 当按钮处于 TOGGLE 模式时，每次用户点击按钮都会在 ON 和 OFF 状态之间切换。`setOnToggleOnListener` 注册的函数将在按钮从 OFF 变为 ON 时执行；`setOnToggleOffListener` 注册的函数将在按钮从 ON 变为 OFF 时执行。通过这两个回调，可以分别处理按钮打开和关闭两种情况下的逻辑。普通模式下不会调用这些回调。调用这些方法会覆盖之前设置的对应回调函数。
+- **Details:** In TOGGLE mode, each time the user clicks the button it toggles between ON and OFF states. The function set via `setOnToggleOnListener` will be called when the button transitions from OFF to ON, and the function set via `setOnToggleOffListener` will be called when it transitions from ON to OFF. These allow you to handle the logic for the button being turned on and turned off separately. In normal button mode, these callbacks are never invoked. Calling these methods replaces any previously set callback for the respective toggle event.
+
+#### Button::setbuttonMode(StellarX::ButtonMode mode)
+
+- **用途：** 设置按钮的工作模式。可在普通按钮、切换按钮和禁用三种模式之间切换。
+- **Purpose:** Sets the button’s operating mode, switching between normal button, toggle button, or disabled.
+- **参数：** `mode`，`StellarX::ButtonMode` 枚举值，可以是 `NORMAL`（普通）、`TOGGLE`（切换）或 `DISABLED`（禁用）。
+- **Parameters:** `mode` – a value from the `StellarX::ButtonMode` enum: `NORMAL`, `TOGGLE`, or `DISABLED`.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 调用此方法会改变按钮的行为模式：
+  - 切换到 `NORMAL` 模式：按钮每次点击不会保持状态，每次点击触发一次点击回调。
+  - 切换到 `TOGGLE` 模式：按钮具有开/关两种状态，用户每点击一次状态翻转并保持，触发相应的切换回调。
+  - 切换到 `DISABLED` 模式：按钮不再响应任何鼠标交互，也通常会绘制为灰色不可用状态。
+     如果当前模式切换为 DISABLED，按钮会立即进入禁用外观；如果从 DISABLED 恢复为 NORMAL/TOGGLE，则重新启用交互。
+- **Details:** Calling this changes the button’s behavior:
+  - `NORMAL`: the button does not maintain state; each click simply triggers the onClick callback once.
+  - `TOGGLE`: the button has an on/off state that flips with each click and remains in that state, triggering the corresponding toggle callback on each change.
+  - `DISABLED`: the button stops responding to mouse interactions and is typically drawn with a grayed-out or inactive appearance.
+     When switched to DISABLED, the button immediately updates to its disabled look; switching from DISABLED back to NORMAL or TOGGLE re-enables interaction and restores its active appearance.
+
+#### Button::setROUND_RECTANGLEwidth(int width) / setROUND_RECTANGLEheight(int height)
+
+- **用途：** 当按钮形状为圆角矩形时，设置其圆角的水平和垂直半径尺寸。
+
+- **Purpose:** When the button’s shape is a rounded rectangle, sets the horizontal and vertical radius of its corners.
+
+- **参数：** `width` 为圆角椭圆的宽度半径，`height` 为圆角椭圆的高度半径，单位为像素。
+
+- **Parameters:** `width` is the horizontal radius of the corner’s ellipse (in pixels), `height` is the vertical radius of the corner’s ellipse (in pixels).
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 这两个方法在按钮形状为 `ROUND_RECTANGLE` 或 `B_ROUND_RECTANGLE` 时才有意义。它们分别设置按钮圆角的水平方向和垂直方向曲率大小（值越大，角越圆）。修改圆角尺寸会导致按钮重新绘制，以采用新的圆角大小。如果按钮当前不是圆角矩形形状，这些调用不会影响形状，直到形状被设置为圆角矩形才会生效。
+
+- **Details:** These methods are meaningful only if the button’s shape is `ROUND_RECTANGLE` or `B_ROUND_RECTANGLE`. They define the curvature of the button’s corners in the horizontal and vertical directions (larger values produce more rounded corners). Changing these values will mark the button for redraw to apply the new corner radii. If the button is not currently a rounded rectangle shape, calling these has no visible effect until the shape is set to a rounded rectangle.
+
+- **示例:**
+
+  ```
+  btn1.setButtonShape(StellarX::ControlShape::ROUND_RECTANGLE);
+  btn1.setROUND_RECTANGLEwidth(15);
+  btn1.setROUND_RECTANGLEheight(15);
+  // 以上代码将 btn1 设置为圆角矩形，圆角尺寸为 15x15 像素
+  ```
+
+#### Button::setFillMode(StellarX::FillMode mode) / setFillIma(StellarX::FillStyle pattern) / setFillIma(const std::string& imageName)
+
+- **用途：** 设置按钮背景的填充方式，可以是纯色填充、图案填充或图像填充。
+
+- **Purpose:** Configures the button’s background fill. It can be a solid color fill, a hatched pattern, or an image.
+
+- **参数：** `mode` 是填充模式枚举（`Solid`、`Null`、`Hatched` 等）；`pattern` 是图案样式枚举（`StellarX::FillStyle`，如水平线、交叉线等图案）；`imageName` 是图像文件路径，用于图像填充。
+
+- **Parameters:** `mode` is the fill mode (`StellarX::FillMode` – e.g. Solid, Null, Hatched); `pattern` is a hatch pattern style (`StellarX::FillStyle` – e.g. Horizontal, Cross, etc.); `imageName` is a file path to an image used for image fill.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 通过 `setFillMode` 可以选择按钮背景的填充方案：
+
+  - `Solid`：纯色填充，此时按钮背景采用当前设置的颜色（通常是默认颜色或通过其他接口设置的颜色）。
+  - `Null`：不填充背景（完全透明背景，仅文字和边框显示）。
+  - `Hatched`：使用系统预定义的图案填充，此时需要配合 `setFillIma(StellarX::FillStyle)` 来指定具体图案（如水平条纹等）。
+     如果选择 Hatched 模式，调用 `setFillIma(pattern)` 来设定图案样式。
+     若要使用自定义图像作为背景，调用 `setFillIma(imageName)` 并传入图像文件名；内部会加载图像，并将填充模式视为图像填充（通常不使用 Hatched 模式）。
+     设置填充后按钮将重绘，以应用新的背景效果。
+
+- **Details:** Use `setFillMode` to select the background fill scheme for the button:
+
+  - `Solid`: a solid color fill. The button’s background will use the current color (either a default or one set via other interfaces).
+  - `Null`: no fill (completely transparent background, only text and border are drawn).
+  - `Hatched`: a hatched pattern fill using system-defined patterns; in this case you should call `setFillIma(StellarX::FillStyle)` to specify the exact pattern (e.g. horizontal lines).
+     If Hatched mode is chosen, call `setFillIma(pattern)` with a `FillStyle` value to set the pattern style.
+     To use a custom image for the button background, call `setFillIma(imageName)` with the image file path. This will load the image internally and use it to tile/fill the background (the fill mode is effectively treated as an image fill, typically you do not set the mode to Hatched in this case).
+     After configuring the fill mode and associated pattern or image, the button will be marked dirty for redraw to apply the new background.
+
+- **示例:**
+
+  ```
+  // 纯色填充示例：
+  btn1.setFillMode(StellarX::FillMode::Solid);
+  btn1.setButtonFalseColor(RGB(200, 200, 200));  // 设置未按下时背景为浅灰
+  
+  // 图案填充示例：
+  btn1.setFillMode(StellarX::FillMode::Hatched);
+  btn1.setFillIma(StellarX::FillStyle::Cross);   // 设置十字交叉线填充图案
+  
+  // 图像填充示例：
+  btn1.setFillIma("button_background.jpg");      // 用指定图像填充按钮背景
+  ```
+
+#### Button::setButtonBorder(COLORREF color)
+
+- **用途：** 设置按钮边框颜色。
+- **Purpose:** Sets the button’s border color.
+- **参数：** `color`，COLORREF 格式的边框颜色值。
+- **Parameters:** `color` – border color in COLORREF format.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 改变按钮边框颜色。在按钮形状为带边框的类型下（如 RECTANGLE, ROUND_RECTANGLE 等），绘制时边框将使用指定颜色。若按钮当前形状为无边框类型，此颜色将存储但不会绘制边框线（除非以后切换回有边框形状）。更改颜色会使按钮重绘以应用新边框颜色。
+- **Details:** Changes the button’s border color. If the button’s shape is a bordered type (RECTANGLE, ROUND_RECTANGLE, etc.), the border will be drawn with this color. If the shape is currently a borderless type, the color is stored but no border line will be drawn (unless the shape is later changed to a bordered variant). Changing the border color marks the button for redraw so the new color will appear.
+
+#### Button::setButtonFalseColor(COLORREF color)
+
+- **用途：** 设置按钮的“False”颜色，即切换按钮在 OFF 状态或其他备用状态下使用的背景色。
+- **Purpose:** Sets the button’s “false” color, i.e., the background color used when a toggle button is in the OFF state (or as an alternate color for other purposes).
+- **参数：** `color`，COLORREF 格式的颜色值。
+- **Parameters:** `color` – a COLORREF color value.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 对于 TOGGLE 模式的按钮，此颜色用作按钮处于 OFF（未按下）状态时的背景颜色。对于普通按钮，此属性可被用作备用颜色（例如用于绘制按钮被按下时的颜色，具体取决于实现）。通过构造函数传入的第二个颜色参数通常对应这个 falseColor。更改 falseColor 后会自动重绘按钮以反映新颜色（如果当前状态正使用该颜色）。
+- **Details:** For a button in TOGGLE mode, this color is used as the background when the button is in the OFF (untoggled) state. For a normal button, this property might be repurposed as an alternate color (for example, it could be used as the pressed state color depending on implementation). The second color passed in certain constructors corresponds to this false color. Changing the false color will cause the button to redraw to reflect the new color (if the button is currently in the state that uses this color).
+
+#### Button::setButtonText(const char* text) / setButtonText(std::string text)
+
+- **用途：** 设置按钮的显示文本。提供 `const char*` 和 `std::string` 两种接口。
+- **Purpose:** Sets the display text of the button. Overloads are provided for `const char*` and `std::string`.
+- **参数：** `text`，要设置的新文本内容。可以是 C 字符串指针或 C++ 字符串对象。
+- **Parameters:** `text` – the new text content for the button (either as a C-string or a C++ string object).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 更改按钮的文字标签，并触发按钮重绘以显示新文本。按钮会根据新文本自动调整文字在控件中的居中对齐，但不会自动改变按钮控件的大小（按钮尺寸保持不变）。长文本可能会超出按钮边界（需手动调整按钮大小或字体大小）。
+- **Details:** Changes the button’s label text and marks the button dirty for redraw so the new text is displayed. The button will render the new text centered within its existing bounds, but it will **not** automatically resize the control to fit the text (the button’s size remains as set). If the new text is too long, it may overflow the button’s area (the developer may need to adjust the button’s size or font to accommodate it).
+
+#### Button::setButtonShape(StellarX::ControlShape shape)
+
+- **用途：** 修改按钮的几何形状类型。
+- **Purpose:** Changes the geometric shape type of the button.
+- **参数：** `shape`，`StellarX::ControlShape` 枚举值，指定按钮的新形状（包括是否有边框）。
+- **Parameters:** `shape` – a `StellarX::ControlShape` enum value specifying the new shape (including whether it has a border or not).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 调用此函数可动态改变按钮的外形，例如从矩形改为圆形，或从有边框版本改为无边框版本。更改形状会影响按钮的绘制逻辑（边框绘制与否、圆角参数是否生效等）。通常应在创建后但显示前设置所需形状。若在按钮已经显示后改变形状，也会重绘按钮以应用新形状。注意切换为无边框形状时，按钮的边框颜色和线宽设置将被忽略；切换回有边框时，这些设置又会生效。
+- **Details:** This function allows changing the button’s shape at runtime, for example from a rectangle to a circle, or from a bordered variant to a borderless one. Changing the shape affects how the button is drawn (whether a border is drawn, whether rounded corner parameters are used, etc.). It’s usually best to set the desired shape after construction but before displaying the button. Changing the shape on a visible button will trigger a redraw to apply the new appearance. Note that if you switch to a borderless shape, any border color or width settings are ignored; switching back to a bordered shape will re-enable those settings.
+
+#### Button::setButtonClick(BOOL click)
+
+- **用途：** 手动设置按钮的点击/选中状态。用于模拟按钮的按下或切换动作。
+
+- **Purpose:** Manually sets the button’s clicked/toggled state. Can be used to simulate a button press or toggle action programmatically.
+
+- **参数：** `click`，布尔值（使用 Windows API 类型 BOOL）。传入 TRUE 相当于按下按钮/切换到 ON 状态，传入 FALSE 相当于释放按钮/切换到 OFF 状态。
+
+- **Parameters:** `click` (BOOL) – pass TRUE to simulate a button press or toggle on, FALSE to simulate release or toggle off.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 在 NORMAL 模式下，调用 `setButtonClick(TRUE)` 将触发按钮的点击事件（调用已设置的 onClick 回调），并将按钮暂时渲染为按下状态，然后立即复原未按下状态（相当于完成一次点击）。在 TOGGLE 模式下，调用该函数会将按钮状态设置为对应的值：TRUE 表示强制切换到 ON 状态（并触发 onToggleOn 回调），FALSE 表示切换到 OFF 状态（并触发 onToggleOff 回调）。直接设置不会产生平滑过渡动画，只是立即改变状态并执行相关逻辑。调用 `setButtonClick` 主要用于在代码中模拟用户交互，例如在初始化时默认选中某个开关按钮等。
+
+- **Details:** In NORMAL mode, calling `setButtonClick(TRUE)` will programmatically trigger the button’s click action: it invokes the onClick callback as if the user clicked the button, momentarily rendering the button in a pressed state and then releasing it (simulating a full click cycle). In TOGGLE mode, this function forces the button’s state: TRUE forces it into the ON (toggled) state — invoking the onToggleOn callback if defined — and FALSE forces it into the OFF state — invoking onToggleOff. There is no animated transition; the state change is immediate and the associated callback is executed. This method is mainly useful for simulating user interaction in code, such as programmatically toggling a switch or setting a default state during initialization.
+
+- **示例:**
+
+  ```
+  // 在代码中模拟一次按钮点击:
+  btn1.setButtonClick(TRUE);  // 将触发 btn1 的 onClick 回调
+  
+  // 将 toggleBtn 设为选中状态:
+  if (!toggleBtn.isClicked()) {
+      toggleBtn.setButtonClick(TRUE);  // 切换到 ON 状态并调用 onToggleOn 回调
+  }
+  ```
+
+#### Button::isClicked() const
+
+- **用途：** 检查按钮当前是否处于按下状态或（对于切换按钮）选中状态。
+- **Purpose:** Checks whether the button is currently in a pressed (or, for toggle buttons, toggled on) state.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 布尔值。如果按钮是普通模式，返回值指示按钮是否正被按下（鼠标尚未释放）；如果是切换模式，返回值指示按钮当前是否处于 ON（选中）状态。禁用模式下通常返回 FALSE。
+- **Return:** Boolean. In normal mode, it indicates whether the button is currently being pressed (mouse is down on it and not yet released). In toggle mode, it indicates whether the button is currently in the ON (toggled) state. In disabled mode, it typically returns FALSE.
+- **行为细节：** 此函数可用于在程序中查询按钮的状态。例如对于 TOGGLE 模式的按钮，可以使用 `isClicked()` 来获取开关的开/关状态（返回 true 表示开）。对于 NORMAL 按钮，这个状态只在鼠标按下且尚未松开时为 true，一般用途不大，更常用的是依靠回调来处理点击。
+- **Details:** This function can be used to query the button’s state in code. For a toggle-mode button, `isClicked()` effectively tells you if the switch is ON (true means toggled on). For a normal button, the “clicked” state is only true during the brief moment when the mouse is down on the button and hasn’t been released yet; it’s not often used except for low-level state checks (it’s more common to rely on the click callback in normal mode).
+
+#### Button::getButtonText() const / getButtonText_c() const
+
+- **用途：** 获取按钮当前显示的文本。有 `std::string` 和 C 字符串两种版本。
+- **Purpose:** Retrieves the text currently displayed on the button. Provided as both a `std::string` and a C-string version.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getButtonText()` 返回一个 `std::string`，内容为按钮文本；`getButtonText_c()` 返回 `const char*` 指向按钮文本的C字符串（生命周期由按钮管理）。
+- **Return:** `getButtonText()` returns a `std::string` containing the button’s label text. `getButtonText_c()` returns a `const char*` pointing to the internal C-string of the button’s text (managed by the button).
+- **行为细节：** 通过这些方法可以读取按钮的标题文字。例如根据按钮文字内容决定下一步逻辑等。需要注意，如果使用 `getButtonText_c()` 返回的指针，千万不要尝试修改或长期保存它，因为它指向的是按钮内部的缓冲区，只可短期读取。通常推荐使用 `getButtonText()` 返回安全的字符串对象。
+- **Details:** These methods allow you to read the button’s label text, for example to make decisions based on the button’s caption. Note that if you use the `getButtonText_c()` method, do not attempt to modify the returned C-string or hold onto it beyond immediate use, as it points to the button’s internal buffer. It’s generally safer to use `getButtonText()` which returns a copy as a `std::string`.
+
+#### Button::getButtonMode() const
+
+- **用途：** 获取按钮当前的工作模式（NORMAL/TOGGLE/DISABLED）。
+- **Purpose:** Returns the button’s current operating mode (NORMAL, TOGGLE, or DISABLED).
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `StellarX::ButtonMode` 枚举值，表示按钮模式。
+- **Return:** A `StellarX::ButtonMode` enum value indicating the button’s mode.
+- **行为细节：** 通过此方法可以查询按钮是普通模式、切换模式还是禁用状态。例如，可以在程序运行时根据模式采取不同逻辑。
+- **Details:** Use this method to determine whether the button is in normal, toggle, or disabled mode. For example, you might check the mode at runtime to perform different logic depending on the mode.
+
+#### Button::getButtonShape() const
+
+- **用途：** 获取按钮当前的形状类型。
+- **Purpose:** Returns the button’s current shape type.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `StellarX::ControlShape` 枚举值，表示按钮形状（及是否有边框）。
+- **Return:** A `StellarX::ControlShape` enum value indicating the button’s shape (and border style).
+- **行为细节：** 可用于查询按钮当前是矩形、圆角矩形、圆形或椭圆形，以及是否有边框。这个信息对于动态调整布局或样式时可能有用。
+- **Details:** This can be used to check if the button is currently rectangular, rounded-rect, circular, or elliptical, and whether it’s using a bordered or borderless variant. This information might be useful when dynamically adjusting layouts or styles.
+
+#### Button::getFillMode() const / getFillIma() const / getFillImaImage() const
+
+- **用途：** 获取按钮背景填充模式及填充细节。
+- **Purpose:** Retrieves the button’s background fill mode and associated fill details.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getFillMode()` 返回 `StellarX::FillMode` 枚举值（Solid/Null/Hatched等）；`getFillIma()` 返回 `StellarX::FillStyle` 当前使用的图案样式；`getFillImaImage()` 返回指向当前使用的填充图像 (`IMAGE*`，EasyX 的图像类型)。如果没有使用图案或图像填充，相应返回值可能无意义（如 `getFillImaImage()` 在非图像模式下可能返回 `nullptr`）。
+- **Return:** `getFillMode()` returns the `StellarX::FillMode` (e.g. Solid, Null, Hatched). `getFillIma()` returns the current `StellarX::FillStyle` pattern being used (if in Hatched mode). `getFillImaImage()` returns an `IMAGE*` pointer to the image currently being used for fill (if in image fill mode). If a particular fill type is not in use (e.g. not in image mode), the corresponding value may be undefined or `nullptr`.
+- **行为细节：** 这些方法提供对按钮背景填充设置的查询能力。例如，可以检查按钮是否使用图像作为背景（通过看 `getFillMode` 是否为自定义模式并且 `getFillImaImage` 非空），或者获取当前使用的图案类型以便协调界面风格。这些函数主要用于需要根据控件状态执行反射（reflection）或调试时使用。
+- **Details:** These functions allow introspection of the button’s background fill configuration. For instance, you can check if the button is using an image as its background (by seeing if `getFillMode` indicates an image fill and `getFillImaImage` returns a valid pointer), or retrieve the current hatch pattern style in use to coordinate UI styling. These are primarily useful for reflecting the control’s state in code (for example, syncing another control’s style to match) or for debugging.
+
+#### Button::getButtonBorder() const / getButtonTextColor() const / getButtonTextStyle() const
+
+- **用途：** 获取按钮的边框颜色、文本颜色以及文本样式结构。
+- **Purpose:** Retrieves the button’s border color, text color, and the text style structure.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getButtonBorder()` 返回 COLORREF 值（当前边框颜色）；`getButtonTextColor()` 返回 COLORREF 值（按钮文字颜色）；`getButtonTextStyle()` 返回 `StellarX::ControlText` 结构，包含字体、字号、对齐、文字颜色等完整文本样式信息。
+- **Return:** `getButtonBorder()` returns a COLORREF representing the current border color. `getButtonTextColor()` returns a COLORREF for the button’s text color. `getButtonTextStyle()` returns a `StellarX::ControlText` structure containing the full text style information (font, size, alignment, color, etc.).
+- **行为细节：** 通过这些接口可以获取按钮当前使用的颜色样式，用于在运行时动态调整UI或查询当前设置。例如，可以取得按钮文字颜色以确保与背景形成对比，或者获取 `ControlText` 结构以复制文本样式到其他控件。值得注意的是，`ControlText` 是一个结构体，Button 将其作为公共成员暴露，因此不仅可以读取也可以直接修改其字段（如字体），修改后需要手动重绘按钮以应用变化。
+- **Details:** These interfaces allow retrieval of the button’s current color styling, which can be useful for dynamically adjusting the UI or querying the current configuration at runtime. For example, you could get the button’s text color to ensure it contrasts well with the background, or get the `ControlText` struct to copy the text style to another control. Note that `ControlText` is a structure and is exposed as a public member of Button, meaning you can also modify its fields (such as font) directly; if you do, you should trigger a redraw of the button to apply the changes.
+
+#### Button::getButtonWidth() const / getButtonHeight() const
+
+- **用途：** 获取按钮当前的宽度和高度。
+- **Purpose:** Returns the button’s current width and height.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 整数，按钮的宽度（`getButtonWidth()`）或高度（`getButtonHeight()`），以像素为单位。
+- **Return:** Integer value representing the button’s width (`getButtonWidth()`) or height (`getButtonHeight()`) in pixels.
+- **行为细节：** 这些方法等价于基类的 `getWidth()` 和 `getHeight()`，提供对按钮尺寸的查询。在某些实现中提供这两个方法可能是出于语义清晰或兼容性考虑。它们返回的值与 Control 基类的尺寸一致。
+- **Details:** These methods are equivalent to the base class’s `getWidth()` and `getHeight()`, providing the button’s dimensions. They likely exist for semantic clarity or compatibility in some contexts. The values returned are the same as the width and height maintained by the Control base class for this button.
+
+## TextBox 类 (文本框控件)
+
+**描述：** `TextBox` 是一个文本输入控件，支持两种模式：文本输入模式和只读显示模式。它封装了 EasyX 框架的文本输入框 (InputBox) 来获取用户输入，从而简化实现。TextBox 可以设置最大输入长度，支持有限的形状样式定制（矩形及其变体），并允许配置文本和背景的样式。常用于表单或需要用户输入的场景，也可用作不可编辑的文本显示框。
+
+**Description:** `TextBox` is a text input control supporting two modes: an input mode for user text entry and a read-only mode for display. It leverages EasyX’s InputBox to get user input, simplifying the implementation. The TextBox allows setting a maximum character length, supports limited shape style customization (rectangle variants), and provides options to configure text and background style. It’s commonly used in forms or situations where user input is required, and it can also serve as a non-editable text display box.
+
+**特性 (Features):**
+
+- 两种工作模式：输入模式和只读模式 *(Two operation modes: input (editable) mode and read-only mode.)*
+- 可设置输入文本的最大字符长度 *(Configurable maximum character length for input.)*
+- 集成系统输入框以简化文本输入逻辑 *(Integrated with system InputBox to simplify text input handling.)*
+- 支持四种矩形形状变体（有/无边框矩形、圆角矩形变体） *(Supports four rectangular shape variants (bordered/borderless rectangle, bordered/borderless rounded rectangle).)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### TextBox::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)
+
+- **用途：** 文本框构造函数，创建一个指定位置和尺寸的文本框，可以选择初始文本、模式和形状。
+
+- **Purpose:** Constructor for a TextBox. Creates a text box at the specified position and size, with optional initial text, mode, and shape.
+
+- **参数：** `x`, `y` 为文本框左上角坐标；`width`, `height` 为文本框宽度和高度；`text` 为初始显示文本（默认为空字符串）；`mode` 为文本框模式（`INPUT_MODE` 可输入，或 `READ_MODE` 只读）；`shape` 为控件形状（默认为有边框矩形）。
+
+- **Parameters:** `x`, `y` are the top-left coordinates of the text box; `width`, `height` specify the size; `text` is the initial text to display (default is empty); `mode` sets the TextBox mode (`INPUT_MODE` for editable, or `READ_MODE` for read-only); `shape` is the control shape (default is a bordered rectangle).
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 在构造 TextBox 时，如果模式为 `INPUT_MODE`，文本框将允许用户点击并弹出输入框以输入文字；如果模式为 `READ_MODE`，文本框将只显示提供的文本且不响应点击输入。初始文本将显示在控件内，但在 INPUT_MODE 下单击后会用 InputBox 获取新输入。构造完成后，可以使用 `setMaxCharLen()` 设置最大输入长度限制。
+
+- **Details:** When constructing the TextBox, if the mode is `INPUT_MODE`, the text box will allow user interaction: clicking it will pop up an input dialog (InputBox) for the user to enter text. If the mode is `READ_MODE`, the text box will simply display the provided text and will not respond to input clicks. The initial text (if any) is displayed inside the control, but in INPUT_MODE it can be replaced when the user inputs a new value via the InputBox. After construction, you may call `setMaxCharLen()` to impose a maximum character length for input.
+
+- **示例:**
+
+  ```
+  // 创建一个可输入的文本框，宽200高30，初始文本为空
+  TextBox inputBox(50, 100, 200, 30);
+  // 创建一个只读文本框，显示 "N/A"
+  TextBox displayBox(50, 140, 200, 30, "N/A", StellarX::TextBoxmode::READ_MODE);
+  ```
+
+#### TextBox::draw()  (重写自 Control)
+
+- **用途：** 绘制文本框背景和文字内容。
+- **Purpose:** Draws the text box’s background and its text content.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 在 `draw()` 中，TextBox 会根据其形状绘制一个矩形（或圆角矩形）背景，填充颜色和边框样式遵循控件设置（例如背景色、边框颜色、边框线型等）。如果文本框当前有文本内容，则将文本绘制在内边距区域内（通常靠左垂直居中显示）。对于只读模式，文本以通常颜色绘制；对于输入模式但当前未激活输入，文本也以通常颜色绘制。当文本框处于禁用状态（如果实现了禁用），可能使用灰色调绘制。
+- **Details:** In the `draw()` implementation, the TextBox will draw a rectangle or rounded rectangle background according to its shape and style settings (using the configured background color, border color, line style, etc.). If the text box currently has content, it will draw the text within its padded area (often left-aligned and vertically centered). In read-only mode, the text is rendered normally. In input mode (when not actively being edited), the text is also rendered normally. If the TextBox supports a disabled state, it might render the text in a greyed-out style when disabled.
+
+#### TextBox::handleEvent(const ExMessage& msg)  (重写自 Control)
+
+- **用途：** 处理与文本框交互的事件，例如鼠标点击来启动文本输入。
+- **Purpose:** Handles events related to the text box, for example detecting a mouse click to initiate text input.
+- **参数：** `msg`，事件消息（通常是鼠标事件）。
+- **Parameters:** `msg` – the event message (typically a mouse event).
+- **返回值：** 布尔值。如果在 INPUT 模式下点击了文本框，将启动输入并消费事件返回 `true`；否则返回 `false`。
+- **Return:** Boolean. If in INPUT mode and the text box was clicked, the event is consumed (return `true` after initiating input); otherwise returns `false`.
+- **行为细节：** 当 TextBox 处于可输入模式 (`INPUT_MODE`) 时，用户单击控件将触发 `handleEvent` 打开一个模态的输入对话框（EasyX 的 `InputBox`）。TextBox 会在打开对话框前设置好最大字符长度限制，调用系统输入框函数让用户输入文字。用户完成输入后，TextBox 接收输入结果，将其设置为自身的文本，并标记需要重绘，然后返回 `true` 表示事件已处理。
+   如果 TextBox 处于只读模式 (`READ_MODE`)，则不响应点击，`handleEvent` 对鼠标事件直接返回 `false`。
+   其他事件如键盘输入通常不直接由 TextBox 处理，因为输入通过对话框完成。
+- **Details:** When the TextBox is in editable mode (`INPUT_MODE`), a user click on the control causes the `handleEvent` to initiate a modal input dialog (using EasyX’s `InputBox`). Before opening the dialog, the TextBox will apply the max character length constraint if one is set. The system input box is then displayed for the user to enter text. Once the user confirms the input, the TextBox receives the result, updates its internal text content, marks itself dirty for redraw, and returns `true` to indicate the click event was handled.
+   If the TextBox is in read-only mode (`READ_MODE`), it ignores clicks; `handleEvent` will return `false` for mouse events (the text box does nothing on click).
+   Other events like direct keyboard input are usually not handled by TextBox itself since text entry is done via the InputBox dialog.
+
+#### TextBox::setMode(StellarX::TextBoxmode mode)
+
+- **用途：** 切换文本框的模式（可输入或只读）。
+- **Purpose:** Switches the text box’s mode between editable input and read-only display.
+- **参数：** `mode`，`StellarX::TextBoxmode` 枚举值，可为 `INPUT_MODE` 或 `READ_MODE`。
+- **Parameters:** `mode` – a `StellarX::TextBoxmode` value (`INPUT_MODE` or `READ_MODE`).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 通过此方法可以在运行时改变文本框模式。例如将一个输入框锁定为只读，或解锁只读框允许用户输入。切换到 `INPUT_MODE` 会使控件在点击时弹出输入框；切换到 `READ_MODE` 则控件点击不会有反应，只展示当前文本。模式切换会影响控件外观（可能改变文本颜色/样式以表示不可编辑）以及交互行为，但不会清空已存在的文本。
+- **Details:** This method allows changing the text box’s mode at runtime. For example, you can lock an input box to make it read-only, or enable a read-only box to accept user input. Switching to `INPUT_MODE` means the control will open an input dialog on click; switching to `READ_MODE` means clicks do nothing and the control simply displays text. The mode change might also affect the control’s appearance (for example, using a different text color or style to indicate non-editable state) and of course its interactivity, but it does not clear any existing text content.
+
+#### TextBox::setMaxCharLen(size_t len)
+
+- **用途：** 设置文本框可输入的最大字符数。
+- **Purpose:** Sets the maximum number of characters that can be entered into the text box.
+- **参数：** `len`，最大字符长度（size_t 类型）。
+- **Parameters:** `len` – the maximum character length allowed.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 调用此方法会限制用户通过输入框输入的文本长度不超过 `len` 个字符。如果用户试图输入更长的内容，多余的字符将不被接受。该限制通常在调用系统 InputBox 时传递，从而在对话框中直接限制输入。如果 `len` 值为 0 或非常大，则视为不限制长度（使用框架默认的限制或无限制）。
+- **Details:** Calling this method limits the text length that the user can input to `len` characters. If the user attempts to input more characters, extra characters will be disallowed or truncated. This constraint is typically passed to the system InputBox, so the input dialog enforces the limit during text entry. If `len` is 0 or a very large number, it is treated as no specific limit (using the framework’s default or effectively unlimited).
+
+#### TextBox::setTextBoxshape(StellarX::ControlShape shape)
+
+- **用途：** 设置文本框的形状类型。
+- **Purpose:** Sets the shape type of the text box.
+- **参数：** `shape`，`StellarX::ControlShape` 枚举值，指定文本框的新形状。通常支持矩形及圆角矩形的有/无边框版本。
+- **Parameters:** `shape` – a `StellarX::ControlShape` enum value specifying the new shape for the text box. Typically supports rectangular and rounded-rectangular shapes, with or without border.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 改变文本框形状会影响其边框和背景的绘制。TextBox 通常不支持圆形/椭圆形等非矩形形状，因此传入这些值可能不会有预期效果（将可能被当作矩形处理）。推荐使用矩形（RECTANGLE/B_RECTANGLE）或圆角矩形（ROUND_RECTANGLE/B_ROUND_RECTANGLE）形状。调用此方法会重绘控件以应用新形状。
+- **Details:** Changing the text box’s shape affects how its border and background are drawn. The TextBox typically does not support non-rectangular shapes like perfect circles or ellipses for input, so providing those values might not yield the expected result (they may be treated as rectangular shapes internally). It’s recommended to use rectangle (RECTANGLE/B_RECTANGLE) or rounded rectangle (ROUND_RECTANGLE/B_ROUND_RECTANGLE) shapes for text boxes. Calling this method triggers a redraw to apply the new shape.
+
+#### TextBox::setTextBoxBorder(COLORREF color) / setTextBoxBk(COLORREF color)
+
+- **用途：** 设置文本框的边框颜色和背景颜色。
+- **Purpose:** Sets the text box’s border color and background color.
+- **参数：** `color`，COLORREF 格式的颜色值。`setTextBoxBorder` 用于边框线颜色，`setTextBoxBk` 用于背景填充颜色。
+- **Parameters:** `color` – a COLORREF color value. Use `setTextBoxBorder` for the border line color, and `setTextBoxBk` for the background fill color.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 调整文本框的外观颜色设置。边框颜色将在控件形状为带边框类型时生效，背景颜色在填充模式为纯色时使用。一般 TextBox 默认是纯色填充背景，调用 `setTextBoxBk` 将改变其背景色。如果需要透明背景，可考虑将填充模式设为 Null 或者使用 Canvas 背景色相同的颜色并配合透明模式（TextBox 没有直接透明选项，但可以通过容器背景来达成）。修改颜色后控件会重绘。
+- **Details:** These methods tweak the TextBox’s appearance colors. The border color takes effect if the control’s shape includes a border; the background color is used when the fill mode is solid color (which is typically the default for a TextBox). Usually the TextBox draws a solid background, so calling `setTextBoxBk` will change that background color. If a transparent background effect is desired, you might set the fill mode to Null or match the container’s background color (TextBox doesn’t have a direct transparent option, but can achieve a similar effect by blending with the parent’s background). After changing these colors, the control will redraw to apply the new look.
+
+#### TextBox::setText(std::string text) / TextBox::getText() const
+
+- **用途：** 设置或获取文本框的内容文本。
+
+- **Purpose:** Sets or gets the content text of the text box.
+
+- **参数（setText）：** `text`，要放入文本框的新字符串。
+
+- **Parameters (setText):** `text` – the new string to put into the text box.
+
+- **返回值（getText）：** 返回当前文本框中的字符串内容（std::string）。
+
+- **Return (getText):** Returns the current string content of the text box (as an std::string).
+
+- **行为细节：** `setText` 将直接更新文本框显示的文字，无论当前模式是输入还是只读，这都会立即生效并触发重绘。如果是在 INPUT_MODE 下且此时没有打开输入框，那么新的文字会显示出来，用户下一次点击编辑会在此文本基础上继续。`getText` 则提供读取当前文本内容的方法，通常在用户输入完成后调用以获取结果。在只读模式下，`getText` 可用于获取显示的信息。
+
+- **Details:** `setText` immediately updates the text displayed in the text box. This works in both input and read-only modes, and it triggers a redraw of the control to show the new text. If in INPUT_MODE (and not currently in the middle of an input dialog), the new text will appear in the box and will be the starting content if the user clicks to edit (they can modify or overwrite it). `getText` allows you to retrieve the current content of the text box, typically used after the user has entered text to get the result. In read-only mode, `getText` can be used to fetch the information being displayed.
+
+- **示例:**
+
+  ```
+  inputBox.setText("Default Name");         // 设置默认文本
+  // ... 用户可能通过对话框修改了文本 ...
+  std::string name = inputBox.getText();    // 获取用户最终输入的文本
+  ```
+
+## Table 类 (高级表格控件)
+
+**描述：** `Table` 是一个用于显示数据表格的控件，支持分页显示大量数据。它提供表头、数据行的呈现，以及分页控制按钮，方便浏览多于一页的数据。Table 能根据内容自动计算列宽和行高，并允许自定义表格的边框和网格样式。适用于需要以表格形式展示数据、报表的场景。
+
+**Description:** `Table` is an advanced control for displaying tabular data, supporting pagination for large data sets. It provides a header row and data rows, along with pagination controls (previous/next page buttons) for browsing data spanning multiple pages. The Table can automatically calculate column widths and row heights based on content, and allows customization of its border and grid style. It’s suitable for scenarios where data or reports need to be presented in a table format.
+
+**特性 (Features):**
+
+- 自动分页和页码计算 *(Automatic pagination and page number calculation.)*
+- 可配置的每页行数 *(Configurable number of rows per page.)*
+- 自定义边框样式和填充模式 *(Customizable border style and fill mode.)*
+- 翻页按钮和页码显示 *(Built-in pagination buttons and page number display.)*
+- 背景缓存优化渲染性能 *(Background buffering to optimize rendering performance.)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### Table::Table(int x, int y)
+
+- **用途：** 表格控件构造函数，在指定位置创建一个空表格控件。初始情况下没有设置列和数据，需要后续调用设置表头和数据。
+
+- **Purpose:** Constructor for the Table control. Creates an empty table at the specified position. Initially, it has no columns or data; those should be set up afterward.
+
+- **参数：** `x`, `y` 为表格左上角坐标。表格初始宽度和高度默认可为 0，后续由内容或显式设置决定。
+
+- **Parameters:** `x`, `y` are the top-left coordinates of the table. The table’s initial width and height default to 0, and will be determined later by content or explicit sizing.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 刚创建的 Table 通常需要设置表头（列标题）和数据后才能正常显示内容。初始尺寸可以通过 `setWidth` 来调整宽度，或者通过添加数据后自动计算确定。表格默认具有网格线、分页控件，但没有列时不会绘制任何有效区域。将 Table 添加到 Window 或 Canvas 后，需调用 `setHeaders` 定义列标题，再调用 `setData` 添加数据行。
+
+- **Details:** A newly created Table typically needs to have its headers (columns) and data set up before it can display meaningful content. Its initial size can be adjusted by calling `setWidth` to define a total width, or it may be determined after adding data (which triggers auto-calculation of dimensions). The table by default supports grid lines and paging controls, but with no columns defined, it won’t render any meaningful area. After adding the Table to a Window or Canvas, you should call `setHeaders` to define the columns, then use `setData` to add data rows.
+
+- **示例:**
+
+  ```
+  Table table(20, 100);
+  table.setHeaders({"Name", "Age", "City"});    // 定义3列表头
+  table.setWidth(300);                          // 设置表格总宽度
+  ```
+
+#### Table::draw()  (重写自 Control)
+
+- **用途：** 绘制表格的框架、页眉和当前页数据行。
+- **Purpose:** Draws the table’s structure, including the header row and the data rows for the current page.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** `draw()` 方法会先绘制表格的背景和边框，然后绘制表头行（通常使用不同的背景色或加粗字体来突出）。接下来根据当前页码，绘制该页包含的数据行，每行各列数据按照计算得到的列宽填充显示，可能带有网格线分隔行列。若启用了分页控件，则在表格底部或顶部绘制翻页按钮（上一页、下一页）和页码指示。绘制过程中，Table 会参考 `rowsPerPage` 决定一页显示多少行，参考已计算的 `colWidths` 来对齐文本。整个表格的绘制通常使用双缓冲，以减少闪烁。
+- **Details:** The `draw()` method will first render the table’s background and outer border. Then it draws the header row, often with a distinct background color or bold text to differentiate it from data rows. After that, based on the current page number, it draws the data rows for that page. Each row’s columns are laid out according to the computed column widths, and grid lines may be drawn to separate rows and columns. If paging controls are enabled, the draw function will also render navigation buttons (e.g. “Previous” and “Next” arrows or buttons) and a page number indicator at the bottom (or top) of the table. During rendering, the Table uses the `rowsPerPage` setting to know how many rows to display, and it uses precomputed `colWidths` to align and truncate text as needed. The entire table is typically drawn using double-buffering to minimize flicker.
+
+#### Table::handleEvent(const ExMessage& msg)  (重写自 Control)
+
+- **用途：** 处理用户与表格的交互事件，如点击分页按钮。
+- **Purpose:** Handles user interaction events with the table, such as clicking the pagination buttons.
+- **参数：** `msg`，事件消息（可能是鼠标点击等）。
+- **Parameters:** `msg` – event message (likely a mouse click or similar).
+- **返回值：** 布尔值。如果事件对应了表格的某个交互（如翻页按钮点击），则处理后返回 `true`；否则返回 `false`。
+- **Return:** Boolean. Returns `true` if the event corresponds to an interaction in the table (e.g., clicking a page navigation button) and has been handled; returns `false` otherwise.
+- **行为细节：** Table 的 `handleEvent` 主要监测鼠标点击：
+  - 如果点击发生在“上一页”按钮且当前不在第一页，则将当前页减一并触发重绘，返回 `true`。
+  - 如果点击发生在“下一页”按钮且当前不在最后一页，则将当前页加一并触发重绘，返回 `true`。
+  - （如果表格有其他可交互元素，如可点击的单元格，亦可在此处理。）
+     非分页区域的点击或者无效的操作将不会被 Table 消费，返回 `false`，让其他控件处理。
+     通过此方法，实现用户点击翻页按钮后表格内容相应更新。
+- **Details:** The Table’s `handleEvent` mainly listens for mouse clicks relevant to the table:
+  - If a click is detected on the “Previous Page” control and the table is not already on the first page, the current page index is decremented, a redraw is triggered to show the new page of data, and the method returns `true`.
+  - If a click is detected on the “Next Page” control and the table is not on the last page, the current page index is incremented, a redraw is triggered, and the method returns `true`.
+  - (If the table had other interactive elements, such as clickable cells, those would be handled here as well in a similar fashion.)
+     Clicks that occur outside the pagination controls or clicks that don’t result in a valid action will not be consumed by the Table; in those cases, `handleEvent` returns `false` so that other controls can handle the event if appropriate.
+     Using this mechanism, when the user clicks the navigation buttons, the table updates its displayed content accordingly.
+
+#### Table::setHeaders(std::initializer_liststd::string headers)
+
+- **用途：** 设置表格的列标题。
+
+- **Purpose:** Sets the table’s column headers.
+
+- **参数：** `headers`，字符串列表，用于指定每一列的标题文本。列表中字符串的数量决定表格的列数。
+
+- **Parameters:** `headers` – an initializer_list of strings specifying the header text for each column. The number of strings in the list determines the number of columns in the table.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** 该方法定义表格的列结构。传入几个标题就创建了几列，Table 内部将初始化列宽数组 `colWidths`，初始值可根据标题长度或默认值设置。在调用此函数后，可以调用 `setWidth(int)` 来设定表格总宽度（如果不调用则可能使用默认宽度或根据第一个数据行自动调整）。设置表头会导致表格重绘。表头字符串将按顺序绘制在表格顶部，通常居中对齐于各列单元。
+
+- **Details:** This method defines the column structure of the table. Each string in the input list becomes the header text of a column, so if you provide N strings, the table will have N columns. The Table will initialize its internal `colWidths` array; initial widths might be based on header text lengths or some default. After calling this, you may call `setWidth(int)` to set the total width of the table (otherwise the table might use a default width or adjust based on the first row of data). Setting the headers will cause the table to redraw. The header texts are rendered in order at the top of the table, typically centered within each column cell.
+
+- **示例:**
+
+  ```
+  table.setHeaders({"ID", "Name", "Score"});
+  // 上例将表格设置为3列，列标题分别为 "ID", "Name", "Score"
+  ```
+
+#### Table::setData(std::vectorstd::string data) / setData(std::initializer_list<std::vectorstd::string> data)
+
+- **用途：** 增加表格的数据行。提供两个重载：一个用于添加单行数据，一个用于添加多行数据。
+
+- **Purpose:** Adds data rows to the table. Two overloads are provided: one for adding a single row (as a vector of strings) and one for adding multiple rows (as an initializer_list of string vectors).
+
+- **参数：** 单行版本：`data`，一个包含该行每列数据的 `std::vector<std::string>`；多行版本：`data`，一个 initializer_list，其中每个元素是一个 `std::vector<std::string>` 表示一行的数据。
+
+- **Parameters:** Single-row version: `data` – a `std::vector<std::string>` containing the data for each column in one row. Multi-row version: `data` – an initializer_list where each element is a `std::vector<std::string>` representing one row of data.
+
+- **返回值：** 无。
+
+- **Return:** None.
+
+- **行为细节：** `setData` 的单行版本会将传入的这一行数据追加到表格的数据集末尾。如果该行提供的列数少于表头列数，不足部分会自动填充为空字符串以对齐列数。追加数据后，内部会重新计算总页数 (`totalPages`)。
+   多行版本会将多行依次追加到表格中，类似地处理每行长度不足的情况。
+   第一次添加数据后，Table 会计算每列的最佳宽度（如根据数据内容长度均分或按最大内容长度），除非已经通过 `setWidth` 固定了总宽度。在后续添加数据时，Table 可能维持已有列宽或根据需要调整。
+   调用 `setData` 不会自动刷新当前显示页，需要在所有数据添加完毕后手动调用重绘或调用相关方法显示第一页。
+
+- **Details:** The single-row version of `setData` appends the given row to the table’s data set. If the number of elements in the vector is less than the number of table columns, the method will pad the row with empty strings so that it has values for all columns. After adding the row, the table’s total page count (`totalPages`) is recalculated.
+   The multi-row version appends each provided row in turn, similarly padding any row that is shorter than the number of headers.
+   After the first batch of data is added, the Table may compute optimal column widths – for example, distributing total width evenly or sizing columns to fit the longest content – unless a total table width has been set via `setWidth`, which fixes the overall width (column widths then may be adjusted proportionally or evenly). When adding subsequent data, the Table will usually maintain the existing column widths, adjusting only if needed (this depends on implementation).
+   Calling `setData` by itself does not automatically refresh the visible page; after adding data, you may need to explicitly trigger a redraw or call related methods (such as showing the first page) to update the display. Typically, adding data and then, for example, calling `table.showPageButton(true)` or ensuring the table is marked dirty will cause the new data to be rendered.
+
+- **示例:**
+
+  ```
+  // 添加一行数据
+  table.setData({"001", "Alice", "95"});
+  
+  // 添加多行数据
+  table.setData({
+      {"002", "Bob", "87"},
+      {"003", "Cathy", "78"}
+  });
+  ```
+
+#### Table::setRowsPerPage(int rows)
+
+- **用途：** 设置表格每页显示的数据行数。
+- **Purpose:** Sets how many data rows are displayed per page of the table.
+- **参数：** `rows`，每页显示的行数（不包括表头）。
+- **Parameters:** `rows` – the number of data rows to show per page (excluding the header row).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 修改该值会影响分页逻辑。例如，如果总数据行很多而 `rows` 值较小，则 `totalPages` 会增大，每页只显示指定数量的行。若修改时当前页码超出新的总页数，则会相应调整当前页码到最后一页。通常在设置完数据后调用，以控制分页大小。更改后应重绘表格以更新显示。
+- **Details:** Changing this value affects the table’s pagination. For example, if there are many data rows and you set a smaller `rows` value, the number of total pages (`totalPages`) will increase, with only the specified number of rows shown on each page. If the current page index is beyond the new total pages after changing this, it will be adjusted to the last page. This is typically set after loading data, to control how many rows the user sees at a time. After changing the rows-per-page setting, the table should be redrawn to reflect the new pagination.
+
+#### Table::showPageButton(bool isShow)
+
+- **用途：** 设置是否显示表格的分页控制按钮。
+- **Purpose:** Determines whether the table’s page navigation buttons are displayed.
+- **参数：** `isShow`，布尔值。`true` 表示显示分页按钮，`false` 表示隐藏分页按钮。
+- **Parameters:** `isShow` (bool). `true` to show the pagination buttons, `false` to hide them.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 当数据可以分页时，默认情况下 Table 会显示上一页/下一页按钮以及页码。但在某些情况下（例如只有一页数据或不希望用户翻页），可以通过此函数隐藏这些控件。设置为 false 后，Table 在绘制时将不再保留底部区域给分页控件，整个高度可能会稍微调整。设置为 true 则恢复显示分页栏。改变此设置需要重绘表格才能生效。
+- **Details:** By default, if the data spans multiple pages, the Table will display “Previous”/“Next” page buttons and a page indicator. However, in some scenarios (e.g., when data fits on one page or the developer wants to handle pagination differently), you might want to hide these controls. When this is set to false, the Table will not draw the paging controls and may use the space otherwise reserved for them as part of the data display area. Setting it to true restores the pagination bar. Changing this setting requires a redraw of the table to take effect.
+
+#### Table::setTableBorder(COLORREF color) / setTableBk(COLORREF color)
+
+- **用途：** 设置表格外边框颜色和表格背景底色。
+- **Purpose:** Sets the table’s outer border color and the table’s background color.
+- **参数：** `color`，COLORREF 格式的颜色值。`setTableBorder` 用于表格边框线颜色；`setTableBk` 用于表格背景的填充颜色。
+- **Parameters:** `color` – a COLORREF color value. Use `setTableBorder` for the table’s outer border line color; use `setTableBk` for the table’s background fill color.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** `setTableBorder` 改变整个表格外围边框的颜色，该边框环绕表头和所有数据。`setTableBk` 则改变表格的背景色，这个背景位于单元格网格线之下。通常表格单元格背景可能使用交替底色或者透明，`setTableBk` 提供一个基础底色用于整个表格区域。更改任一颜色会使表格标记为需要重绘。
+- **Details:** `setTableBorder` changes the color of the table’s outer border that encloses the header and all data rows. `setTableBk` changes the background color of the table area, which lies beneath the cells and grid lines. Often, table cells might use alternating row colors or appear transparent, but `setTableBk` provides a base color for the entire table region behind the cells. Changing either of these colors will mark the table as dirty for redraw.
+
+#### Table::setTableFillMode(StellarX::FillMode mode) / setTableLineStyle(StellarX::LineStyle style)
+
+- **用途：** 设置表格背景填充模式和网格线线型。
+- **Purpose:** Sets the table’s background fill mode and the style of its grid lines.
+- **参数：** `mode` 为填充模式枚举（影响表格背景区域的填充方式，如纯色或图案）；`style` 为线型枚举（影响表格内部网格线和边框线的样式，如实线、虚线）。
+- **Parameters:** `mode` – a `StellarX::FillMode` value controlling how the table’s background area is filled (e.g. solid color or pattern); `style` – a `StellarX::LineStyle` value controlling the style of the table’s grid and border lines (e.g. solid, dashed).
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 通过 `setTableFillMode`，可以选择表格背景采用纯色填充、图案填充等（类似 Canvas 的填充模式）；通常表格背景采用纯色或不填充，因为单元格区域会另行绘制。`setTableLineStyle` 则可令表格的边框和内部的分隔线（如列间竖线，行间横线）变为指定线型，比如虚线网格等。这两个设置可以改变表格整体视觉风格。修改后需要重绘才能体现效果。
+- **Details:** Using `setTableFillMode`, you can select how the table’s background is filled (similar to Canvas fill mode) – typically a solid color or no fill, since the cell areas will be drawn on top. `setTableLineStyle` allows the table’s outer border and interior grid lines (like vertical column dividers and horizontal row dividers) to be drawn with the specified style, such as dashed lines for the grid. These two settings let you change the overall visual style of the table. A redraw is required for changes to take effect.
+
+#### Table::setTableBorderWidth(int width)
+
+- **用途：** 设置表格外边框线和网格线的宽度。
+- **Purpose:** Sets the thickness of the table’s outer border and grid lines.
+- **参数：** `width`，以像素为单位的线宽。
+- **Parameters:** `width` – the line width in pixels for the table’s border and grid.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 改变此值会影响表格绘制时边框和内部网格线的粗细程度。默认情况下表格线为1像素。如果设置更大的值，线条会更粗，表格看起来更醒目，但也可能影响单元格内容的可读性（因为线条占据更多空间）。设置非常小的值（如0或1）会使线条细或几乎不可见。更改线宽后应重绘表格。
+- **Details:** Changing this value affects the thickness of the table’s outer border and interior grid lines when drawn. By default, table lines are 1 pixel thick. If you set a larger value, the lines will be thicker, making the table grid more prominent (though very thick lines might reduce the area for content and affect readability). Setting it to a very small value (like 0 or 1) will make lines thin or nearly invisible. After adjusting the line width, the table needs to be redrawn to apply the new thickness.
+
+#### Table::onWindowResize()  (重写自 Control)
+
+- **用途：** 当父窗口大小改变时调整表格布局。
+- **Purpose:** Adjusts the table’s layout when the parent window is resized.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** 无。
+- **Return:** None.
+- **行为细节：** 当窗口尺寸变化时，Table 的 `onWindowResize` 会检查自身是否使用锚点布局。如果表格被锚定左右，则会随着窗口拉伸调整宽度，并相应重新计算各列宽度（例如按比例分配新增加的宽度）。如果表格锚定上下边，则高度变动时可能调整可显示的行数或者仅仅调整布局但由于分页机制高度变化不会增减行。通常，表格在窗口大小变化时维持已有的列结构，只调整整体大小及可能的分页控件位置。
+- **Details:** When the window size changes, the Table’s `onWindowResize` will check if it is using anchor layout. If the table is anchored to left and right edges, its width will change with the window and it may recalculate the column widths (for example, distributing any additional width proportionally across columns). If the table is anchored to top and bottom edges, as the height changes it might adjust how many rows can be shown or simply stretch the layout (the number of displayed rows may remain the same due to the paging mechanism, but spacing could change). In general, when the window resizes, the table maintains its existing column structure, adjusting only the overall size and repositioning the paging controls as needed.
+
+#### Table::getCurrentPage() const / getTotalPages() const
+
+- **用途：** 获取表格当前显示的页码，以及总页数。
+- **Purpose:** Retrieves the table’s currently displayed page index and the total number of pages.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getCurrentPage()` 返回当前页序号（从0或1开始的索引，具体实现而定，一般用于内部计算）；`getTotalPages()` 返回总页数（正整数）。
+- **Return:** `getCurrentPage()` returns the index of the current page (indexing may start from 0 or 1 depending on implementation, typically used internally); `getTotalPages()` returns the total number of pages (a positive integer).
+- **行为细节：** 这些方法可用于了解表格的分页状态。例如，在界面其他位置显示 “Page X of Y” 时，需要从 Table 获取当前页和总页数。通常框架将当前页码作为0基索引存储，而在UI显示时可能+1（因为人类习惯1基页码）。`getTotalPages()` 计算基于数据行数和 `rowsPerPage` 设置。
+- **Details:** These methods provide insight into the table’s pagination state. For instance, if you want to display “Page X of Y” elsewhere in the UI, you would retrieve the current page and total pages from the Table. Typically, the framework might store current page as a 0-based index internally, while for display you’d convert it to 1-based (since users usually count pages starting from 1). `getTotalPages()` is calculated based on the number of data rows and the `rowsPerPage` setting.
+
+#### Table::getRowsPerPage() const / getShowPageButton() const
+
+- **用途：** 获取表格每页行数设置，以及分页按钮的显示状态。
+- **Purpose:** Retrieves the table’s current rows-per-page setting and whether the pagination buttons are set to be shown.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getRowsPerPage()` 返回每页显示的数据行数量（int）；`getShowPageButton()` 返回一个 bool，指示是否显示分页按钮。
+- **Return:** `getRowsPerPage()` returns the number of data rows shown per page (int). `getShowPageButton()` returns a bool indicating whether the pagination buttons are currently set to be visible.
+- **行为细节：** 可用于查询 Table 的当前分页配置，例如用于调试或在界面上显示分页设置。通常这些属性在初始化后不频繁变更，但提供接口以防需要在运行时检查。
+- **Details:** These allow you to query the Table’s current pagination configuration, which can be useful for debugging or to display the pagination settings in the UI if needed. Generally, these properties are set up during initialization and not changed often, but the getters are provided in case you need to check them at runtime.
+
+#### Table::getTableBorder() const / getTableBk() const
+
+- **用途：** 获取表格边框颜色和背景颜色。
+- **Purpose:** Retrieves the table’s border color and background color.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getTableBorder()` 返回 COLORREF 值（表格外边框颜色）；`getTableBk()` 返回 COLORREF 值（表格背景底色）。
+- **Return:** `getTableBorder()` returns a COLORREF representing the table’s outer border color. `getTableBk()` returns a COLORREF for the table’s background base color.
+- **行为细节：** 这些方法用于查询 Table 当前使用的颜色配置，可在需要动态调整或同步样式时使用。例如，将多个表格的边框颜色统一，可以先从一个表格读取其颜色然后设置给其他表格。
+- **Details:** These getters allow you to check what colors the Table is currently using, which can be handy if you need to dynamically adjust or synchronize styles between components. For example, to unify the border colors of multiple tables, you could read the color from one table and apply it to others.
+
+#### Table::getTableFillMode() const / getTableLineStyle() const
+
+- **用途：** 获取表格背景填充模式和网格线样式。
+- **Purpose:** Retrieves the table’s background fill mode and grid line style.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getTableFillMode()` 返回 `StellarX::FillMode` 枚举值；`getTableLineStyle()` 返回 `StellarX::LineStyle` 枚举值。
+- **Return:** `getTableFillMode()` returns the `StellarX::FillMode` currently set for the table’s background. `getTableLineStyle()` returns the `StellarX::LineStyle` for the table’s grid and border lines.
+- **行为细节：** 用于查询 Table 的视觉样式配置，通常结合其他接口使用。比如获取 line style 以判断当前网格是实线还是虚线，在定制绘制时可能用到。
+- **Details:** These are used to query the Table’s visual style settings, often for use in combination with other interfaces. For instance, you might get the line style to determine if the grid is solid or dashed, which could be useful if performing custom drawing or ensuring consistency across different tables.
+
+#### Table::getHeaders() const / getData() const
+
+- **用途：** 获取表格的表头列表和所有数据内容。
+- **Purpose:** Retrieves the table’s header list and all the data currently stored in the table.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getHeaders()` 返回一个 `std::vector<std::string>`，包含各列的标题文字；`getData()` 返回一个 `std::vector<std::vector<std::string>>`，每个内部 vector 代表一行的数据。
+- **Return:** `getHeaders()` returns a `std::vector<std::string>` containing the title text of each column. `getData()` returns a `std::vector<std::vector<std::string>>` where each inner vector represents one row of data.
+- **行为细节：** 通过这些函数可以获取 Table 当前的内容，方便进行序列化（比如保存到文件）或调试。需要注意的是，`getData()` 返回的是整个数据集合，可能非常大，应谨慎使用，比如避免在每帧调用。使用者对返回的数据进行修改不会直接影响 Table 内部状态（因为返回的是拷贝或只读视图，具体实现依赖 Table 内部），如果想修改表格内容应使用提供的设置函数。
+- **Details:** These functions allow retrieval of the Table’s current content, which can be useful for serialization (e.g., saving to a file) or debugging. Note that `getData()` returns the entire data set in the table, which could be very large if the table holds a lot of data, so it should be used judiciously (for example, avoid calling it every frame in a loop). Modifying the returned data will not automatically affect the Table’s internal state (as the return is likely a copy or a read-only view depending on implementation). To modify the table’s content, you should use the provided setter functions.
+
+#### Table::getTableBorderWidth() const / getTableWidth() const / getTableHeight() const
+
+- **用途：** 获取表格边框线宽、表格内容总宽度和总高度。
+- **Purpose:** Retrieves the table’s border line width, the total content width, and the total content height of the table.
+- **参数：** 无。
+- **Parameters:** None.
+- **返回值：** `getTableBorderWidth()` 返回 int，表格边框（及网格线）当前的像素宽度；`getTableWidth()` 返回 int，表格所有列总和的宽度；`getTableHeight()` 返回 int，表格所有行总和的高度。
+- **Return:** `getTableBorderWidth()` returns an int representing the current pixel width of the table’s border (and grid lines). `getTableWidth()` returns an int representing the total width of all columns combined. `getTableHeight()` returns an int for the total height of all rows combined.
+- **行为细节：** `getTableBorderWidth()` 通常返回先前通过 `setTableBorderWidth` 设置的值。如果未设置则可能是默认值1。
+   `getTableWidth()` 计算表头各列宽度之和（不包括边框线外沿），反映表格内容区域的总宽。它可用于了解表格当前占据的宽度，比如在布局中做参考。
+   `getTableHeight()` 计算所有数据行的总高度，这个高度可能超过当前控件显示高度（因为可能有分页，只显示其中一部分）。此函数更多用于内部计算或者当需要知道全部数据纵向空间时使用。
+- **Details:** `getTableBorderWidth()` usually returns the value previously set by `setTableBorderWidth` (or a default like 1 if never set).
+   `getTableWidth()` sums up the widths of all columns (excluding the outer border’s extra thickness), reflecting the total width of the table’s content area. This can be useful to know how wide the table currently is, for example for use in layout decisions.
+   `getTableHeight()` calculates the total height of all data rows combined. This height may exceed the control’s visible height if the table has multiple pages and thus not all data is visible at once. This function is mainly for internal use or in cases where you need to know the total vertical space the data would occupy (for instance, for printing or exporting the entire table). Note that if not fully implemented, it might return 0 or a placeholder if the feature is incomplete.
+
+
+
+## TabControl 类 (选项卡容器控件)
+
+*TabControl Class (Tab Container Control)*
+
+**描述：**
+ `TabControl` 是一个容器类控件，继承自 `Canvas`，用于管理“页签按钮 + 对应页面(Canvas)”的组合。它支持在上/下/左/右四个方向布置页签栏，并与 `Button` 的 TOGGLE 模式联动，实现点击页签按钮切换不同页面内容。控件会在窗口尺寸变化时自动重新计算页签按钮位置和页面区域，从而在同一块区域内承载多张页面并通过页签进行快速切换。TabControl
+
+**Description:**
+ `TabControl` is a container control derived from `Canvas` that manages pairs of “tab button + page (Canvas)”. It supports placing the tab bar on the top, bottom, left, or right, and works together with `Button` in TOGGLE mode so that clicking a tab button shows its corresponding page and hides others. The control automatically recalculates tab/button positions and page areas when the window is resized, letting you host multiple pages in the same area and quickly switch between them using tabs. TabControl
+
+**特性 (Features):**
+
+- 继承自 `Canvas`，具备画布背景、边框、形状等所有基础功能 *(Inherits from `Canvas`, with background, border, and shape features.)*TabControl
+- 管理一个由 `(Button, Canvas)` 组成的列表，每个按钮对应一张页面 *(Manages a list of `(Button, Canvas)` pairs, one page per tab.)*TabControl
+- 支持四种页签位置：`Top` / `Bottom` / `Left` / `Right` *(Supports four tab bar placements: Top / Bottom / Left / Right.)*TabControl
+- 支持通过文本查找页签索引、获取/设置当前激活页签 *(Supports finding tabs by text, getting/setting the active tab index.)*TabControl
+- 响应窗口尺寸变化，自动调整页签按钮与页面区域大小和位置 *(Responds to window resize, updating tab buttons and page areas.)*
+- 统一的脏区标记与重绘请求机制，支持容器级“统一重绘” *(Unified dirty flag and repaint request mechanism for container-level redraw.)*TabControl
+
+### 公共成员函数 (Public Member Functions)
+
+#### TabControl::TabControl() / TabControl::TabControl(int x, int y, int width, int height)
+
+- **用途：**
+   创建一个 TabControl 实例。无参构造创建一个默认尺寸为 0 的控件；带参构造在给定全局坐标 `(x, y)` 和尺寸 `(width, height)` 处创建选项卡容器，并设置控件 id 为 `"TabControl"`。
+- **Purpose:**
+   Constructs a `TabControl` instance. The default constructor creates a control with zero size; the parameterized constructor creates a tab container at the given global position `(x, y)` and size `(width, height)`, and sets the control id to `"TabControl"`.
+- **参数 / Parameters：**
+  - `x`, `y`：控件左上角的全局坐标 *(global top-left coordinates).*
+  - `width`, `height`：控件宽度与高度 *(control width and height).*
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+   构造函数只负责初始化基本尺寸与默认配置：
+  - 默认页签栏高度为 `BUTMINWIDTH`。
+  - 默认页签摆放位置为 `StellarX::TabPlacement::Top`。
+  - 内部 `controls` 列表初始为空，后续通过 `add()` 系列函数添加。TabControl
+
+#### TabControl::~TabControl()
+
+- **用途 / Purpose：**
+   析构函数释放 TabControl 自身资源。内部 `controls` 使用 `std::unique_ptr` 管理按钮和页面，析构时会自动释放按钮与页面控件。
+- **参数 / Parameters：** 无。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+   不需要手动调用，一般在 `std::unique_ptr<TabControl>` 或其父容器析构时自动触发。
+
+------
+
+#### TabControl::draw()  (重写自 Canvas)
+
+- **用途：**
+   绘制整个 TabControl，包括自身背景、边框、页签按钮以及各个页面内容。TabControl
+
+- **Purpose:**
+   Draws the entire `TabControl`, including its background, border, all tab buttons, and each page’s content.
+
+- **参数 / Parameters：** 无。
+
+- **返回值 / Return：** 无。
+
+- **行为细节 (Details)：**
+
+  实现大致步骤为：
+
+  1. 若控件不可见或未标记为 `dirty`，直接返回，不做任何绘制。
+  2. 如果之前已有背景快照（`hasSnap == true`），先回贴旧快照以清除旧内容；若位置或尺寸已发生变化，则丢弃旧快照并在当前区域重新抓取背景。
+  3. 若是首次绘制，则在当前 `(x, y, width, height)` 区域抓取背景快照。
+  4. 再次将最新背景回贴到屏幕上，保证绘制区域是干净的。
+  5. 调用 `Canvas::draw()`，绘制画布自身的背景、边框和内部 Canvas 子控件。
+  6. 遍历所有 `(Button, Canvas)` 对：
+     - 对每个按钮：标记为 `dirty` 并调用按钮的 `draw()`。
+     - 对每个页面 Canvas：标记为 `dirty` 并调用页面的 `draw()`。
+  7. 完成后将自身 `dirty` 置为 `false`。
+
+  通过这种“背景快照 + 统一绘制”的方式，TabControl 在频繁切换页签或窗口拉伸时减少闪烁，并避免多次重复清屏。
+
+------
+
+#### TabControl::handleEvent(const ExMessage& msg)  (重写自 Control)
+
+- **用途：**
+   处理与 TabControl 相关的输入事件（主要是鼠标事件），包括页签按钮点击和页面内部控件事件。
+- **Purpose:**
+   Handles input events for the `TabControl`, including tab button clicks and events for controls inside each page.
+- **参数 / Parameters：**
+  - `msg`：事件消息 `ExMessage`，可能包含鼠标移动、按下、弹起等信息。
+- **返回值 / Return：**
+  - `true`：事件已被某个页签按钮或页面控件消费。
+  - `false`：没有任何子控件处理该事件。
+- **行为细节 (Details)：**
+  - 若整个 TabControl 目前不可见（`show == false`），直接返回 `false`。
+  - 首先遍历所有页签按钮 (`controls[idx].first`)：
+    - 若某个按钮 `handleEvent(msg)` 返回 `true`，立即将 `consume` 设为 `true` 并停止继续检查其他按钮。
+  - 然后遍历所有页面 Canvas (`controls[idx].second`)：
+    - 仅对当前可见的页面调用 `handleEvent`；
+    - 若某个页面处理了事件，设置 `consume = true` 并停止后续检查。TabControl
+  - 如果在事件处理过程中 TabControl 被标记为 `dirty`，则调用 `requestRepaint(parent)` 请求上层容器进行统一重绘。
+  - 最终返回 `consume`，表明事件是否已被 TabControl 或其子控件消费。
+
+------
+
+#### TabControl::add(std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>&& control)
+
+- **用途：**
+   向 TabControl 中添加一个新的“页签按钮 + 页面(Canvas)”组合。
+
+- **Purpose:**
+   Adds a new `(Button, Canvas)` pair as a tab and its corresponding page to the `TabControl`.
+
+- **参数 / Parameters：**
+
+  - `control`：一个右值引用的 `std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>>`，包含页签按钮和对应页面对象的所有权。
+
+- **返回值 / Return：** 无。
+
+- **行为细节 (Details)：**
+
+  1. 将传入的 `(Button, Canvas)` 移动到内部 `controls` 列表末尾。
+  2. 调用 `initTabBar()` 和 `initTabPage()` 重新计算所有页签按钮与页面区域的位置和大小。
+  3. 为新加入的按钮和页面做额外初始化：
+     - 将按钮的 `parent` 设置为该 `TabControl`；
+     - 启用按钮的 tooltip (`enableTooltip(true)`）；
+     - 将按钮模式设为 `ButtonMode::TOGGLE`；
+     - 注册 `setOnToggleOnListener`：
+       - 打开对应页面、调用页面的 `onWindowResize()`；
+       - 关闭其他所有页签页面并取消其按钮选中；
+       - 将 TabControl 标记为 `dirty`。
+     - 注册 `setOnToggleOffListener`：
+       - 关闭对应页面，并将 TabControl 标记为 `dirty`。
+     - 将页面 Canvas 的 `parent` 设置为该 `TabControl`，同步线宽 `setLinewidth(canvaslinewidth)`，并初始置为不可见。
+
+- **示例：**
+
+  ```
+  auto tabButton = std::make_unique<Button>(0, 0, 80, 30, "Page1");
+  auto tabPage   = std::make_unique<Canvas>(0, 0, 300, 200);
+  
+  TabControl tabs(10, 10, 400, 300);
+  tabs.add(std::make_pair(std::move(tabButton), std::move(tabPage)));
+  ```
+
+------
+
+#### TabControl::add(std::string tabText, std::unique_ptr<Control> control)
+
+- **用途：**
+   向指定页签的页面中添加一个普通控件，例如 Label、Button、Table 等。TabControl
+- **Purpose:**
+   Adds a regular `Control` (e.g., a Label, Button, or Table) to the page corresponding to the tab whose button text matches `tabText`.
+- **参数 / Parameters：**
+  - `tabText`：页签按钮显示文本，用于定位目标页签。
+  - `control`：将要添加到该页的控件所有权（`std::unique_ptr<Control>`）。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  1. 先将该控件标记为 `dirty`。
+  2. 遍历内部 `controls` 列表，查找按钮文本 (`getButtonText()`) 等于 `tabText` 的页签。
+  3. 找到后：
+     - 将控件的 `parent` 设置为该页对应的 Canvas；
+     - 根据当前页面的可见状态设置控件可见性；
+     - 调用该 Canvas 的 `addControl()` 将控件加入页面。
+  4. 如果没有找到对应文本的页签，则什么也不做（控件会被丢弃，因此实际使用时应保证 `tabText` 有效）。
+
+------
+
+#### TabControl::setTabPlacement(StellarX::TabPlacement placement) / setTabBarHeight(int height)
+
+- **用途：**
+   配置页签栏的摆放方向以及页签栏的高度（对于左右摆放时则为页签栏宽度）。TabControl
+- **Purpose:**
+   Configures the orientation of the tab bar and its height (or width when placed on the left/right).
+- **参数 / Parameters：**
+  - `placement`：`StellarX::TabPlacement` 枚举值，可为 `Top` / `Bottom` / `Left` / `Right`。
+  - `height`：页签栏高度；当页签栏在左/右时，此值用作页签栏的宽度。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - `setTabPlacement`：
+    - 更新内部 `tabPlacement`；
+    - 调用 `setDirty(true)` 标记控件需要重绘；
+    - 调用 `initTabBar()` 和 `initTabPage()` 重新布局所有按钮和页面。
+  - `setTabBarHeight`：
+    - 更新 `tabBarHeight`；
+    - 同样标记脏区并重新初始化页签按钮与页面区域。
+
+------
+
+#### TabControl::setIsVisible(bool visible)  (重写自 Canvas)
+
+- **用途：**
+   设置 TabControl 及其所有页签按钮和页面的可见性。TabControl
+- **Purpose:**
+   Sets the visibility of the `TabControl` and all its tab buttons and pages.
+- **参数 / Parameters：**
+  - `visible`：`true` 表示显示，`false` 表示隐藏。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  1. 首先调用 `Canvas::setIsVisible(visible)`，以处理画布自身的背景快照逻辑。
+  2. 更新内部 `show` 标志。
+  3. 对每个页签：
+     - 按钮继承该可见性；
+     - 页面也跟随显示/隐藏，并被标记为 `dirty` 以便重新绘制或清除残影。
+
+------
+
+#### TabControl::onWindowResize()  (重写自 Control)
+
+- **用途：**
+   当窗口大小变化时更新 TabControl 布局，包括页签按钮位置及各页面区域大小，并将尺寸变化传递给每个页面 Canvas。
+- **Purpose:**
+   Updates the layout of the `TabControl` (tab buttons and page areas) when the window is resized and propagates the size change to each page canvas.
+- **参数 / Parameters：** 无。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 调用 `initTabBar()` 重新计算每个页签按钮的尺寸和位置。
+  - 调用 `initTabPage()` 重新为每个页面 Canvas 设置 `(x, y, width, height)`，并根据页签栏位置重新定位其子控件（通过它们的 `getLocalX()/getLocalY()` 计算新的全局坐标）。
+  - 保证在窗口拉伸后，页签与页面整体布局始终保持一致。
+
+------
+
+#### TabControl::getActiveIndex() const / setActiveIndex(int idx)
+
+- **用途：**
+   获取或设置当前处于激活状态的页签索引。
+- **Purpose:**
+   Gets or sets the index of the currently active tab.
+- **参数 / Parameters：**
+  - `idx`：要激活的页签索引（从 0 开始）。
+- **返回值 / Return：**
+  - `getActiveIndex()`：返回当前激活页签的索引；若没有任何页签被选中，可能返回 `-1`。
+  - `setActiveIndex()`：无返回值。
+- **行为细节 (Details)：**
+  - `getActiveIndex()`：遍历内部 `controls` 列表，找到第一个按钮处于“选中/点击”状态的页签并返回其索引。若无匹配则返回 `-1`（实现细节以源码为准）。
+  - `setActiveIndex(idx)`：
+    - 若索引无效（越界或对应按钮被禁用），一般不会执行任何切换。
+    - 对指定索引的按钮执行“切换到 ON”逻辑：
+      - 显示对应页面并调用其 `onWindowResize()`；
+      - 将其他页签按钮置为未选中并隐藏对应页面。
+
+------
+
+#### TabControl::count() const / indexOf(const std::string& tabText) const
+
+- **用途：**
+   查询页签数量以及通过页签文本查找索引。
+- **Purpose:**
+   Queries the number of tabs and finds a tab index by its button text.
+- **参数 / Parameters：**
+  - `tabText`：用于查找的页签按钮文本。
+- **返回值 / Return：**
+  - `count()`：返回当前 TabControl 中的页签数量。
+  - `indexOf(tabText)`：若存在文本为 `tabText` 的页签，则返回其索引；否则返回 `-1`。
+- **行为细节 (Details)：**
+  - `count()` 实际上返回内部 `controls` 向量的大小。
+  - `indexOf()` 遍历 `controls`，比较每个按钮的 `getButtonText()` 与 `tabText` 是否相等。
+
+------
+
+#### TabControl::setDirty(bool dirty) override / requestRepaint(Control* parent) override
+
+- **用途：**
+   手动标记 TabControl 为“需要重绘”，并在适当时向父容器请求统一重绘。
+- **Purpose:**
+   Manually marks the `TabControl` as dirty and requests a unified repaint from the parent container when needed.
+- **参数 / Parameters：**
+  - `dirty`：`true` 表示需要重绘，`false` 表示清除脏标记。
+  - `parent`：父控件指针（通常由内部调用时传入）。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - `setDirty(true)` 会把 TabControl 标记为需要重绘；通常在切换页签或布局变化时调用。
+  - `requestRepaint(parent)`：
+    - 若在事件处理后发现 `dirty == true`，TabControl 会调用此方法；
+    - 如果 `parent` 是 TabControl 自己，将触发自身重绘；
+    - 否则会向上层容器请求一次“统一收口”的重绘，以避免在事件处理中直接多次重绘导致闪烁。
+
+------
+
+## Window 类 (应用主窗口)
+
+*Window Class (Application Main Window)*
+
+**描述：**
+ `Window` 是整个应用程序的主窗口封装，负责初始化 EasyX 图形环境、创建并管理 Win32 窗口句柄，承载所有顶层控件和对话框，并提供统一的绘制与事件循环机制。它解决了窗口可拉伸、最小尺寸约束、合成双缓冲以及模态/非模态对话框与主窗口之间的重绘协调等问题。
+
+**Description:**
+ `Window` is the main application window wrapper. It initializes EasyX, creates and manages the Win32 window handle, hosts all top-level controls and dialogs, and provides unified drawing and event-loop handling. It addresses issues such as resizable windows, minimum client size constraints, composited double-buffering, and coordinated redrawing between modal/non-modal dialogs and the main window.
+
+**特性 (Features):**
+
+- 创建和关闭 EasyX 图形环境，持有 `HWND`、背景图像、背景颜色等状态 *(Creates/closes EasyX, holds `HWND`, background image/color state.)*
+- 支持纯色背景与背景图片两种绘制模式 *(Supports solid-color and image-based backgrounds.)*Window
+- 提供统一的 `draw()` 和 `runEventLoop()` 接口，集中处理绘制与输入事件 *(Provides unified `draw()` and `runEventLoop()` for drawing and event handling.)*
+- 支持设置最小客户区尺寸，在拖动窗口时进行“最小尺寸夹紧” *(Supports minimum client size and clamps during `WM_SIZING`.)*Window
+- 支持可选的 `WS_EX_COMPOSITED` 合成双缓冲，减少子控件闪烁 *(Optional `WS_EX_COMPOSITED` composited buffering to reduce flicker.)*Window
+- 内部维护控件列表和对话框列表，并按“对话框优先、控件之后”的顺序分发事件 *(Maintains control and dialog lists and dispatches events in dialog-first order.)*
+
+### 公共成员函数 (Public Member Functions)
+
+#### Window::Window(int width, int height, int mode)
+
+#### Window::Window(int width, int height, int mode, COLORREF bkcloc)
+
+#### Window::Window(int width, int height, int mode, COLORREF bkcloc, std::string headline)
+
+- **用途：**
+   创建主窗口对象，设置初始客户区尺寸、EasyX 启动模式、背景颜色及窗口标题文本。Window
+- **Purpose:**
+   Constructs the main window with an initial client size, EasyX mode, background color, and window title.
+- **参数 / Parameters：**
+  - `width`, `height`：窗口初始客户区宽度和高度。
+  - `mode`：EasyX 初始化模式（例如 `EX_SHOWCONSOLE`、`EX_TOPMOST` 等）。
+  - `bkcloc`：窗口背景颜色（COLORREF）。
+  - `headline`：窗口标题文本。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 三个构造函数都初始化：
+    - 当前有效宽高 `width`, `height`；
+    - 待应用尺寸 `pendingW`, `pendingH`；
+    - 最小客户区尺寸 `minClientW`, `minClientH`（初始与创建尺寸相同）；
+    - `windowMode` 为传入的模式。
+  - 有背景色参数版本会额外设置 `wBkcolor`；带标题版本则还会设置 `headline`。
+  - EasyX 的窗口真正被创建是在第一次调用 `draw()` 时，而不是构造时。
+
+------
+
+#### Window::~Window()
+
+- **用途 / Purpose：**
+   析构窗口对象，释放背景图资源并关闭 EasyX 图形环境。Window
+- **行为细节 (Details)：**
+  - 若存在 `background` 图像对象则删除；
+  - 调用 `closegraph()` 关闭 EasyX。
+  - 一般不需要手动调用析构，离开作用域或 `std::unique_ptr<Window>` 被释放时会自动执行。
+
+------
+
+#### Window::draw() / Window::draw(std::string pImgFile)
+
+- **用途：**
+   对窗口进行一次完整绘制：
+  - 纯色版本：使用当前背景色清屏，再绘制所有控件和对话框；
+  - 背景图版本：加载指定图片作为背景，填满客户区，再绘制控件和对话框。
+- **Purpose:**
+   Performs a full-frame draw of the window:
+  - solid-color version: clears the client area with the current background color, then draws all controls and dialogs;
+  - image version: loads and draws the specified image as the background, then draws all controls and dialogs.
+- **参数 / Parameters：**
+  - `pImgFile`：背景图片文件路径（仅限带参数版本）。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 若尚未初始化 EasyX：
+    - 调用 `initgraph(width, height, windowMode)` 创建窗口并记录 `hWnd`；
+    - 子类化 EasyX 窗口过程为 `WndProcThunk`，用于统一处理 `WM_ERASEBKGND`、`WM_ENTERSIZEMOVE`、`WM_SIZING`、`WM_EXITSIZEMOVE`、`WM_GETMINMAXINFO` 等消息；
+    - 调用 `ApplyResizableStyle` 应用可拉伸、剪裁和可选的 `WS_EX_COMPOSITED` 样式。
+  - 纯色版本：
+    - 设置背景色 `setbkcolor(wBkcolor)` 并 `cleardevice()` 清屏；
+  - 背景图版本：
+    - 若尚无 `background` 对象则分配之；
+    - 加载图片到 `background`，用 `loadimage(background, bkImageFile.c_str(), width, height, true)` 填充；
+    - `putimage(0, 0, background)` 将其绘制到客户区。Window
+  - 之后统一使用批量绘制：
+    - `BeginBatchDraw()`；
+    - 遍历所有 `controls` 和 `dialogs`：对每个设置 `dirty = true` 并调用其 `draw()`；
+    - `EndBatchDraw()`。
+  - `draw(pImgFile)` 版本会在内部更新 `bkImageFile` 后再调用背景图绘制流程。
+
+------
+
+#### Window::runEventLoop()
+
+- **用途：**
+   运行窗口的主事件循环：持续从 EasyX 事件队列中取出消息，分发给对话框与控件，处理窗口尺寸变化，并在需要时统一重绘。
+
+- **Purpose:**
+   Runs the main event loop of the window: pulls messages from EasyX’s event queue, dispatches them to dialogs and controls, handles window size changes, and triggers unified redraws when needed.
+
+- **参数 / Parameters：** 无。
+
+- **返回值 / Return：**
+   返回整数状态码，一般用于表示是否正常退出。
+
+- **行为细节 (Details)：**
+
+  典型流程：
+
+  1. 持续调用 `peekmessage(&msg, EM_MOUSE | EM_KEY | EM_WINDOW, true)` 获取事件。
+  2. 若收到关闭事件（如 `WM_CLOSE` 等），跳出循环返回。
+  3. 对 `EX_WINDOW` 类型的消息调用 `processWindowMessage(msg)`，记录最新 `pendingW/pendingH` 并根据拉伸状态设置 `needResizeDirty`。Window
+  4. 将普通事件先分发给对话框列表（从后往前，确保最新加入的对话框优先），再分发给普通控件。若有控件消费事件则不再向后传递。
+  5. 每轮循环末尾若 `needResizeDirty == true`，调用 `pumpResizeIfNeeded()`：
+     - 读取 `pendingW/pendingH` 为最终尺寸；
+     - 按新尺寸调整所有控件（调用它们的 `onWindowResize()` 或 anchor 布局逻辑）；
+     - 统一重绘窗口与控件。
+
+------
+
+#### Window::setBkImage(std::string pImgFile)
+
+- **用途：**
+   设置窗口背景图片，并立即以该图片为背景重新绘制所有控件和对话框。Window
+- **Purpose:**
+   Sets the window’s background image and immediately redraws the window using this image as background.
+- **参数 / Parameters：**
+  - `pImgFile`：背景图片文件路径。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 更新内部 `bkImageFile`；
+  - 如果还没有 `background` 对象，则创建一个；
+  - 使用 `loadimage` 将图片缩放至当前窗口大小并绘制到 (0,0)；
+  - 然后与 `draw()` 中相同，批量重绘所有控件和对话框。
+
+------
+
+#### Window::setBkcolor(COLORREF c) / Window::setHeadline(std::string headline)
+
+- **用途：**
+  - `setBkcolor`：设置窗口的纯色背景，并立即重绘所有控件/对话框。
+  - `setHeadline`：更新窗口标题文本，并在窗口已经创建时调用 `SetWindowText`。Window
+- **Purpose:**
+  - `setBkcolor` sets the solid background color and immediately redraws the window.
+  - `setHeadline` updates the window caption text and applies it via `SetWindowText` if the HWND is available.
+- **参数 / Parameters：**
+  - `c`：COLORREF 格式的背景颜色。
+  - `headline`：新的窗口标题文本。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - `setBkcolor`：
+    - 更新 `wBkcolor`；
+    - 调用 `setbkcolor` 和 `cleardevice` 清屏；
+    - 使用批绘 (`BeginBatchDraw/EndBatchDraw`) 重新调用每个控件和对话框的 `draw()`。
+  - `setHeadline`：
+    - 仅更新内部字符串并在 `hWnd` 有效时调用 `SetWindowText`，不会触发重绘。
+
+------
+
+#### Window::addControl(std::unique_ptr<Control> control) / addDialog(std::unique_ptr<Control> dialogs)
+
+- **用途：**
+   向窗口添加一个普通控件或一个非模态对话框。Window
+- **Purpose:**
+   Adds a normal control or a non-modal dialog to the window.
+- **参数 / Parameters：**
+  - `control`：顶层控件对象（例如 Canvas、Table 等）的所有权。
+  - `dialogs`：对话框控件对象（通常是 `Dialog` 派生类）的所有权。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - `addControl`：将控件加入 `controls` 向量，实际绘制在下一次 `draw()` 或统一重绘时完成。
+  - `addDialog`：将对话框加入 `dialogs` 向量，事件分发时会优先给对话框列表（从后往前）处理，以保证最新弹出的对话框优先响应。
+
+------
+
+#### Window::hasNonModalDialogWithCaption(const std::string& caption, const std::string& message) const
+
+- **用途：**
+   检查当前窗口是否已经存在一个“可见且非模态”的对话框，其标题和文本与给定参数一致，用于避免重复弹出相同提示框。Window
+- **Purpose:**
+   Checks whether there is already a visible, non-modal dialog whose caption and text match the given parameters, to avoid showing duplicate dialogs.
+- **参数 / Parameters：**
+  - `caption`：对话框标题。
+  - `message`：对话框内容文本。
+- **返回值 / Return：**
+  - `true`：存在匹配的非模态对话框。
+  - `false`：不存在。
+- **行为细节 (Details)：**
+  - 遍历 `dialogs` 列表，对每个元素尝试 `dynamic_cast<Dialog*>`：
+    - 检查该对话框是否可见 (`IsVisible()`)、是否为非模态 (`!model()`)、标题是否为 `caption`、内容是否为 `message`。
+  - 一旦找到匹配对象立即返回 `true`，否则遍历结束返回 `false`。
+
+------
+
+#### Window::getHwnd() const / getWidth() const / getHeight() const
+
+#### Window::getHeadline() const / getBkcolor() const / getBkImage() const / getBkImageFile() const / getControls()
+
+- **用途：**
+   提供对窗口当前状态的只读访问，包括 HWND、尺寸、标题、背景颜色/图片及控件列表。
+- **Purpose:**
+   Provides read-only access to the window’s current state: HWND, size, caption, background color/image, and control list.
+- **参数 / Parameters：** 无。
+- **返回值 / Return：**
+  - `getHwnd()`：返回底层 Win32 窗口句柄。
+  - `getWidth()` / `getHeight()`：返回最近一次记录的 `pendingW` / `pendingH`（最近收到的尺寸），注意可能尚未应用到画布。Window
+  - `getHeadline()`：返回当前窗口标题字符串。
+  - `getBkcolor()`：返回当前背景颜色。
+  - `getBkImage()`：返回背景图片的 `IMAGE*` 指针（可能为空）。
+  - `getBkImageFile()`：返回当前背景图片文件路径字符串。
+  - `getControls()`：返回内部控件容器的引用 `std::vector<std::unique_ptr<Control>>&`，可用于遍历或对现有控件做进一步配置。
+- **行为细节 (Details)：**
+  - 因为窗口尺寸调整采用“统一收口”策略，所以 `getWidth()/getHeight()` 返回的是最新一次 `WM_SIZE` 或拉伸过程中记录的尺寸；真正应用到控件上的尺寸以收口时的 `width/height` 为准。
+  - `getControls()` 返回引用，调用者不应删除或替换其中的指针，只应在逻辑上遍历和配置已有控件。
+
+------
+
+#### Window::setMinClientSize(int w, int h)  (inline)
+
+#### Window::setComposited(bool on)  (inline)
+
+- **用途：**
+  - `setMinClientSize`：设置窗口允许的最小客户区宽高，用于在拉伸和最大最小化过程中进行尺寸约束。
+  - `setComposited`：打开或关闭 `WS_EX_COMPOSITED` 合成双缓冲样式。
+- **Purpose:**
+  - `setMinClientSize` sets the minimum allowed client width and height.
+  - `setComposited` toggles the use of the `WS_EX_COMPOSITED` extended style for composited double buffering.
+- **参数 / Parameters：**
+  - `w`, `h`：最小客户区宽、高。
+  - `on`：是否启用合成双缓冲。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - `setMinClientSize` 仅更新内部 `minClientW` / `minClientH`；真实约束发生在：
+    - `WM_GETMINMAXINFO`：提供系统层面的最小跟踪大小限制；
+    - `WM_SIZING` 阶段，通过 `ApplyMinSizeOnSizing` 对被拖动的边进行“夹紧”，避免窗口被拉得比指定最小值还小。
+  - `setComposited` 只更新 `useComposited` 标志，实际样式在下次 `draw()` 时通过 `ApplyResizableStyle` 应用，并用 `SWP_FRAMECHANGED` 通知系统更新非客户区域。
+
+------
+
+#### Window::processWindowMessage(const ExMessage& msg)
+
+- **用途：**
+   处理 `EX_WINDOW` 类型的窗口消息（例如 `WM_SIZE` 等），记录最新尺寸并在适当时标记 `needResizeDirty` 以触发统一收口重绘。
+- **Purpose:**
+   Handles `EX_WINDOW` messages (such as `WM_SIZE`), records the latest size, and sets `needResizeDirty` to trigger a unified resize-and-redraw pass.
+- **参数 / Parameters：**
+  - `msg`：来自 EasyX 的 `ExMessage` 窗口消息。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 对 `WM_SIZE` 消息更新 `pendingW/pendingH` 为当前客户区新尺寸；
+  - 结合 `isSizing` 状态判断是否处于拉伸过程；
+  - 适当时将 `needResizeDirty` 置为 `true`，在主循环末尾由 `pumpResizeIfNeeded()` 统一处理。
+
+------
+
+#### Window::pumpResizeIfNeeded()
+
+- **用途：**
+   若 `needResizeDirty` 已被置位，则执行一次统一的“尺寸应用 + 布局自适应 + 全量重绘”。
+- **Purpose:**
+   If `needResizeDirty` is set, performs a unified pass to apply the new size, adapt layout, and redraw the entire window.
+- **参数 / Parameters：** 无。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 读取 `pendingW/pendingH` 作为最终尺寸更新 `width/height`；
+  - 更新 EasyX 绘图区域以及内部控件布局（调用 `adaptiveLayout`、控件 `onWindowResize()` 等）；
+  - 调用 `draw()` 或等价流程重新绘制所有控件和对话框；
+  - 最后清除 `needResizeDirty` 标志。
+
+------
+
+#### Window::scheduleResizeFromModal(int w, int h)
+
+- **用途：**
+   在模态对话框内部需要调整主窗口尺寸时，安全地将“主窗口尺寸调整请求”记录下来，并在回到主事件循环后统一执行，避免在模态循环中直接重绘导致冲突。
+- **Purpose:**
+   Schedules a window resize from within a modal dialog by recording the desired width/height and letting the main loop apply the change later, avoiding redraw conflicts inside a modal loop.
+- **参数 / Parameters：**
+  - `w`, `h`：希望调整到的客户区宽高。
+- **返回值 / Return：** 无。
+- **行为细节 (Details)：**
+  - 将传入的 `w/h` 与最小客户区尺寸 `minClientW/minClientH` 比较，确保不小于最小值；
+  - 将通过 `ClientToScreen/ScreenToClient` 等换算为客户区尺寸的结果写入 `pendingW/pendingH`；
+  - 标记 `needResizeDirty = true`；
+  - 真正的尺寸应用与重绘在主事件循环末尾由 `pumpResizeIfNeeded()` 完成，从而保证模态对话框关闭后主窗口尺寸与布局同步更新且无残影。
+
+
+
+---
+
+## Dialog 类（模态/非模态对话框控件）
+
+*Dialog Class (Modal / Non-Modal Dialog Control)*
+
+**描述：**
+ `Dialog` 继承自 `Canvas`，是一个完整的对话框控件，支持模态与非模态两种工作模式。它负责消息文本的换行布局、按钮区域布局、标题栏与关闭按钮绘制，以及背景快照保存/恢复和延迟清理，保证对话框关闭后不会在窗口上留下残影。
+
+**Description:**
+ `Dialog` is a `Canvas`-derived control representing a full-featured dialog box. It supports modal and non-modal usage modes, performs automatic line wrapping and layout of the message text and buttons, draws the title bar and close button, and manages background snapshots with a delayed cleanup strategy to prevent artifacts after closing.
+
+**特性 (Features)：**
+
+- 支持多种标准按钮组合：`OK`、`OKCancel`、`YesNo`、`YesNoCancel`、`RetryCancel`、`AbortRetryIgnore`。Dialog
+- 支持模态（内部轮询事件）与非模态（由 `Window` 事件循环驱动）两种模式。
+- 自动根据文本与按钮数量计算对话框宽高，并在所属窗口内居中。Dialog
+- 背景快照 `saveBackground` / `restBackground` + 延迟清理 `performDelayedCleanup`，避免对话框关闭后出现残影。Dialog
+
+------
+
+### 公共成员变量 (Public Data Members)
+
+#### Dialog::textStyle
+
+- **用途：**
+   控制对话框中文字（标题与正文）的字体样式，如字体名、字号、高度、是否加粗 / 斜体等。默认会在 `initDialogSize()` 里设置一个合适的高度，然后用于绘制标题与每一行文本。
+
+- **Purpose:**
+   Stores the font style (`StellarX::ControlText`) used to draw the dialog’s title and message text. It affects text height, width, font face, weight, italic, underline, etc.
+
+- **示例 (Example)：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "这是对话框正文内容");
+  // 修改字体颜色和高度
+  dlg.textStyle.color   = RGB(255, 0, 0);
+  dlg.textStyle.nHeight = 24;
+  dlg.SetMessage("更新后的文本使用新的字体样式");
+  dlg.Show(); // 模态/非模态行为由构造时的 modal 参数决定
+  ```
+
+------
+
+#### Dialog::resultCallback
+
+- **用途：**
+   非模态对话框关闭后返回结果时使用的回调函数，一般由 `MessageBox::showAsync` 通过 `SetResultCallback` 设置。`Close()` 中如果 `!modal` 且 `resultCallback` 非空，会调用此回调并传入当前 `result`。
+
+- **Purpose:**
+   A callback invoked when a non-modal dialog is closed, used to deliver the `MessageBoxResult`. Typically set indirectly via `SetResultCallback` and used by `MessageBox::showAsync`.
+
+- **示例 (Example)：**
+
+  ```
+  auto dlg = std::make_unique<Dialog>(
+      mainWindow,
+      "异步确认",
+      "这是一个非模态对话框",
+      StellarX::MessageBoxType::YesNo,
+      false // 非模态
+  );
+  dlg->resultCallback = [](StellarX::MessageBoxResult r) {
+      if (r == StellarX::MessageBoxResult::Yes) {
+          // 用户点了“是”
+      }
+  };
+  mainWindow.addDialog(std::move(dlg));
+  ```
+
+> 实际使用时更推荐通过 `SetResultCallback` 设置，而不是直接访问成员。
+
+------
+
+### 公共成员函数 (Public Member Functions)
+
+#### Dialog::Dialog(Window& hWnd, std::string text, std::string message = "对话框", MessageBoxType type = MessageBoxType::OK, bool modal = true)
+
+- **用途：**
+   构造一个对话框。`text` 作为标题（caption），`message` 作为正文内容，`type` 控制按钮组合，`modal` 控制是否为模态对话框。
+
+- **Purpose:**
+   Constructs a dialog with the given caption (`text`), message body (`message`), message box type (`type`), and modality (`modal`).
+
+- **参数：**
+
+  - `hWnd`：所属 `Window` 引用，用于计算居中位置、访问窗口尺寸及背景。
+  - `text`：标题文本。
+  - `message`：正文内容（缺省为 `"对话框"`）。
+  - `type`：按钮组合类型，默认为 `MessageBoxType::OK`。
+  - `modal`：`true` 表示模态对话框，`false` 表示非模态。
+
+- **返回值：**
+   无（构造函数）。
+
+- **示例：**
+
+  ```
+  Dialog dlg(
+      mainWindow,
+      "删除确认",                    // 标题
+      "确定要删除选中的记录吗？",    // 正文
+      StellarX::MessageBoxType::YesNo,
+      true                           // 模态
+  );
+  dlg.Show();
+  auto result = dlg.GetResult();
+  ```
+
+------
+
+#### Dialog::~Dialog()
+
+- **用途 / Purpose：**
+   对话框析构函数，用于释放内部资源。实际的背景恢复与控件清理主要通过 `performDelayedCleanup()` 完成，析构函数本身为默认实现。Dialog
+
+- **示例：**
+
+  ```
+  {
+      Dialog dlg(mainWindow, "提示", "作用域结束时自动析构");
+      dlg.Show();
+  } // 这里 dlg 析构
+  ```
+
+------
+
+#### Dialog::draw()  (重写自 Canvas)
+
+- **用途：**
+   绘制对话框，包括背景快照恢复、边框与圆角矩形、内部子控件、以及多行文本消息。仅当 `show == true && dirty == true` 时才绘制。Dialog
+
+- **Purpose:**
+   Renders the dialog: restores background from snapshot, draws the rounded-rectangle border and background, draws child controls, and then draws the message text lines. Only draws when the dialog is visible and marked dirty.
+
+- **参数 / Parameters：**
+   无。
+
+- **返回值 / Return：**
+   无。
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "手动调用 draw 示例", StellarX::MessageBoxType::OK, false);
+  dlg.setInitialization(true); // 确保已计算尺寸和背景
+  dlg.Show();                  // 标记 show = true
+  dlg.draw();                  // 非常用：通常由 Window 或内部循环自动调用
+  ```
+
+------
+
+#### Dialog::handleEvent(const ExMessage& msg)
+
+- **用途：**
+   处理与对话框相关的输入事件（鼠标、键盘等）。模态对话框还会拦截点击对话框外部区域的事件并发出提示音，不允许操作背景内容。Dialog
+
+- **Purpose:**
+   Handles input events for the dialog, forwarding them to child controls and optionally consuming them. For modal dialogs, clicks outside the dialog area are consumed with a beep to prevent interaction with background controls.
+
+- **参数：**
+
+  - `msg`：`ExMessage` 事件结构。
+
+- **返回值：**
+
+  - `bool`：若事件被对话框或其子控件消费返回 `true`，否则返回 `false`。
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "handleEvent 示例", StellarX::MessageBoxType::OK, false);
+  dlg.Show();
+  
+  ExMessage msg;
+  if (peekmessage(&msg, EX_MOUSE | EX_KEY)) {
+      bool handled = dlg.handleEvent(msg);
+      if (handled) {
+          // 事件已被对话框消费
+      }
+  }
+  ```
+
+------
+
+#### Dialog::SetTitle(const std::string& title)
+
+- **用途：**
+   设置对话框标题文本，并在已有标题 `Label` 存在时更新其显示内容，最后标记对话框为脏以触发重绘。Dialog
+
+- **Purpose:**
+   Sets the dialog’s title text, updates the internal label if it exists, and marks the dialog dirty to redraw on the next frame.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "初始标题", "正文");
+  dlg.SetTitle("运行时修改后的标题");
+  dlg.Show();
+  ```
+
+------
+
+#### Dialog::SetMessage(const std::string& message)
+
+- **用途：**
+   更新对话框正文内容。内部会重新按行拆分文本、计算文本宽高，并标记对话框为脏。Dialog
+
+- **Purpose:**
+   Updates the message body, re-splits it into lines, recomputes text size, and marks the dialog dirty.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "旧消息");
+  dlg.SetMessage("这是更新后的消息\n会自动换行并重新计算尺寸");
+  dlg.Show();
+  ```
+
+------
+
+#### Dialog::SetType(StellarX::MessageBoxType type)
+
+- **用途：**
+   设置对话框按钮组合类型（如 `OK`, `OKCancel`, `YesNo` 等），并重新创建功能按钮。Dialog
+
+- **Purpose:**
+   Sets the message box type (button combination) and reinitializes the buttons accordingly.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "你喜欢哪种按钮组合？");
+  dlg.SetType(StellarX::MessageBoxType::YesNoCancel);
+  dlg.Show();
+  ```
+
+------
+
+#### Dialog::SetModal(bool modal)
+
+- **用途：**
+   设置对话框是否为模态。仅影响后续 `Show()` 的行为，已在运行中的对话框不会被立即切换模式。Dialog
+
+- **Purpose:**
+   Sets whether the dialog is modal; this affects how `Show()` behaves (blocking internal loop vs. being driven by the main event loop).
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "稍后以非模态方式显示", StellarX::MessageBoxType::OK, true);
+  dlg.SetModal(false); // 改成非模态
+  dlg.Show();
+  ```
+
+------
+
+#### Dialog::SetResult(StellarX::MessageBoxResult result)
+
+- **用途：**
+   手动设置对话框的结果值，一般由按钮回调内部调用，例如“确定”“取消”等按钮的点击处理。Dialog
+
+- **Purpose:**
+   Sets the dialog’s result value, typically used in button click handlers before closing the dialog.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "自定义结果", "点击后手动设置结果");
+  dlg.SetResult(StellarX::MessageBoxResult::OK);
+  dlg.Close();
+  ```
+
+------
+
+#### Dialog::GetResult() const
+
+- **用途：**
+   获取对话框当前存储的结果值，常在模态对话框 `Show()` 返回后使用。Dialog
+
+- **Purpose:**
+   Returns the dialog’s current `MessageBoxResult`, usually after a modal `Show()` returns.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "这是一个模态对话框");
+  dlg.Show();
+  StellarX::MessageBoxResult r = dlg.GetResult();
+  ```
+
+------
+
+#### Dialog::model() const
+
+- **用途：**
+   返回对话框当前是否为模态模式（内部持有的 `modal` 标志）。
+
+- **Purpose:**
+   Returns whether this dialog is configured as modal.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "标题", "正文", StellarX::MessageBoxType::OK, true);
+  bool isModal = dlg.model(); // true
+  ```
+
+------
+
+#### Dialog::Show()
+
+- **用途：**
+   显示对话框。
+
+  - 若为模态，则进入内部事件循环，阻塞当前线程，直到对话框关闭。
+  - 若为非模态，则只标记可见和脏，由 `Window::runEventLoop()` 统一驱动绘制与事件。
+
+- **Purpose:**
+   Shows the dialog.
+
+  - In modal mode, enters an internal loop processing size changes and input events until the dialog is closed.
+  - In non-modal mode, simply marks the dialog as visible and dirty, letting the main event loop handle events and redraws.
+
+- **示例：**
+
+  ```
+  // 模态用法
+  Dialog dlg1(mainWindow, "模态对话框", "这一段代码会阻塞直到关闭", StellarX::MessageBoxType::OK, true);
+  dlg1.Show();
+  auto r1 = dlg1.GetResult();
+  
+  // 非模态用法
+  Dialog dlg2(mainWindow, "非模态对话框", "主循环继续运行", StellarX::MessageBoxType::OK, false);
+  mainWindow.addDialog(std::make_unique<Dialog>(dlg2)); // 实际上应直接用 unique_ptr 构造
+  dlg2.Show();
+  ```
+
+------
+
+#### Dialog::Close()
+
+- **用途：**
+   关闭对话框：设置 `show = false`、`close = true`、标记 `dirty` 和 `pendingCleanup = true`，在适当时机执行延迟清理。同时在非模态模式下，如果设置了 `resultCallback`，会调用该回调函数将结果返回给调用者。Dialog
+
+- **Purpose:**
+   Closes the dialog: hides it, marks it dirty and pending cleanup, and for non-modal dialogs invokes `resultCallback` (if any) with the stored result.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "关闭示例", "点击按钮后调用 Close()");
+  // 假设某个按钮回调里：
+  dlg.SetResult(StellarX::MessageBoxResult::OK);
+  dlg.Close();
+  ```
+
+------
+
+#### Dialog::setInitialization(bool init)
+
+- **用途：**
+   在需要时显式触发对话框初始化：重新计算尺寸、居中位置，并重新抓取背景快照。一般由 `Show()` 内部与窗口尺寸变化逻辑（如模态时的 `scheduleResizeFromModal` / `pumpResizeIfNeeded`）调用。
+
+- **Purpose:**
+   Explicitly initializes the dialog when `init` is true: recomputes size, positions the dialog (usually centered), and captures a fresh background snapshot. Typically called internally when the dialog is first shown or when the parent window size changes.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "初始化示例", "在尺寸变化后重新初始化");
+  // 窗口尺寸变化后手动触发（通常由框架内部调用）
+  dlg.setInitialization(true);
+  dlg.Show();
+  ```
+
+------
+
+#### Dialog::performDelayedCleanup()
+
+- **用途：**
+   执行**延迟清理**：在对话框已经隐藏 (`show == false`) 且被标记为 `pendingCleanup` 时，恢复背景、清空子控件、重置内部状态，避免残影。这个函数通常在 `draw()` 或 `handleEvent()` 中自动调用，外部一般不需要手动调用。Dialog
+
+- **Purpose:**
+   Performs delayed cleanup after the dialog has been hidden: restores the saved background if any, clears child controls, and forces a full background + controls redraw when no snapshot is available, resetting internal flags afterwards. Normally called automatically by `draw()` / `handleEvent()` when `pendingCleanup` is set.
+
+- **示例（不推荐频繁手动调用，仅演示）：**
+
+  ```
+  Dialog dlg(mainWindow, "清理示例", "关闭后执行延迟清理");
+  dlg.Show();
+  dlg.Close();
+  // 若你在特殊情况下需要立即清掉残影，可以：
+  dlg.performDelayedCleanup(); // 通常框架会自动处理，无需手动调用
+  ```
+
+------
+
+#### Dialog::SetResultCallback(std::function<void(MessageBoxResult)> cb)
+
+- **用途：**
+   设置非模态对话框关闭时的结果回调函数。关闭时，如果 `!modal && resultCallback`，则调用此回调并传入 `result`。
+
+- **Purpose:**
+   Sets the callback to be invoked when a non-modal dialog is closed, passing the `MessageBoxResult` as argument.
+
+- **示例：**
+
+  ```
+  auto dlg = std::make_unique<Dialog>(
+      mainWindow,
+      "异步结果",
+      "点击按钮后回调被触发",
+      StellarX::MessageBoxType::YesNo,
+      false // 非模态
+  );
+  
+  dlg->SetResultCallback([](StellarX::MessageBoxResult r) {
+      if (r == StellarX::MessageBoxResult::Yes) {
+          // 用户选择了 Yes
+      } else {
+          // 其它结果
+      }
+  });
+  
+  mainWindow.addDialog(std::move(dlg));
+  ```
+
+------
+
+#### Dialog::GetCaption() const
+
+- **用途：**
+   获取对话框的标题文本（caption）。在工厂模式下用于非模态去重（与正文一起比对）。
+
+- **Purpose:**
+   Returns the dialog’s caption (title text), used by the factory to detect duplicate non-modal dialogs.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "标题A", "内容A");
+  std::string caption = dlg.GetCaption(); // "标题A"
+  ```
+
+------
+
+#### Dialog::GetText() const
+
+- **用途：**
+   获取对话框正文内容（message 文本），同样用于非模态对话框的去重逻辑。
+
+- **Purpose:**
+   Returns the dialog’s message text, used together with the caption in duplication checks for non-modal dialogs.
+
+- **示例：**
+
+  ```
+  Dialog dlg(mainWindow, "提示", "这是一条消息");
+  std::string text = dlg.GetText(); // "这是一条消息"
+  ```
+
+
+
+---
+
+## MessageBox 类（消息框工厂类）
+
+*MessageBox Class (Message Box Factory)*
+
+**描述：**
+ `MessageBox` 是一个**纯静态工厂类**，封装了 `Dialog` 的创建、显示与销毁逻辑，用来快速弹出标准消息框。支持**模态阻塞**和**非模态（异步回调）**两种方式，并内置去重逻辑，避免相同标题+内容的非模态对话框重复出现。
+
+**Description:**
+ `MessageBox` is a static factory class that encapsulates creation, display, and lifetime management of `Dialog` objects. It supports both **modal (blocking)** and **non-modal (asynchronous with callback)** message boxes, and includes a de-duplication mechanism to prevent multiple identical non-modal dialogs from being shown at the same time.
+
+**特性 (Features)：**
+
+- 纯静态类，无需实例化即可使用。
+- 一行代码即可弹出标准消息框，简化业务代码。
+- 支持模态阻塞（返回值）与非模态回调两种模式。
+- 非模态模式下，会通过 `Window::hasNonModalDialogWithCaption` 做去重。MessageBox
+
+------
+
+### 公共成员函数 (Public Member Functions)
+
+#### MessageBox::showModal(Window& wnd, const std::string& text, const std::string& caption = "提示", MessageBoxType type = MessageBoxType::OK)
+
+- **用途：**
+   在指定窗口 `wnd` 上弹出一个**模态消息框**，阻塞当前调用线程，直到用户点击按钮关闭对话框，并返回一个 `MessageBoxResult` 表示用户选择。
+
+- **Purpose:**
+   Shows a **modal** message box owned by `wnd`, blocking the current thread until the user closes the dialog, then returns a `MessageBoxResult` indicating which button was pressed.
+
+- **参数 (Parameters)：**
+
+  - `wnd`：所属窗口引用，用于居中对话框以及接入窗口的绘制/尺寸变化逻辑。
+  - `text`：对话框正文内容（消息文本）。
+  - `caption`：对话框标题文字，默认 `"提示"`。
+  - `type`：`StellarX::MessageBoxType`，指定按钮组合类型，如 `OK`、`OKCancel` 等，默认 `OK`。
+
+- **返回值 (Return)：**
+
+  - `MessageBoxResult`：枚举值，表示用户最终点击的按钮（如 `OK`、`Cancel`、`Yes`、`No` 等）。
+
+- **行为细节 (Details)：**
+
+  - 内部会构造一个 `Dialog dlg(wnd, caption, text, type, true)`，即创建模态对话框。
+  - 调用 `dlg.setInitialization(true)` 完成对话框尺寸计算、居中、背景快照等初始化。Dialog
+  - 再调用 `dlg.Show()`，进入对话框内部的模态事件循环（轮询窗口尺寸、处理键鼠事件、重绘对话框）。
+  - `Show()` 返回后，再调用 `dlg.GetResult()` 得到结果并返回给调用者。
+
+- **示例 (Example)：**
+
+  ```
+  #include "MessageBox.h"
+  #include "Window.h"
+  
+  // 在某个业务逻辑里询问用户是否退出
+  StellarX::MessageBoxResult result =
+      StellarX::MessageBox::showModal(
+          mainWindow,                         // 关联窗口
+          "确定要退出程序吗？",               // 正文
+          "退出确认",                         // 标题
+          StellarX::MessageBoxType::OKCancel  // 按钮类型：确定 / 取消
+      );
+  
+  if (result == StellarX::MessageBoxResult::OK) {
+      // 用户点了“确定”，执行退出逻辑
+  } else {
+      // 用户取消或关闭对话框，保持当前状态
+  }
+  ```
+
+------
+
+#### MessageBox::showAsync(Window& wnd, const std::string& text, const std::string& caption = "提示", MessageBoxType type = MessageBoxType::OK, std::function<void(MessageBoxResult)> onResult = nullptr)
+
+- **用途：**
+   在指定窗口上弹出一个**非模态消息框**，**立即返回**，不阻塞当前线程，通过传入的回调 `onResult` 在用户关闭对话框时异步获取结果。
+
+- **Purpose:**
+   Shows a **non-modal** message box associated with `wnd`. The function returns immediately, and the optional callback `onResult` is invoked asynchronously when the user closes the dialog, passing the `MessageBoxResult`.
+
+- **参数 (Parameters)：**
+
+  - `wnd`：对话框所属窗口。
+  - `text`：正文内容。
+  - `caption`：对话框标题，默认 `"提示"`。
+  - `type`：按钮组合类型，默认 `MessageBoxType::OK`。
+  - `onResult`：可选回调函数，签名为 `void(MessageBoxResult)`，在非模态对话框关闭后被调用。
+
+- **返回值 (Return)：**
+
+  - `void`。函数本身立即返回，不等待用户操作。
+
+- **行为细节 (Details)：**
+
+  - 调用前会先通过 `wnd.hasNonModalDialogWithCaption(caption, text)` 判断同标题+内容的非模态对话框是否已经存在，如存在则发出响铃并直接返回，不再创建新的对话框。
+  - 若未重复，则创建 `auto dlg = std::make_unique<Dialog>(wnd, caption, text, type, false);`，即非模态 `Dialog`。
+  - 将 `onResult` 传给 `dlgPtr->SetResultCallback(onResult)`，用于在 `Dialog::Close()` 中异步回调。
+  - 调用 `wnd.addDialog(std::move(dlg))` 将对话框交由 `Window` 管理生命周期，并最终调用 `dlgPtr->Show()` 显示。
+
+- **示例 (Example)：**
+
+  ```
+  #include "MessageBox.h"
+  #include "Window.h"
+  
+  // 弹出一个非模态提示框，提示保存成功
+  StellarX::MessageBox::showAsync(
+      mainWindow,
+      "配置已经保存成功！",
+      "提示",
+      StellarX::MessageBoxType::OK,
+      [](StellarX::MessageBoxResult result) {
+          // 这里可以根据用户点击的按钮做后续处理
+          if (result == StellarX::MessageBoxResult::OK) {
+              // 用户确认了提示，可选地写日志等
+          }
+      }
+  );
+  
+  // 代码会继续往下执行，不会被阻塞
+  ```
\ No newline at end of file