// StellarX 星垣GUI框架 - 测试用例
//
// 当前阶段测试入口说明（2026-04）：
// 1. KEY1：旧页签链路 + Table 超界残留回归
//    - 目标：验证 TabControl 重复激活同一页签、切页、关页后的快照/清理链是否稳定。
//    - 预期：
//      * 外部重复激活当前页签，不再扰动已激活页的快照链。
//      * 页签 1 中 Table 超出页区域的部分，在切页或关闭页签时不会残留。
//      * 触发正常全量重绘后，不应出现额外残影或层级错乱。
//
// 2. KEY2：公开布局 API 首个迁移样例
//    - 目标：验证新的 AxisSizePolicy / AxisAlignPolicy 公开接口在真实场景里可用。
//    - 预期：
//      * 32 位选择区中的“位号 + 位按钮”作为单元整体位移，窗口拉伸后保持对齐。
//      * 位按钮点击、位取反、左移、右移、一键置 0/1、签名切换，会统一刷新十六进制、
//        十进制、上次值、本次值和 initData。
//      * 顶层五个区块在正常拉伸/最大化后继续铺满窗口，不再依赖旧双锚点硬凑。
//      * 当前更偏重横向铺满验证；极窄窗口下功能区是否进一步自适应，不作为本阶段硬指标。
//
// 3. KEY3：旧业务大场景保留用例
//    - 目标：保留历史业务页示例，观察老场景在新主线下是否出现明显倒退。
//    - 预期：
//      * 登录页、TabControl、旧业务页基本行为保持可运行。
//      * 当前不作为本阶段主回归集，不要求覆盖新的布局 API 或 overlay 专项。
//
// 4. KEY4：Dialog / MessageBox 专项回归
//    - 目标：验证模态/非模态对话框、遮挡交互、关闭后 hover 恢复、拖拽 resize 等链路。
//    - 预期：
//      * 非模态 Dialog 遮挡底层按钮时，不应出现 hover/tooltip 穿透或残留。
//      * 模态 Dialog 打开后拖拽窗口，标题、关闭按钮和底层恢复链保持稳定。
//      * 对话框关闭后，底层按钮 hover 能及时恢复。
//    - 备注：当前它更适合作为 Dialog 专项补充，不纳入每轮主集。
//
// 5. KEY5：第二阶段专项主回归
//    - 目标：覆盖三层 Canvas、TabControl、Tooltip、overlay、Table、页码与分页按钮等主线风险点。
//    - 预期：
//      * 三层 Canvas 嵌套下，深层按钮的 hover / press / release / tooltip 都能正确刷新。
//      * Window / Canvas / TabControl 的 overlay 补画与 coverage 链闭合，不再出现遮挡错层。
//      * TabControl 页签按钮与页面层级正确；页签 tooltip 不会再被页面盖掉。
//      * Table 分页按钮、页码标签、与上层浮层相交时的重绘链保持正确。
//
// 6. KEY6：已实现但主回归未覆盖的枚举/分支补充
//    - 目标：补充 TabPlacement::Right、Button 圆/椭圆/禁用态、TextBox 圆角形状、
//      以及 YesNo / RetryCancel / AbortRetryIgnore 消息框类型。
//    - 预期：
//      * 右侧页签布局、切页、页内按钮和输入框正常。
//      * 圆形/椭圆按钮命中区域符合形状，禁用按钮不触发点击回调。
//      * 剩余 MessageBox 类型按钮结果链正常，非模态关闭不残留。
//
// 当前阶段建议主回归集：KEY1 + KEY2 + KEY5
// Dialog / MessageBox 补充专项：KEY4
// 实现分支补充专项：KEY6
#include"StellarX.h"
#include <vector>
#ifndef KEY
#define KEY 6
#endif

// 测试用例统一使用最新布局 API，避免继续依赖旧 setAnchor() 兼容层。
// 这些 helper 只服务 z-testDome：命名带 SxTest 前缀，避免被误认为框架公开接口。
static void SxTestSetDesignX(Control* control)
{
	if (!control) return;
	control->setHorizontalAnchors(false, false);
	control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
	control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
}

static void SxTestSetDesignY(Control* control)
{
	if (!control) return;
	control->setVerticalAnchors(false, false);
	control->setVerticalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
	control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::Start);
}

static void SxTestSetStretchX(Control* control)
{
	if (!control) return;
	control->setHorizontalAnchors(true, true);
	control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::Stretch);
	control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	SxTestSetDesignY(control);
}

static void SxTestSetLeftFixed(Control* control)
{
	if (!control) return;
	control->setHorizontalAnchors(true, false);
	control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
	control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	SxTestSetDesignY(control);
}

static void SxTestSetRightFixed(Control* control)
{
	if (!control) return;
	control->setHorizontalAnchors(false, true);
	control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
	control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::End);
	SxTestSetDesignY(control);
}

static void SxTestSetTopFixed(Control* control)
{
	if (!control) return;
	SxTestSetDesignX(control);
	control->setVerticalAnchors(true, false);
	control->setVerticalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
	control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::Start);
}

static void SxTestSetBottomFixed(Control* control)
{
	if (!control) return;
	SxTestSetDesignX(control);
	control->setVerticalAnchors(false, true);
	control->setVerticalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
	control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::End);
}

static void SxTestSetStretchY(Control* control)
{
	if (!control) return;
	SxTestSetDesignX(control);
	control->setVerticalAnchors(true, true);
	control->setVerticalSizePolicy(StellarX::AxisSizePolicy::Stretch);
	control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::Start);
}

#if 6 == KEY

int main()
{
	StellarX::SxLogger::setGBK();
	StellarX::SxLogger::Get().enableConsole(true);
	StellarX::SxLogger::Get().setMinLevel(StellarX::SxLogLevel::Debug);
	StellarX::SxLogger::Get().setLanguage(StellarX::SxLogLanguage::ZhCN);

	Window win(1120, 760, 1, RGB(246, 248, 251), "StellarX KEY6 分支覆盖补充");

	const COLORREF panelColor = RGB(230, 238, 248);
	const COLORREF shapeColor = RGB(244, 235, 218);
	const COLORREF tabColor = RGB(226, 242, 235);
	const COLORREF msgColor = RGB(240, 229, 245);
	const COLORREF hoverColor = RGB(255, 225, 92);
	const COLORREF trueColor = RGB(238, 142, 104);
	const COLORREF falseColor = RGB(247, 248, 250);

	auto configureButton = [&](Button* button, const std::string& tooltip)
		{
			button->enableTooltip(true);
			button->setTooltipDelay(120);
			button->setTooltipText(tooltip);
		};

	auto makeButton = [&](int x, int y, int w, int h, const std::string& text)
		{
			auto button = std::make_unique<Button>(x, y, w, h, text, trueColor, falseColor, hoverColor);
			configureButton(button.get(), text);
			return button;
		};

	auto header = std::make_unique<Canvas>(20, 20, 1080, 82);
	auto headerPtr = header.get();
	headerPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	headerPtr->setCanvasBkColor(panelColor);
	SxTestSetStretchX(headerPtr);

	auto title = std::make_unique<Label>(18, 10, "KEY6：已实现但主回归未覆盖的分支补充");
	title->textStyle.nHeight = 26;
	title->setDirty(true);
	title->setTextdisap(true);
	auto hint = std::make_unique<Label>(18, 48, "覆盖：Right 页签、圆/椭圆按钮命中、DISABLED 按钮、圆角 TextBox、剩余 MessageBox 类型");
	hint->setTextdisap(true);
	headerPtr->addControl(std::move(title));
	headerPtr->addControl(std::move(hint));

	auto shapePanel = std::make_unique<Canvas>(20, 120, 470, 270);
	auto shapePanelPtr = shapePanel.get();
	shapePanelPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	shapePanelPtr->setCanvasBkColor(shapeColor);
	SxTestSetLeftFixed(shapePanelPtr);

	auto statusLabel = std::make_unique<Label>(18, 226, "状态：等待交互");
	auto statusLabelPtr = statusLabel.get();
	statusLabelPtr->setTextdisap(true);

	auto shapeTitle = std::make_unique<Label>(18, 14, "A：Button 形状与禁用态");
	shapeTitle->setTextdisap(true);
	auto shapeHint = std::make_unique<Label>(18, 40, "圆/椭圆按钮需要按形状命中；禁用按钮不应触发回调。");
	shapeHint->setTextdisap(true);

	auto circleButton = makeButton(30, 78, 72, 72, "圆");
	circleButton->setButtonShape(StellarX::ControlShape::CIRCLE);
	circleButton->setOnClickListener([statusLabelPtr]()
		{
			statusLabelPtr->setText("状态：有边框圆形按钮被点击");
		});

	auto solidCircleButton = makeButton(132, 78, 72, 72, "无边圆");
	solidCircleButton->setButtonShape(StellarX::ControlShape::B_CIRCLE);
	solidCircleButton->setOnClickListener([statusLabelPtr]()
		{
			statusLabelPtr->setText("状态：无边框圆形按钮被点击");
		});

	auto ellipseButton = makeButton(234, 84, 116, 58, "椭圆");
	ellipseButton->setButtonShape(StellarX::ControlShape::ELLIPSE);
	ellipseButton->setOnClickListener([statusLabelPtr]()
		{
			statusLabelPtr->setText("状态：有边框椭圆按钮被点击");
		});

	auto solidEllipseButton = makeButton(30, 164, 116, 50, "无边椭圆");
	solidEllipseButton->setButtonShape(StellarX::ControlShape::B_ELLIPSE);
	solidEllipseButton->setOnClickListener([statusLabelPtr]()
		{
			statusLabelPtr->setText("状态：无边框椭圆按钮被点击");
		});

	auto disabledButton = std::make_unique<Button>(176, 164, 116, 50, "禁用", StellarX::ButtonMode::DISABLED, StellarX::ControlShape::ROUND_RECTANGLE);
	configureButton(disabledButton.get(), "禁用按钮：应只显示禁用态，不触发点击");
	disabledButton->setOnClickListener([statusLabelPtr]()
		{
			statusLabelPtr->setText("状态：BUG，禁用按钮触发了点击");
		});

	shapePanelPtr->addControl(std::move(shapeTitle));
	shapePanelPtr->addControl(std::move(shapeHint));
	shapePanelPtr->addControl(std::move(circleButton));
	shapePanelPtr->addControl(std::move(solidCircleButton));
	shapePanelPtr->addControl(std::move(ellipseButton));
	shapePanelPtr->addControl(std::move(solidEllipseButton));
	shapePanelPtr->addControl(std::move(disabledButton));
	shapePanelPtr->addControl(std::move(statusLabel));

	auto tabPanel = std::make_unique<Canvas>(520, 120, 580, 270);
	auto tabPanelPtr = tabPanel.get();
	tabPanelPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabPanelPtr->setCanvasBkColor(tabColor);
	SxTestSetStretchX(tabPanelPtr);

	auto tabTitle = std::make_unique<Label>(18, 14, "B：TabPlacement::Right");
	tabTitle->setTextdisap(true);
	auto tabHint = std::make_unique<Label>(18, 40, "右侧页签栏应稳定，页面区宽度应扣除页签栏。");
	tabHint->setTextdisap(true);

	auto rightTabs = std::make_unique<TabControl>(18, 72, 542, 172);
	auto rightTabsPtr = rightTabs.get();
	rightTabsPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	rightTabsPtr->setCanvasfillMode(StellarX::FillMode::Null);
	rightTabsPtr->setTabPlacement(StellarX::TabPlacement::Right);
	rightTabsPtr->setTabBarHeight(76);
	SxTestSetStretchX(rightTabsPtr);

	auto rightPage1 = std::make_unique<Canvas>(0, 0, 466, 172);
	rightPage1->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	rightPage1->setCanvasBkColor(RGB(240, 248, 255));
	auto rightPage1Ptr = rightPage1.get();
	auto rightPage1Label = std::make_unique<Label>(16, 18, "右侧页签页 1：按钮和圆角输入框");
	rightPage1Label->setTextdisap(true);
	auto rightPage1Button = makeButton(18, 58, 120, 34, "页内按钮");
	rightPage1Button->setOnClickListener([statusLabelPtr]()
		{
			statusLabelPtr->setText("状态：Right 页签页内按钮被点击");
		});
	auto roundInput = std::make_unique<TextBox>(160, 58, 260, 34, "圆角输入框", StellarX::TextBoxmode::INPUT_MODE, StellarX::ControlShape::ROUND_RECTANGLE);
	roundInput->setTextBoxshape(StellarX::ControlShape::ROUND_RECTANGLE);
	roundInput->setMaxCharLen(24);
	SxTestSetStretchX(roundInput.get());
	rightPage1Ptr->addControl(std::move(rightPage1Label));
	rightPage1Ptr->addControl(std::move(rightPage1Button));
	rightPage1Ptr->addControl(std::move(roundInput));

	auto rightPage2 = std::make_unique<Canvas>(0, 0, 466, 172);
	rightPage2->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	rightPage2->setCanvasBkColor(RGB(247, 244, 236));
	auto rightPage2Ptr = rightPage2.get();
	auto rightPage2Label = std::make_unique<Label>(16, 18, "右侧页签页 2：只读圆角 TextBox");
	rightPage2Label->setTextdisap(true);
	auto roundReadOnly = std::make_unique<TextBox>(18, 58, 380, 34, "只读圆角文本框", StellarX::TextBoxmode::READONLY_MODE, StellarX::ControlShape::B_ROUND_RECTANGLE);
	roundReadOnly->setTextBoxshape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	SxTestSetStretchX(roundReadOnly.get());
	rightPage2Ptr->addControl(std::move(rightPage2Label));
	rightPage2Ptr->addControl(std::move(roundReadOnly));

	rightTabsPtr->add(std::make_pair(std::make_unique<Button>(0, 0, 76, 34, "页一"), std::move(rightPage1)));
	rightTabsPtr->add(std::make_pair(std::make_unique<Button>(0, 0, 76, 34, "页二"), std::move(rightPage2)));
	rightTabsPtr->setActiveIndex(0);

	tabPanelPtr->addControl(std::move(tabTitle));
	tabPanelPtr->addControl(std::move(tabHint));
	tabPanelPtr->addControl(std::move(rightTabs));

	auto messagePanel = std::make_unique<Canvas>(20, 420, 1080, 250);
	auto messagePanelPtr = messagePanel.get();
	messagePanelPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	messagePanelPtr->setCanvasBkColor(msgColor);
	SxTestSetStretchX(messagePanelPtr);

	auto msgTitle = std::make_unique<Label>(18, 14, "C：剩余 MessageBox 类型");
	msgTitle->setTextdisap(true);
	auto msgHint = std::make_unique<Label>(18, 40, "分别打开 YesNo、RetryCancel、AbortRetryIgnore，观察按钮结果和关闭后 hover 恢复。");
	msgHint->setTextdisap(true);
	auto msgStatus = std::make_unique<Label>(18, 202, "消息框结果：等待操作");
	auto msgStatusPtr = msgStatus.get();
	msgStatus->setTextdisap(true);

	auto yesNoButton = makeButton(30, 92, 170, 44, "模态 YesNo");
	yesNoButton->setOnClickListener([&win, msgStatusPtr]()
		{
			auto result = StellarX::MessageBox::showModal(win, "KEY6：YesNo 分支验证", "KEY6 YesNo", StellarX::MessageBoxType::YesNo);
			msgStatusPtr->setText("消息框结果：YesNo -> " + std::to_string((int)result));
		});

	auto retryCancelButton = makeButton(230, 92, 190, 44, "模态 RetryCancel");
	retryCancelButton->setOnClickListener([&win, msgStatusPtr]()
		{
			auto result = StellarX::MessageBox::showModal(win, "KEY6：RetryCancel 分支验证", "KEY6 RetryCancel", StellarX::MessageBoxType::RetryCancel);
			msgStatusPtr->setText("消息框结果：RetryCancel -> " + std::to_string((int)result));
		});

	auto abortRetryIgnoreButton = makeButton(450, 92, 230, 44, "非模态 AbortRetryIgnore");
	abortRetryIgnoreButton->setOnClickListener([&win, msgStatusPtr]()
		{
			StellarX::MessageBox::showAsync(
				win,
				"KEY6：AbortRetryIgnore 非模态分支验证。\n关闭后检查底层按钮 hover / tooltip 是否恢复。",
				"KEY6 AbortRetryIgnore",
				StellarX::MessageBoxType::AbortRetryIgnore,
				[msgStatusPtr](StellarX::MessageBoxResult result)
				{
					msgStatusPtr->setText("消息框结果：AbortRetryIgnore -> " + std::to_string((int)result));
				});
		});

	messagePanelPtr->addControl(std::move(msgTitle));
	messagePanelPtr->addControl(std::move(msgHint));
	messagePanelPtr->addControl(std::move(yesNoButton));
	messagePanelPtr->addControl(std::move(retryCancelButton));
	messagePanelPtr->addControl(std::move(abortRetryIgnoreButton));
	messagePanelPtr->addControl(std::move(msgStatus));

	win.addControl(std::move(header));
	win.addControl(std::move(shapePanel));
	win.addControl(std::move(tabPanel));
	win.addControl(std::move(messagePanel));

	win.draw();
	return win.runEventLoop();
}

#endif

#if 5 == KEY

int main()
{
	StellarX::SxLogger::setGBK();
	StellarX::SxLogger::Get().enableConsole(true);
	StellarX::SxLogger::Get().setMinLevel(StellarX::SxLogLevel::Debug);
	StellarX::SxLogger::Get().setLanguage(StellarX::SxLogLanguage::ZhCN);

	const COLORREF headerColor = RGB(232, 238, 245);
	const COLORREF nestedZoneColor = RGB(217, 233, 252);
	const COLORREF level1Color = RGB(224, 244, 255);
	const COLORREF level2Color = RGB(222, 244, 228);
	const COLORREF level3Color = RGB(255, 239, 215);
	const COLORREF tabZoneColor = RGB(220, 241, 240);
	const COLORREF behaviorZoneColor = RGB(243, 238, 214);
	const COLORREF overlayZoneColor = RGB(255, 228, 206);
	const COLORREF tableZoneColor = RGB(235, 226, 250);
	const COLORREF floatingColor = RGB(249, 224, 232);
	const COLORREF buttonFalseColor = RGB(246, 247, 249);
	const COLORREF buttonHoverColor = RGB(255, 225, 92);
	const COLORREF buttonTrueColor = RGB(236, 138, 88);

	Window win(1380, 880, 1, RGB(246, 248, 251), "StellarX KEY5 第二阶段专项回归");

	auto configureTooltip = [](Button* button, const std::string& text)
		{
			button->enableTooltip(true);
			button->setTooltipDelay(120);
			button->setTooltipText(text);
		};
	auto makeTestButton = [&](int x, int y, int width, int height, const std::string& text)
		{
			auto button = std::make_unique<Button>(x, y, width, height, text, buttonTrueColor, buttonFalseColor, buttonHoverColor);
			configureTooltip(button.get(), text);
			return button;
		};

	auto header = std::make_unique<Canvas>(20, 20, 1340, 90);
	auto headerPtr = header.get();
	headerPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	headerPtr->setCanvasBkColor(headerColor);
	SxTestSetStretchX(headerPtr);

	auto headerTitle = std::make_unique<Label>(18, 8, "KEY5：第二阶段专项回归");
	headerTitle->textStyle.nHeight = 26;
	headerTitle->setDirty(true);
	headerTitle->setTextdisap(true);
	auto headerLine1 = std::make_unique<Label>(18, 44, "A 三层嵌套  B TabControl  C Label/跨容器 hover  D 同父 overlay  E Table/顶层浮层");
	headerLine1->setTextdisap(true);
	auto headerLine2 = std::make_unique<Label>(18, 64, "重点看：stretch、父局部到世界坐标、tooltip 清理、overlay 补画、分页按钮与页码");
	headerLine2->setTextdisap(true);
	headerPtr->addControl(std::move(headerTitle));
	headerPtr->addControl(std::move(headerLine1));
	headerPtr->addControl(std::move(headerLine2));

	auto nestedZone = std::make_unique<Canvas>(20, 130, 650, 280);
	auto nestedZonePtr = nestedZone.get();
	nestedZonePtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	nestedZonePtr->setCanvasBkColor(nestedZoneColor);
	SxTestSetStretchX(nestedZonePtr);

	auto nestedTitle = std::make_unique<Label>(16, 16, "A 蓝：三层 Canvas 嵌套");
	nestedTitle->setTextdisap(true);
	auto nestedHint = std::make_unique<Label>(16, 40, "看父局部到世界坐标链。");
	nestedHint->setTextdisap(true);

	auto nestedLeftBtn = makeTestButton(20, 74, 110, 34, "左固定");
	SxTestSetLeftFixed(nestedLeftBtn.get());

	auto nestedStretchBox = std::make_unique<TextBox>(150, 74, 350, 34, "A 区横向拉伸输入框");
	SxTestSetStretchX(nestedStretchBox.get());

	auto nestedRightBtn = makeTestButton(520, 74, 110, 34, "右固定");
	SxTestSetRightFixed(nestedRightBtn.get());

	auto level1 = std::make_unique<Canvas>(18, 126, 614, 134);
	auto level1Ptr = level1.get();
	level1Ptr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	level1Ptr->setCanvasBkColor(level1Color);
	SxTestSetStretchX(level1Ptr);

	auto level1Title = std::make_unique<Label>(14, 10, "A-1 青：第一层");
	level1Title->setTextdisap(true);
	auto level1Btn = makeTestButton(18, 42, 110, 30, "内层左");
	SxTestSetLeftFixed(level1Btn.get());

	auto level2 = std::make_unique<Canvas>(142, 36, 454, 84);
	auto level2Ptr = level2.get();
	level2Ptr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	level2Ptr->setCanvasBkColor(level2Color);
	SxTestSetStretchX(level2Ptr);

	auto level2Title = std::make_unique<Label>(12, 8, "A-2 绿：第二层");
	level2Title->setTextdisap(true);
	auto level2Btn = makeTestButton(332, 8, 108, 28, "右固定");
	SxTestSetRightFixed(level2Btn.get());

	auto level3 = std::make_unique<Canvas>(16, 42, 422, 28);
	auto level3Ptr = level3.get();
	level3Ptr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	level3Ptr->setCanvasBkColor(level3Color);
	SxTestSetStretchX(level3Ptr);

	auto level3Label = std::make_unique<Label>(10, 6, "A-3 橙：第三层");
	level3Label->setTextdisap(true);
	auto level3Btn = makeTestButton(312, 2, 98, 24, "右按钮");
	SxTestSetRightFixed(level3Btn.get());
	configureTooltip(level3Btn.get(), "第三层 Canvas 里的右固定按钮");

	level3Ptr->addControl(std::move(level3Label));
	level3Ptr->addControl(std::move(level3Btn));
	level2Ptr->addControl(std::move(level2Title));
	level2Ptr->addControl(std::move(level2Btn));
	level2Ptr->addControl(std::move(level3));
	level1Ptr->addControl(std::move(level1Title));
	level1Ptr->addControl(std::move(level1Btn));
	level1Ptr->addControl(std::move(level2));

	nestedZonePtr->addControl(std::move(nestedTitle));
	nestedZonePtr->addControl(std::move(nestedHint));
	nestedZonePtr->addControl(std::move(nestedLeftBtn));
	nestedZonePtr->addControl(std::move(nestedStretchBox));
	nestedZonePtr->addControl(std::move(nestedRightBtn));
	nestedZonePtr->addControl(std::move(level1));

	auto tabZone = std::make_unique<Canvas>(690, 130, 670, 280);
	auto tabZonePtr = tabZone.get();
	tabZonePtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabZonePtr->setCanvasBkColor(tabZoneColor);
	SxTestSetRightFixed(tabZonePtr);

	auto tabTitle = std::make_unique<Label>(16, 16, "B 青：TabControl 外层 resize");
	tabTitle->setTextdisap(true);
	auto tabHint = std::make_unique<Label>(16, 40, "看页签、页面和页内控件。");
	tabHint->setTextdisap(true);

	auto tabControl = std::make_unique<TabControl>(18, 60, 634, 200);
	auto tabControlPtr = tabControl.get();
	tabControlPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabControlPtr->setCanvasfillMode(StellarX::FillMode::Null);
	tabControlPtr->setTabPlacement(StellarX::TabPlacement::Top);
	tabControlPtr->setTabBarHeight(30);
	SxTestSetStretchX(tabControlPtr);

	auto tabPage1 = std::make_unique<Canvas>(0, 0, 634, 170);
	auto tabPage1Ptr = tabPage1.get();
	tabPage1Ptr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabPage1Ptr->setCanvasBkColor(RGB(241, 247, 255));

	auto tabPage2 = std::make_unique<Canvas>(0, 0, 634, 170);
	auto tabPage2Ptr = tabPage2.get();
	tabPage2Ptr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabPage2Ptr->setCanvasBkColor(RGB(248, 244, 236));

	auto page1Label = std::make_unique<Label>(14, 12, "页 1：页内 TextBox 继续由 Canvas 管。");
	page1Label->setTextdisap(true);
	auto page1Box = std::make_unique<TextBox>(18, 44, 468, 34, "页 1 左右拉伸输入框");
	SxTestSetStretchX(page1Box.get());
	auto page1Btn = makeTestButton(504, 44, 96, 34, "右固定");
	SxTestSetRightFixed(page1Btn.get());
	configureTooltip(page1Btn.get(), "页 1 右固定按钮");

	auto page1InnerCanvas = std::make_unique<Canvas>(18, 92, 582, 56);
	auto page1InnerCanvasPtr = page1InnerCanvas.get();
	page1InnerCanvasPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	page1InnerCanvasPtr->setCanvasBkColor(RGB(223, 236, 248));
	SxTestSetStretchX(page1InnerCanvasPtr);

	auto page1InnerLabel = std::make_unique<Label>(10, 8, "页 1 内层 Canvas");
	page1InnerLabel->setTextdisap(true);
	auto page1InnerBtn = makeTestButton(462, 14, 108, 28, "右按钮");
	SxTestSetRightFixed(page1InnerBtn.get());
	configureTooltip(page1InnerBtn.get(), "页 1 内层 Canvas 按钮");

	page1InnerCanvasPtr->addControl(std::move(page1InnerLabel));
	page1InnerCanvasPtr->addControl(std::move(page1InnerBtn));
	tabPage1Ptr->addControl(std::move(page1Label));
	tabPage1Ptr->addControl(std::move(page1Box));
	tabPage1Ptr->addControl(std::move(page1Btn));
	tabPage1Ptr->addControl(std::move(page1InnerCanvas));

	auto page2Label = std::make_unique<Label>(14, 12, "页 2：切页后继续测 hover 和 resize。");
	page2Label->setTextdisap(true);
	auto page2Btn = makeTestButton(18, 44, 126, 34, "Tooltip 按钮");
	configureTooltip(page2Btn.get(), "页 2 普通按钮 Tooltip");

	auto page2InnerCanvas = std::make_unique<Canvas>(166, 36, 434, 84);
	auto page2InnerCanvasPtr = page2InnerCanvas.get();
	page2InnerCanvasPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	page2InnerCanvasPtr->setCanvasBkColor(RGB(235, 229, 214));

	auto page2InnerLabel = std::make_unique<Label>(10, 8, "页 2 内层 Canvas");
	page2InnerLabel->setTextdisap(true);
	auto page2InnerBtn = makeTestButton(286, 42, 126, 28, "右侧 Tooltip");
	SxTestSetRightFixed(page2InnerBtn.get());
	configureTooltip(page2InnerBtn.get(), "页 2 内层按钮 Tooltip");

	page2InnerCanvasPtr->addControl(std::move(page2InnerLabel));
	page2InnerCanvasPtr->addControl(std::move(page2InnerBtn));
	tabPage2Ptr->addControl(std::move(page2Label));
	tabPage2Ptr->addControl(std::move(page2Btn));
	tabPage2Ptr->addControl(std::move(page2InnerCanvas));

	auto tabBtn1 = std::make_unique<Button>(0, 0, 108, 30, "布局页");
	auto tabBtn2 = std::make_unique<Button>(0, 0, 108, 30, "交互页");
	configureTooltip(tabBtn1.get(), "布局页页签按钮");
	configureTooltip(tabBtn2.get(), "交互页页签按钮");
	tabControlPtr->add(std::make_pair(std::move(tabBtn1), std::move(tabPage1)));
	tabControlPtr->add(std::make_pair(std::move(tabBtn2), std::move(tabPage2)));
	tabControlPtr->setActiveIndex(0);

	tabZonePtr->addControl(std::move(tabTitle));
	tabZonePtr->addControl(std::move(tabHint));
	tabZonePtr->addControl(std::move(tabControl));

	auto behaviorZone = std::make_unique<Canvas>(20, 430, 650, 190);
	auto behaviorZonePtr = behaviorZone.get();
	behaviorZonePtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	behaviorZonePtr->setCanvasBkColor(behaviorZoneColor);

	auto behaviorTitle = std::make_unique<Label>(16, 16, "C 米：Label 内容驱动 + 跨容器 hover");
	behaviorTitle->setTextdisap(true);

	auto dynamicLabel = std::make_unique<Label>(20, 52, "动态标签：默认短文本");
	auto dynamicLabelPtr = dynamicLabel.get();
	dynamicLabelPtr->textStyle.nHeight = 22;
	dynamicLabelPtr->setDirty(true);
	dynamicLabelPtr->setTextdisap(true);

	auto behaviorHint = std::make_unique<Label>(20, 82, "改样式后会手动 setDirty(true)。");
	behaviorHint->setTextdisap(true);

	std::vector<std::string> labelTexts =
	{
		"动态标签：默认短文本",
		"动态标签：切到更长一点的文本",
		"动态标签：短"
	};
	int labelIndex = 0;
	bool styleToggle = false;

	auto changeTextBtn = makeTestButton(20, 120, 120, 34, "改文本");
	auto changeStyleBtn = makeTestButton(156, 120, 150, 34, "改样式");
	changeTextBtn->setOnClickListener([&]()
		{
			labelIndex = (labelIndex + 1) % static_cast<int>(labelTexts.size());
			dynamicLabelPtr->setText(labelTexts[labelIndex]);
		});
	changeStyleBtn->setOnClickListener([&]()
		{
			styleToggle = !styleToggle;
			dynamicLabelPtr->textStyle.nHeight = styleToggle ? 30 : 22;
			dynamicLabelPtr->textStyle.color = styleToggle ? RGB(184, 87, 44) : RGB(0, 0, 0);
			dynamicLabelPtr->setDirty(true);
		});

	auto innerHoverBtn = makeTestButton(506, 120, 118, 34, "容器内按钮");
	SxTestSetRightFixed(innerHoverBtn.get());
	configureTooltip(innerHoverBtn.get(), "Canvas 内按钮 Tooltip");

	behaviorZonePtr->addControl(std::move(behaviorTitle));
	behaviorZonePtr->addControl(std::move(dynamicLabel));
	behaviorZonePtr->addControl(std::move(behaviorHint));
	behaviorZonePtr->addControl(std::move(changeTextBtn));
	behaviorZonePtr->addControl(std::move(changeStyleBtn));
	behaviorZonePtr->addControl(std::move(innerHoverBtn));

	auto overlayZone = std::make_unique<Canvas>(690, 430, 670, 190);
	auto overlayZonePtr = overlayZone.get();
	overlayZonePtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	overlayZonePtr->setCanvasBkColor(overlayZoneColor);
	SxTestSetStretchX(overlayZonePtr);

	auto overlayTitle = std::make_unique<Label>(16, 16, "D 橙：Top+Bottom + 同父 overlay");
	overlayTitle->setTextdisap(true);

	auto lowerLayer = std::make_unique<Canvas>(20, 56, 356, 104);
	auto lowerLayerPtr = lowerLayer.get();
	lowerLayerPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	lowerLayerPtr->setCanvasBkColor(RGB(255, 245, 231));
	SxTestSetStretchY(lowerLayerPtr);

	auto lowerTitle = std::make_unique<Label>(12, 8, "D-1 下层区");
	lowerTitle->setTextdisap(true);
	auto lowerBox = std::make_unique<TextBox>(12, 34, 222, 30, "下层区输入框");
	SxTestSetStretchX(lowerBox.get());
	auto lowerBtn = makeTestButton(248, 34, 92, 30, "下层按钮");
	SxTestSetRightFixed(lowerBtn.get());
	configureTooltip(lowerBtn.get(), "下层 Canvas 按钮");

	lowerLayerPtr->addControl(std::move(lowerTitle));
	lowerLayerPtr->addControl(std::move(lowerBox));
	lowerLayerPtr->addControl(std::move(lowerBtn));

	auto upperLayer = std::make_unique<Canvas>(262, 94, 382, 78);
	auto upperLayerPtr = upperLayer.get();
	upperLayerPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	upperLayerPtr->setCanvasBkColor(RGB(255, 224, 206));
	SxTestSetRightFixed(upperLayerPtr);

	auto upperTitle = std::make_unique<Label>(12, 8, "D-2 上层区");
	upperTitle->setTextdisap(true);
	auto upperBtn = makeTestButton(244, 38, 122, 28, "上层 Tooltip");
	SxTestSetRightFixed(upperBtn.get());
	configureTooltip(upperBtn.get(), "上层 Canvas 按钮");

	upperLayerPtr->addControl(std::move(upperTitle));
	upperLayerPtr->addControl(std::move(upperBtn));

	auto overlayBottomBtn = makeTestButton(526, 148, 118, 30, "底边固定");
	SxTestSetBottomFixed(overlayBottomBtn.get());

	overlayZonePtr->addControl(std::move(overlayTitle));
	overlayZonePtr->addControl(std::move(lowerLayer));
	overlayZonePtr->addControl(std::move(upperLayer));
	overlayZonePtr->addControl(std::move(overlayBottomBtn));

	auto tableZone = std::make_unique<Canvas>(20, 640, 980, 200);
	auto tableZonePtr = tableZone.get();
	tableZonePtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tableZonePtr->setCanvasBkColor(tableZoneColor);
	SxTestSetStretchX(tableZonePtr);

	auto tableTitle = std::make_unique<Label>(16, 12, "E 紫：Table 仅 X Stretch");
	tableTitle->setTextdisap(true);
	auto tableHint = std::make_unique<Label>(16, 34, "看翻页按钮、页码和顶层浮层补画。");
	tableHint->setTextdisap(true);

	auto table = std::make_unique<Table>(20, 62);
	auto tablePtr = table.get();
	tablePtr->setHeaders({ "编号", "回归点", "预期" });
	tablePtr->setData({
		{"01", "左右拉伸", "窗口变宽后列宽一起增大"},
		{"02", "分页按钮", "hover / click / leave 都能及时刷新"},
		{"03", "页码标签", "整表重绘后不会消失"},
		{"04", "顶层浮层", "下层重绘后上层还能补回来"}
		});
	tablePtr->setRowsPerPage(2);
	tablePtr->setTableBorderWidth(1);
	tablePtr->setTableBorder(RGB(86, 88, 132));
	SxTestSetStretchX(tablePtr);

	tableZonePtr->addControl(std::move(tableTitle));
	tableZonePtr->addControl(std::move(tableHint));
	tableZonePtr->addControl(std::move(table));

	auto topHoverBtn = makeTestButton(646, 550, 118, 34, "顶层按钮");
	configureTooltip(topHoverBtn.get(), "顶层按钮 Tooltip");

	auto floatingZone = std::make_unique<Canvas>(900, 702, 460, 138);
	auto floatingZonePtr = floatingZone.get();
	floatingZonePtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	floatingZonePtr->setCanvasBkColor(floatingColor);
	SxTestSetBottomFixed(floatingZonePtr);

	auto floatingTitle = std::make_unique<Label>(16, 12, "F 粉：Bottom only 浮层");
	floatingTitle->setTextdisap(true);
	auto floatingHint = std::make_unique<Label>(16, 36, "看 Table 下层重绘后的补画。");
	floatingHint->setTextdisap(true);
	auto floatingBtn = makeTestButton(322, 88, 118, 30, "右固定");
	SxTestSetRightFixed(floatingBtn.get());
	configureTooltip(floatingBtn.get(), "粉色浮层里的按钮");

	floatingZonePtr->addControl(std::move(floatingTitle));
	floatingZonePtr->addControl(std::move(floatingHint));
	floatingZonePtr->addControl(std::move(floatingBtn));

	win.addControl(std::move(header));
	win.addControl(std::move(nestedZone));
	win.addControl(std::move(tabZone));
	win.addControl(std::move(behaviorZone));
	win.addControl(std::move(topHoverBtn));
	win.addControl(std::move(overlayZone));
	win.addControl(std::move(tableZone));
	win.addControl(std::move(floatingZone));

	win.draw();
	return win.runEventLoop();
}

#endif

#if 1 == KEY
int main()
{
	//StellarX::SxLogger::setGBK();
	//StellarX::SxLogger::Get().enableFile("stellarx.log", false, 1024);
	StellarX::SxLogger::Get().enableConsole(true);
	StellarX::SxLogger::Get().setMinLevel(StellarX::SxLogLevel::Debug);   // Info/Debug/Trace 自己切
	StellarX::SxLogger::Get().setLanguage(StellarX::SxLogLanguage::ZhCN); // ZhCN / EnUS
	
	Window mainWindow(1200, 400, 1, RGB(255, 0, 0), "StellarX Hello");
	auto table = std::make_unique<Table>(200, 50);
	Table* table_ptr = table.get();
	table->setHeaders({ "name","age","seorc","home" });
	table->setData({
		{"zhangsan","20","99.99","wadsacafadsawd"},
		{"lisi","20","99.99","wadsacafadsawd"},
		{"wangwu","20","99.99","wadsacafadsawd"},
		{"zhaoliu","20","99.99","wadsacafadsawd"},
		{"1","20","99.99","wadsacafadsawd" },
		{"2","20","99.99","wadsacafadsawd" } ,
		{"3","20","99.99","wadsacafadsawd" } ,
		{"4","20","99.99","wadsacafadsawd" },
		{"5","20","99.99","wadsacafadsawd" } ,
		{"6","20","99.99","wadsacafadsawd" } ,
		{"7","20","99.99","wadsacvvvvvvv我afads" } ,
		{"8","2000000000000000000","99.999999999999","wadsacafa0000000d0000000sawd" } ,
		{"9555555555","2000","99.9999999","wadsacafadsawd" } });
	table->setRowsPerPage(4);
	table->setTableBorderWidth(1);
	table->textStyle.color = RGB(255, 0, 0);
	table->setTableBorder(RGB(255, 0, 0));
	table->setTableFillMode(StellarX::FillMode::Null);
	
	auto but = std::make_unique<Button>(0, 0, 100, 15, "按钮1");
	auto ta = std::make_unique<TabControl>(10, 10, 1100, 300);
	ta->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	ta->setActiveIndex(2);

	std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>> p;
	std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>> p1;
	std::pair<std::unique_ptr<Button>, std::unique_ptr<Canvas>> p2;
	p2.first = std::make_unique<Button>(0, 0, 100, 15, "按钮3");
	p2.second = std::make_unique<Canvas>(200, 200, 1100, 280);
	p2.second->setShape(StellarX::ControlShape::ROUND_RECTANGLE);

	p1.first = std::make_unique<Button>(0, 0, 100, 15, "按钮2");
	p1.second = std::make_unique<Canvas>(200, 200, 1100, 280);
	p1.second->setCanvasBkColor(RGB(255, 200, 0));
	p.first = std::move(but);
	p.second = std::make_unique<Canvas>(100, 100, 1100, 280);
	p.second->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	p.second->setCanvasBkColor(RGB(0, 255, 0));
	p.second->setCanvasfillMode(StellarX::FillMode::Null);
	auto table_get = table.get();
	p.second->addControl(std::move(table));
	ta->setTabPlacement(StellarX::TabPlacement::Bottom);

	auto b = std::make_unique<Button>(0, 0, 100, 35, "按钮");
	b->setOnClickListener([&]()
		{
			/*	StellarX::MessageBox::showAsync(mainWindow, "韦世豪大傻逼", "笑话", StellarX::MessageBoxType::AbortRetryIgnore,
			[](StellarX::MessageBoxResult result) { if (StellarX::MessageBoxResult::Retry == result)std::cout << "\a"; });
			*/
			table_ptr->clearHeaders();
			table_ptr->clearData();
			table_ptr->setHeaders({ "new_name","new_age","new_seorc","new""_home","new_test"});
			table_ptr->setData({
			{"new_zhangsan","30","88.88","new_wadsacafadsawd","123"},
			{"new_lisi","30","88.88","new_wadsacafadsawd","456"},
			{"new_wangwu","30","88.88","new_wadsacafadsawd","789"},
			{"new_zhaoliu","30","88.88","new_wadsacafadsawd","101"} });
			table_ptr->setData({"test_zhaoliu","test_30","88.88","test_wadsacafadsawd","test_101"});
				
				
		});
	p.second->addControl(std::move(b));
	ta->add(std::move(p));
	ta->add(std::move(p1));
	ta->add(std::move(p2));
	ta->setTabBarHeight(20);
	ta->setCanvasfillMode(StellarX::FillMode::Null);
	auto ta_ptr = ta.get();
	auto test = std::make_unique<Button>(1100, 350, 40, 40, "test");
	auto test_ptr = test.get();
	test->setOnClickListener([&]() 
		{
			ta_ptr->setActiveIndex(0);
		});
	//auto testTextBox = std::make_unique<TextBox>(100, 350, 80, 30);
	auto testTextBox = std::make_unique<TextBox>(0, 0, 80, 30);
	testTextBox->setText("hello");
	auto _123 = std::make_unique<Canvas>(100, 340, 180, 130);
	_123->addControl(std::move(testTextBox));
	_123->setCanvasfillMode(StellarX::FillMode::Null);
	
	mainWindow.addControl(std::move(ta));
	mainWindow.addControl(std::move(test));
	mainWindow.addControl(std::move(_123));

	mainWindow.draw("D:\\编程相关\\素材\\星垣logo.png");
	mainWindow.runEventLoop();
}
#endif

#if 4 == KEY

#include"StellarX.h"
#include <vector>

int main()
{
	StellarX::SxLogger::setGBK();
	StellarX::SxLogger::Get().enableConsole(true);
	StellarX::SxLogger::Get().setMinLevel(StellarX::SxLogLevel::Debug);
	StellarX::SxLogger::Get().setLanguage(StellarX::SxLogLanguage::ZhCN);

	Window win(1280, 780, 1, RGB(242, 246, 250), "StellarX 综合回归测试用例 4");

	auto infoPanel = std::make_unique<Canvas>(20, 20, 1240, 90);
	auto infoPanelPtr = infoPanel.get();
	infoPanelPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	infoPanelPtr->setCanvasBkColor(RGB(225, 234, 244));
	SxTestSetStretchX(infoPanelPtr);

	auto infoTitle = std::make_unique<Label>(20, 10, "综合回归测试 4：对话框遮挡、快速 Hover、分页按钮、模态 Resize");
	infoTitle->textStyle.nHeight = 26;
	infoTitle->setTextdisap(true);
	auto infoLine1 = std::make_unique<Label>(20, 42, "1. 点击右侧按钮打开非模态/模态对话框；2. 在顶部按钮、页签、分页按钮附近快速划动光标。");
	infoLine1->setTextdisap(true);
	auto infoLine2 = std::make_unique<Label>(20, 62, "3. 模态对话框打开后拖动窗口大小；4. 关闭对话框后观察底层按钮 Hover 是否立即恢复。");
	infoLine2->setTextdisap(true);

	auto openAsyncButton = std::make_unique<Button>(930, 22, 130, 42, "打开非模态");
	auto openAsyncButtonPtr = openAsyncButton.get();
	openAsyncButtonPtr->enableTooltip(true);
	openAsyncButtonPtr->setTooltipText("打开长文本非模态对话框，覆盖顶部按钮 / 页签 / 分页区");

	auto openModalButton = std::make_unique<Button>(1080, 22, 130, 42, "打开模态");
	auto openModalButtonPtr = openModalButton.get();
	openModalButtonPtr->enableTooltip(true);
	openModalButtonPtr->setTooltipText("打开模态对话框并测试拖拽窗口后的重绘与关闭");

	infoPanelPtr->addControl(std::move(infoTitle));
	infoPanelPtr->addControl(std::move(infoLine1));
	infoPanelPtr->addControl(std::move(infoLine2));
	infoPanelPtr->addControl(std::move(openAsyncButton));
	infoPanelPtr->addControl(std::move(openModalButton));

	auto hoverCanvas = std::make_unique<Canvas>(20, 140, 1240, 100);
	auto hoverCanvasPtr = hoverCanvas.get();
	hoverCanvasPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	hoverCanvasPtr->setCanvasBkColor(RGB(230, 238, 248));
	SxTestSetStretchX(hoverCanvasPtr);

	auto hoverTitle = std::make_unique<Label>(20, 8, "区域 A：打开非模态对话框后，请在下面 8 个按钮之间快速来回划动鼠标。");
	hoverTitle->setTextdisap(true);
	hoverCanvasPtr->addControl(std::move(hoverTitle));

	for (int i = 0; i < 8; ++i)
	{
		auto hoverButton = std::make_unique<Button>(250 + i * 92, 38, 72, 38, "B" + std::to_string(i + 1));
		hoverButton->enableTooltip(true);
		hoverButton->setTooltipText("顶部 Hover 按钮 " + std::to_string(i + 1));
		hoverButton->setButtonShape(StellarX::ControlShape::B_RECTANGLE);
		hoverCanvasPtr->addControl(std::move(hoverButton));
	}

	auto tabControl = std::make_unique<TabControl>(120, 260, 1040, 180);
	auto tabControlPtr = tabControl.get();
	tabControlPtr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabControlPtr->setCanvasfillMode(StellarX::FillMode::Null);
	tabControlPtr->setTabPlacement(StellarX::TabPlacement::Top);
	tabControlPtr->setTabBarHeight(28);
	SxTestSetStretchX(tabControlPtr);

	auto page1 = std::make_unique<Canvas>(0, 0, 1040, 152);
	page1->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	page1->setCanvasBkColor(RGB(246, 250, 255));
	auto page2 = std::make_unique<Canvas>(0, 0, 1040, 152);
	page2->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	page2->setCanvasBkColor(RGB(250, 248, 242));
	auto page3 = std::make_unique<Canvas>(0, 0, 1040, 152);
	page3->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	page3->setCanvasBkColor(RGB(243, 250, 244));

	auto tabPage1Ptr = page1.get();
	auto tabPage2Ptr = page2.get();
	auto tabPage3Ptr = page3.get();

	tabControlPtr->add(std::make_pair(std::make_unique<Button>(0, 0, 120, 28, "页签-事件区"), std::move(page1)));
	tabControlPtr->add(std::make_pair(std::make_unique<Button>(0, 0, 120, 28, "页签-空白区"), std::move(page2)));
	tabControlPtr->add(std::make_pair(std::make_unique<Button>(0, 0, 120, 28, "页签-辅助区"), std::move(page3)));
	tabControlPtr->setActiveIndex(0);

	auto page1Label = std::make_unique<Label>(20, 10, "区域 B：打开非模态对话框后，切换页签并在页内按钮上快速 Hover。");
	page1Label->setTextdisap(true);
	tabPage1Ptr->addControl(std::move(page1Label));
	for (int i = 0; i < 4; ++i)
	{
		auto pageButton = std::make_unique<Button>(190 + i * 150, 55, 110, 38, "页内按钮" + std::to_string(i + 1));
		pageButton->enableTooltip(true);
		pageButton->setTooltipText("页签区按钮 " + std::to_string(i + 1));
		tabPage1Ptr->addControl(std::move(pageButton));
	}

	auto page2Label = std::make_unique<Label>(30, 55, "区域 B-2：此页保留较大空白区，用来观察 Hover 离开空白区域时的恢复。");
	page2Label->setTextdisap(true);
	tabPage2Ptr->addControl(std::move(page2Label));

	auto page3Label = std::make_unique<Label>(20, 18, "区域 B-3：辅助页，用来测试页签切换本身的重绘是否稳定。");
	page3Label->setTextdisap(true);
	auto page3Button = std::make_unique<Button>(420, 65, 180, 40, "辅助按钮");
	page3Button->enableTooltip(true);
	page3Button->setTooltipText("辅助页按钮 Tooltip");
	tabPage3Ptr->addControl(std::move(page3Label));
	tabPage3Ptr->addControl(std::move(page3Button));

	auto table = std::make_unique<Table>(240, 470);
	auto tablePtr = table.get();
	tablePtr->setHeaders({ "编号", "名称", "状态", "备注" });
	tablePtr->setData({
		{"01", "顶部按钮覆盖测试", "待验证", "快速 Hover 后不能残留高亮"},
		{"02", "页签切换测试", "待验证", "页签按钮与页内容不应穿透"},
		{"03", "分页按钮测试", "待验证", "被非模态部分覆盖时仍应稳定"},
		{"04", "模态 Resize 测试", "待验证", "拖窗后标题、关闭按钮不应残影"},
		{"05", "关闭后 Hover 恢复", "待验证", "模态关闭后底层按钮 Hover 应恢复"}
		});
	tablePtr->setRowsPerPage(2);
	tablePtr->setTableBorderWidth(1);
	tablePtr->setTableBorder(RGB(60, 90, 120));
	tablePtr->setTableFillMode(StellarX::FillMode::Null);
	SxTestSetStretchX(tablePtr);

	const std::string asyncText =
		"KEY4 非模态回归测试正在进行。\n"
		"请依次检查以下场景：\n"
		"1. 在顶部按钮之间快速来回移动鼠标。\n"
		"2. 切换页签，并在页签按钮与页内按钮上快速 Hover。\n"
		"3. 将鼠标移动到表格分页按钮附近，观察是否闪烁或穿透。\n"
		"4. 将鼠标移出窗口后再移回窗口。\n"
		"5. 保持本对话框打开，确认它始终位于最上层。\n"
		"6. 若需要重复测试，可直接再次点击右上角按钮。\n"
		"7. 本对话框故意较高，以覆盖顶部按钮、页签区与部分分页区。\n"
		"8. 顶部按钮区域用于检测快速 Hover 残留。\n"
		"9. 页签区域用于检测被遮挡时的切换与 Hover。\n"
		"10. 表格分页区用于检测分页按钮被部分覆盖时的重绘。\n"
		"11. 若关闭本对话框，请观察底层 Hover 是否立即恢复。\n"
		"12. 本消息框保留较多行，是为了增大对遮挡场景的覆盖范围。";

	const std::string modalText =
		"KEY4 模态回归测试。\n"
		"请在本对话框保持打开时执行：\n"
		"1. 拖拽窗口大小，观察标题、关闭按钮与功能按钮是否残影。\n"
		"2. 拖拽后点击关闭按钮。\n"
		"3. 拖拽后点击功能按钮。\n"
		"4. 对话框关闭后，将鼠标停在底层顶部按钮上，观察 Hover 是否恢复。";

	openAsyncButtonPtr->setOnClickListener([&win, asyncText]()
		{
			StellarX::MessageBox::showAsync(
				win,
				asyncText,
				"KEY4 非模态综合回归",
				StellarX::MessageBoxType::YesNoCancel,
				[](StellarX::MessageBoxResult result)
				{
					SX_LOGI("KEY4") << "非模态对话框结果=" << (int)result;
				});
		});

	openModalButtonPtr->setOnClickListener([&win, modalText]()
		{
			auto result = StellarX::MessageBox::showModal(
				win,
				modalText,
				"KEY4 模态综合回归",
				StellarX::MessageBoxType::OKCancel);
			SX_LOGI("KEY4") << "模态对话框结果=" << (int)result;
		});

	win.addControl(std::move(infoPanel));
	win.addControl(std::move(hoverCanvas));
	win.addControl(std::move(tabControl));
	win.addControl(std::move(table));

	win.draw();
	return win.runEventLoop();
}

#endif

#if 2 == KEY
// 本工具基于 StellarX 构建，轻量级的 Windows GUI 框架。
#include"StellarX.h"
#include <sstream>
#include<iomanip>
#include<array>

auto   blackColor = RGB(202, 255, 255);
char initData[33] = "00000000000000000000000000000000";//初始数据
bool gSigned = false;      //是否为有符号数
int main()
{
	//StellarX::SxLogger::Get().enableConsole(true);
	StellarX::SxLogger::Get().enableFile("log.txt",true,1024);
	StellarX::SxLogger::Get().setMinLevel(StellarX::SxLogLevel::Debug);   // Info/Debug/Trace 自己切
	StellarX::SxLogger::Get().setLanguage(StellarX::SxLogLanguage::ZhCN); // ZhCN / EnUS

	Window mainWindow(700, 510, 1, RGB(255, 255, 255), "寄存器查看工具 V1.0——我在人间做废物                         (同类工具定制：3150131407(Q / V))");

	auto setStretchX = [](Control* control) {
		control->setHorizontalAnchors(true, true);
		control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::Stretch);
		control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	};
	auto setStretchY = [](Control* control) {
		control->setVerticalAnchors(true, true);
		control->setVerticalSizePolicy(StellarX::AxisSizePolicy::Stretch);
		control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	};
	auto setLeftFixed = [](Control* control) {
		control->setHorizontalAnchors(true, false);
		control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
		control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	};
	auto setRightFixed = [](Control* control) {
		control->setHorizontalAnchors(false, true);
		control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
		control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::End);
	};
	auto setCenterFixed = [](Control* control) {
		control->setHorizontalAnchors(true, true);
		control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
		control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Center);
	};
	auto setBottomFixed = [](Control* control) {
		control->setVerticalAnchors(false, true);
		control->setVerticalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
		control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::End);
	};
	auto setTopFixed = [](Control* control) {
		control->setVerticalAnchors(true, false);
		control->setVerticalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
		control->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	};
	auto setProportionalX = [](Control* control) {
		control->setHorizontalAnchors(true, true);
		control->setHorizontalSizePolicy(StellarX::AxisSizePolicy::FixedSize);
		control->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Proportional);
	};
	auto styleTitleLabel = [](Label* label) {
		label->setTextdisap(true);
	};
	auto styleActionButton = [&](Button* button) {
		button->textStyle.color = RGB(226, 116, 152);
		button->setButtonShape(StellarX::ControlShape::B_RECTANGLE);
	};
	auto styleInputBox = [&](TextBox* box, int maxChars) {
		box->setMaxCharLen(maxChars);
		box->textStyle.color = RGB(226, 116, 152);
		box->setTextBoxBk(RGB(244, 234, 142));
		box->setTextBoxshape(StellarX::ControlShape::B_RECTANGLE);
	};
	auto styleReadonlyBox = [&](TextBox* box, int maxChars) {
		box->setMaxCharLen(maxChars);
		box->textStyle.color = RGB(255, 69, 0);
		box->setTextBoxBk(RGB(141, 141, 141));
		box->setTextBoxshape(StellarX::ControlShape::B_RECTANGLE);
		box->setMode(StellarX::TextBoxmode::READONLY_MODE);
	};

	//选择区控件
	auto  selectionArea = std::make_unique <Canvas>(10, 10, 680, 150);
	selectionArea->setCanvasBkColor(blackColor);
	selectionArea->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	setStretchX(selectionArea.get());
	setTopFixed(selectionArea.get());

	auto selectionAreaLabel = std::make_unique<Label>(18, 0, "32位选择区");
	styleTitleLabel(selectionAreaLabel.get());
	setLeftFixed(selectionAreaLabel.get());

	auto topRow = std::make_unique<Canvas>(18, 24, 644, 54);
	topRow->setCanvasBkColor(blackColor);
	topRow->setShape(StellarX::ControlShape::B_RECTANGLE);
	setStretchX(topRow.get());
	setTopFixed(topRow.get());

	auto bottomRow = std::make_unique<Canvas>(18, 88, 644, 54);
	bottomRow->setCanvasBkColor(blackColor);
	bottomRow->setShape(StellarX::ControlShape::B_RECTANGLE);
	setStretchX(bottomRow.get());
	setBottomFixed(bottomRow.get());

	Canvas* topRowPtr = topRow.get();
	Canvas* bottomRowPtr = bottomRow.get();
	std::array<Button*, 32> selectionAreaButton_ptr{};

	auto vecIndexFromBit = [](int bit) { return 31 - bit; };
	auto makeBitCell = [&](Canvas* row, int visualIndex, int bit)
	{
		const int cellX = visualIndex * 38 + (visualIndex / 4) * 10;
		auto cell = std::make_unique<Canvas>(cellX, 0, 32, 50);
		cell->setCanvasBkColor(blackColor);
		cell->setShape(StellarX::ControlShape::B_RECTANGLE);
		setProportionalX(cell.get());

		std::ostringstream os;
		os << std::setw(2) << std::setfill('0') << bit;
		auto bitLabel = std::make_unique<Label>(bit >= 10 ? 8 : 12, 0, os.str(), RGB(208, 208, 208));
		bitLabel->setTextdisap(true);

		auto bitButton = std::make_unique<Button>(3, 20, 26, 28, "0",
			blackColor, RGB(171, 196, 220), StellarX::ButtonMode::TOGGLE);
		styleActionButton(bitButton.get());
		selectionAreaButton_ptr[vecIndexFromBit(bit)] = bitButton.get();

		cell->addControl(std::move(bitLabel));
		cell->addControl(std::move(bitButton));
		row->addControl(std::move(cell));
	};

	for (int i = 0; i < 16; ++i)
		makeBitCell(topRowPtr, i, 31 - i);
	for (int i = 0; i < 16; ++i)
		makeBitCell(bottomRowPtr, i, 15 - i);

	selectionArea->addControl(std::move(selectionAreaLabel));
	selectionArea->addControl(std::move(topRow));
	selectionArea->addControl(std::move(bottomRow));
	//功能区控件
	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);
	setStretchX(function.get());
	setTopFixed(function.get());

	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);
	setLeftFixed(bitInvert_que.get());
	setCenterFixed(leftShift_que.get());
	setRightFixed(rightShift_que.get());

	auto bitInvert = bitInvert_que.get();
	auto leftShift = leftShift_que.get();
	auto rightShift = rightShift_que.get();

	bitInvert->setCanvasBkColor(blackColor);
	bitInvert->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	leftShift->setCanvasBkColor(blackColor);
	leftShift->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	rightShift->setCanvasBkColor(blackColor);
	rightShift->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);

	auto bitInvertLabel = std::make_unique<Label>(13, -10, "位取反");
	auto leftShiftLabel = std::make_unique<Label>(13, -10, "左移位");
	auto rightShiftLabel = std::make_unique<Label>(13, -10, "右移位");
	styleTitleLabel(bitInvertLabel.get());
	styleTitleLabel(leftShiftLabel.get());
	styleTitleLabel(rightShiftLabel.get());

	// 数值显示区
	auto NumericalDisplayArea = std::make_unique<Canvas>(10, 255, 680, 70);
	NumericalDisplayArea->setCanvasBkColor(blackColor);
	NumericalDisplayArea->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	setStretchX(NumericalDisplayArea.get());
	setTopFixed(NumericalDisplayArea.get());

	auto numericalTitle = std::make_unique<Label>(18, -10, "数值显示区");
	styleTitleLabel(numericalTitle.get());
	setLeftFixed(numericalTitle.get());

	auto hexGroup = std::make_unique<Canvas>(18, 20, 300, 38);
	hexGroup->setCanvasfillMode(StellarX::FillMode::Null);
	hexGroup->setShape(StellarX::ControlShape::B_RECTANGLE);
	setLeftFixed(hexGroup.get());

	auto decGroup = std::make_unique<Canvas>(362, 20, 300, 38);
	decGroup->setCanvasfillMode(StellarX::FillMode::Null);
	decGroup->setShape(StellarX::ControlShape::B_RECTANGLE);
	setRightFixed(decGroup.get());

	auto hexLabel = std::make_unique<Label>(0, 8, "十六进制");
	styleTitleLabel(hexLabel.get());
	auto decLabel = std::make_unique<Label>(0, 8, "十进制");
	styleTitleLabel(decLabel.get());

	auto hexBox = std::make_unique<TextBox>(86, 4, 204, 30, "00000000");
	auto decBox = std::make_unique<TextBox>(70, 4, 220, 30, "0");
	styleReadonlyBox(hexBox.get(), 11);
	styleReadonlyBox(decBox.get(), 11);
	auto hex = hexBox.get();
	auto dec = decBox.get();

	hexGroup->addControl(std::move(hexLabel));
	hexGroup->addControl(std::move(hexBox));
	decGroup->addControl(std::move(decLabel));
	decGroup->addControl(std::move(decBox));

	NumericalDisplayArea->addControl(std::move(numericalTitle));
	NumericalDisplayArea->addControl(std::move(hexGroup));
	NumericalDisplayArea->addControl(std::move(decGroup));

	// 二进制显示区
	auto BinaryDisplayArea = std::make_unique<Canvas>(10, 335, 680, 110);
	BinaryDisplayArea->setCanvasBkColor(blackColor);
	BinaryDisplayArea->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	setStretchX(BinaryDisplayArea.get());
	BinaryDisplayArea->setVerticalAnchors(true, true);
	BinaryDisplayArea->setVerticalSizePolicy(StellarX::AxisSizePolicy::Stretch);
	BinaryDisplayArea->setVerticalAlignPolicy(StellarX::AxisAlignPolicy::Start);

	auto binaryTitle = std::make_unique<Label>(18, -10, "二进制显示区");
	styleTitleLabel(binaryTitle.get());
	setLeftFixed(binaryTitle.get());

	auto lastRow = std::make_unique<Canvas>(18, 20, 644, 30);
	lastRow->setCanvasfillMode(StellarX::FillMode::Null);
	lastRow->setShape(StellarX::ControlShape::B_RECTANGLE);
	setStretchX(lastRow.get());
	setTopFixed(lastRow.get());

	auto thisRow = std::make_unique<Canvas>(18, 67, 644, 30);
	thisRow->setCanvasfillMode(StellarX::FillMode::Null);
	thisRow->setShape(StellarX::ControlShape::B_RECTANGLE);
	setStretchX(thisRow.get());
	setBottomFixed(thisRow.get());

	auto lastLabel = std::make_unique<Label>(0, 6, "上次值");
	auto thisLabel = std::make_unique<Label>(0, 6, "本次值");
	styleTitleLabel(lastLabel.get());
	styleTitleLabel(thisLabel.get());

	auto lastBox = std::make_unique<TextBox>(80, 0, 564, 30, "0000_0000_0000_0000_0000_0000_0000_0000");
	auto thisBox = std::make_unique<TextBox>(80, 0, 564, 30, "0000_0000_0000_0000_0000_0000_0000_0000");
	styleReadonlyBox(lastBox.get(), 40);
	styleReadonlyBox(thisBox.get(), 40);
	lastBox->setHorizontalAnchors(true, true);
	lastBox->setHorizontalSizePolicy(StellarX::AxisSizePolicy::Stretch);
	lastBox->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	thisBox->setHorizontalAnchors(true, true);
	thisBox->setHorizontalSizePolicy(StellarX::AxisSizePolicy::Stretch);
	thisBox->setHorizontalAlignPolicy(StellarX::AxisAlignPolicy::Start);
	auto Last = lastBox.get();
	auto This = thisBox.get();

	lastRow->addControl(std::move(lastLabel));
	lastRow->addControl(std::move(lastBox));
	thisRow->addControl(std::move(thisLabel));
	thisRow->addControl(std::move(thisBox));

	BinaryDisplayArea->addControl(std::move(binaryTitle));
	BinaryDisplayArea->addControl(std::move(lastRow));
	BinaryDisplayArea->addControl(std::move(thisRow));

	// 配置区
	auto configuration = std::make_unique<Canvas>(10, 455, 680, 40);
	configuration->setCanvasBkColor(blackColor);
	configuration->setShape(StellarX::ControlShape::B_ROUND_RECTANGLE);
	setStretchX(configuration.get());
	setBottomFixed(configuration.get());

	auto configurationLabel = std::make_unique<Label>(20, -10, "配置区");
	styleTitleLabel(configurationLabel.get());
	setLeftFixed(configurationLabel.get());

	auto clearButton = std::make_unique<Button>(420, 10, 90, 20, "一键置0",
		blackColor, RGB(171, 196, 220));
	auto fillButton = std::make_unique<Button>(530, 10, 90, 20, "一键置1",
		blackColor, RGB(171, 196, 220));
	styleActionButton(clearButton.get());
	styleActionButton(fillButton.get());
	setRightFixed(clearButton.get());
	setRightFixed(fillButton.get());

	auto signedToggle = std::make_unique<Button>(
		300, 10, 90, 20, "无符号",
		blackColor, RGB(171, 196, 220), StellarX::ButtonMode::TOGGLE);
	styleActionButton(signedToggle.get());
	setCenterFixed(signedToggle.get());
	auto* signedTogglePtr = signedToggle.get();

	// ====== 公用小工具======
	auto clamp = [](int v, int lo, int hi) { return v < lo ? lo : (v > hi ? hi : v); };
	auto toInt = [](const std::string& s, int def = 0) {
		try { return std::stoi(s); }
		catch (...) { return def; }
	};

	auto snapshotBits = [&]() {
		std::array<bool, 32> bits{};
		for (int bit = 0; bit < 32; ++bit)
			bits[bit] = selectionAreaButton_ptr[vecIndexFromBit(bit)]->isClicked();
		return bits;
	};

	auto valueFromBits = [](const std::array<bool, 32>& bits) -> uint32_t {
		uint32_t value = 0;
		for (int bit = 0; bit < 32; ++bit)
			if (bits[bit]) value |= (1u << bit);
		return value;
	};

	auto binaryGroupedFromBits = [](const std::array<bool, 32>& bits) -> std::string {
		std::string text;
		text.reserve(39);
		for (int bit = 31; bit >= 0; --bit) {
			text.push_back(bits[bit] ? '1' : '0');
			if (bit % 4 == 0 && bit != 0) text.push_back('_');
		}
		return text;
	};

	auto syncInitData = [&](const std::array<bool, 32>& bits) {
		for (int bit = 31; bit >= 0; --bit)
			initData[31 - bit] = bits[bit] ? '1' : '0';
		initData[32] = '\0';
	};

	auto refreshDisplaysWithBits = [&](const std::array<bool, 32>& bits, bool pushHistory) {
		const uint32_t value = valueFromBits(bits);
		const int32_t signedValue = static_cast<int32_t>(value);
		char hexbuf[16];
		std::snprintf(hexbuf, sizeof(hexbuf), "%08X", value);

		if (pushHistory)
			Last->setText(This->getText());

		hex->setText(hexbuf);
		dec->setText(gSigned ? std::to_string(signedValue) : std::to_string(value));
		This->setText(binaryGroupedFromBits(bits));
		syncInitData(bits);
	};

	bool batchApplyingBits = false;
	auto applyBits = [&](const std::array<bool, 32>& bits, bool pushHistory) {
		batchApplyingBits = true;
		for (int bit = 0; bit < 32; ++bit) {
			auto* button = selectionAreaButton_ptr[vecIndexFromBit(bit)];
			if (button->isClicked() != bits[bit])
				button->setButtonClick(bits[bit]);
			button->setButtonText(bits[bit] ? "1" : "0");
		}
		batchApplyingBits = false;
		refreshDisplaysWithBits(bits, pushHistory);
	};

	// 取反区控件
	auto invStartLabel = std::make_unique<Label>(18, 12, "从");
	auto invEndLabel = std::make_unique<Label>(82, 12, "到");
	styleTitleLabel(invStartLabel.get());
	styleTitleLabel(invEndLabel.get());

	auto invStartBox = std::make_unique<TextBox>(34, 28, 34, 28, "0");
	auto invEndBox = std::make_unique<TextBox>(98, 28, 34, 28, "31");
	styleInputBox(invStartBox.get(), 3);
	styleInputBox(invEndBox.get(), 3);
	auto invL = invStartBox.get();
	auto invH = invEndBox.get();

	auto bitInvertFunctionButton = std::make_unique<Button>(140, 28, 64, 28, "位取反",
		blackColor, RGB(171, 196, 220));
	styleActionButton(bitInvertFunctionButton.get());
	auto bitInvertFunctionButton_ptr = bitInvertFunctionButton.get();

	bitInvert->addControl(std::move(bitInvertLabel));
	bitInvert->addControl(std::move(invStartLabel));
	bitInvert->addControl(std::move(invEndLabel));
	bitInvert->addControl(std::move(invStartBox));
	bitInvert->addControl(std::move(invEndBox));
	bitInvert->addControl(std::move(bitInvertFunctionButton));

	// 左移控件
	auto leftShiftFunctionLabel = std::make_unique<Label>(178, 30, "位");
	styleTitleLabel(leftShiftFunctionLabel.get());

	auto leftShiftFunctionTextBox = std::make_unique<TextBox>(82, 28, 86, 28, "0");
	styleInputBox(leftShiftFunctionTextBox.get(), 3);
	auto shlBox = leftShiftFunctionTextBox.get();

	auto leftShiftFunctionButton = std::make_unique<Button>(16, 28, 56, 28, "左移",
		blackColor, RGB(171, 196, 220));
	styleActionButton(leftShiftFunctionButton.get());
	auto leftShiftFunctionButton_ptr = leftShiftFunctionButton.get();

	leftShift->addControl(std::move(leftShiftLabel));
	leftShift->addControl(std::move(leftShiftFunctionButton));
	leftShift->addControl(std::move(leftShiftFunctionTextBox));
	leftShift->addControl(std::move(leftShiftFunctionLabel));

	// 右移控件
	auto rightShiftFunctionLabel = std::make_unique<Label>(178, 30, "位");
	styleTitleLabel(rightShiftFunctionLabel.get());

	auto rightShiftFunctionTextBox = std::make_unique<TextBox>(82, 28, 86, 28, "0");
	styleInputBox(rightShiftFunctionTextBox.get(), 3);
	auto shrBox = rightShiftFunctionTextBox.get();

	auto rightShiftFunctionButton = std::make_unique<Button>(16, 28, 56, 28, "右移",
		blackColor, RGB(171, 196, 220));
	styleActionButton(rightShiftFunctionButton.get());
	auto rightShiftFunctionButton_ptr = rightShiftFunctionButton.get();

	rightShift->addControl(std::move(rightShiftLabel));
	rightShift->addControl(std::move(rightShiftFunctionButton));
	rightShift->addControl(std::move(rightShiftFunctionTextBox));
	rightShift->addControl(std::move(rightShiftFunctionLabel));

	// 位按钮与显示区联动
	for (int bit = 0; bit < 32; ++bit) {
		auto* button = selectionAreaButton_ptr[vecIndexFromBit(bit)];
		button->setOnToggleOnListener([&, bit]() {
			selectionAreaButton_ptr[vecIndexFromBit(bit)]->setButtonText("1");
			if (!batchApplyingBits)
				refreshDisplaysWithBits(snapshotBits(), true);
		});
		button->setOnToggleOffListener([&, bit]() {
			selectionAreaButton_ptr[vecIndexFromBit(bit)]->setButtonText("0");
			if (!batchApplyingBits)
				refreshDisplaysWithBits(snapshotBits(), true);
		});
	}

	bitInvertFunctionButton_ptr->setOnClickListener([&]() {
		int low = clamp(toInt(invL->getText(), 0), 0, 31);
		int high = clamp(toInt(invH->getText(), 31), 0, 31);
		if (low > high) std::swap(low, high);

		auto bits = snapshotBits();
		for (int bit = low; bit <= high; ++bit)
			bits[bit] = !bits[bit];
		applyBits(bits, true);
	});

	leftShiftFunctionButton_ptr->setOnClickListener([&]() {
		int count = clamp(toInt(shlBox->getText(), 0), 0, 31);
		auto bits = snapshotBits();
		std::array<bool, 32> next{};
		for (int bit = 31; bit >= 0; --bit)
			next[bit] = (bit >= count) ? bits[bit - count] : false;
		applyBits(next, true);
	});

	rightShiftFunctionButton_ptr->setOnClickListener([&]() {
		int count = clamp(toInt(shrBox->getText(), 0), 0, 31);
		auto bits = snapshotBits();
		std::array<bool, 32> next{};
		for (int bit = 0; bit < 32; ++bit)
			next[bit] = (bit + count <= 31) ? bits[bit + count] : false;
		applyBits(next, true);
	});

	clearButton->setOnClickListener([&]() {
		std::array<bool, 32> bits{};
		applyBits(bits, true);
	});

	fillButton->setOnClickListener([&]() {
		std::array<bool, 32> bits{};
		bits.fill(true);
		applyBits(bits, true);
	});

	signedTogglePtr->setOnToggleOnListener([&]() {
		gSigned = true;
		signedTogglePtr->setButtonText("有符号");
		StellarX::MessageBox::showModal(mainWindow, "有符号模式下，\n最高位为符号位，\n其余位为数值位。", "有符号模式");
		refreshDisplaysWithBits(snapshotBits(), false);
	});
	signedTogglePtr->setOnToggleOffListener([&]() {
		gSigned = false;
		signedTogglePtr->setButtonText("无符号");
		StellarX::MessageBox::showAsync(mainWindow, "无符号模式下，\n所有位均为数值位。", "无符号模式");
		refreshDisplaysWithBits(snapshotBits(), false);
	});
	signedTogglePtr->enableTooltip(true);
	signedTogglePtr->setTooltipTextsForToggle("切换无符号模式", "切换有符号模式");

	function->addControl(std::move(bitInvert_que));
	function->addControl(std::move(leftShift_que));
	function->addControl(std::move(rightShift_que));

	configuration->addControl(std::move(configurationLabel));
	configuration->addControl(std::move(signedToggle));
	configuration->addControl(std::move(clearButton));
	configuration->addControl(std::move(fillButton));

	refreshDisplaysWithBits(snapshotBits(), false);

	mainWindow.addControl(std::move(selectionArea));
	mainWindow.addControl(std::move(function));
	mainWindow.addControl(std::move(NumericalDisplayArea));
	mainWindow.addControl(std::move(BinaryDisplayArea));
	mainWindow.addControl(std::move(configuration));

	mainWindow.draw();
	return mainWindow.runEventLoop();
}
#endif

#if 3 == KEY

// 本Demo基于 StellarX 构建，轻量级的 Windows GUI 框架。
#include"StellarX.h"

int main()
{
	StellarX::SxLogger::setGBK();
	StellarX::SxLogger::Get().enableConsole(true);
	StellarX::SxLogger::Get().setMinLevel(StellarX::SxLogLevel::Debug);   // Info/Debug/Trace 自己切
	StellarX::SxLogger::Get().setLanguage(StellarX::SxLogLanguage::ZhCN); // ZhCN / EnUS

	Window win(1300, 800, 1, RGB(255, 255, 0), "记账管理系统");

	/*********登录界面***********/
	//标签
	std::unique_ptr<Label>  logIn_label[3];
	logIn_label[0] = std::make_unique<Label>(90, 150, "欢迎使用餐馆记账管理系统");
	logIn_label[1] = std::make_unique<Label>(400, 300, "账号");
	logIn_label[2] = std::make_unique<Label>(400, 400, "密码");
	for (auto& log : logIn_label)
	{
		log->setTextdisap(true);
		log->textStyle.lpszFace = "华文行楷";
	}
	logIn_label[0]->textStyle.nHeight = 100;
	SxTestSetTopFixed(logIn_label[0].get());
	logIn_label[1]->textStyle.nHeight = 50;
	SxTestSetBottomFixed(logIn_label[1].get());
	logIn_label[2]->textStyle.nHeight = 50;
	SxTestSetBottomFixed(logIn_label[2].get());

	//输入框
	std::unique_ptr<TextBox>  logIn_textBox[2];
	TextBox* logIn_textBox_ptr[2];
	logIn_textBox[0] = std::make_unique<TextBox>(500, 295, 450, 50);
	logIn_textBox[1] = std::make_unique<TextBox>(500, 395, 450, 50);
	logIn_textBox[1]->setMode(StellarX::TextBoxmode::PASSWORD_MODE);
	logIn_textBox_ptr[0] = logIn_textBox[0].get();
	logIn_textBox_ptr[1] = logIn_textBox[1].get();
	for (auto& tb : logIn_textBox)
	{
		SxTestSetBottomFixed(tb.get());
		tb->setMaxCharLen(15);
	}
	//按钮
	std::unique_ptr<Button>  logIn_Button[2];
	Button* logIn_Button_ptr[2];
	logIn_Button[0] = std::make_unique<Button>(350, 500, 300, 50, "管理员登录");
	logIn_Button[1] = std::make_unique<Button>(750, 500, 300, 50, "操作员登录");
	logIn_Button_ptr[0] = logIn_Button[0].get();
	logIn_Button_ptr[1] = logIn_Button[1].get();
	for (auto& b : logIn_Button)
	{
		SxTestSetBottomFixed(b.get());
	}
	//log画布
	auto log_Canvas = std::make_unique<Canvas>(0, 0, 1300, 800);
	Canvas* log_Canvas_ptr = log_Canvas.get();
	log_Canvas_ptr->setCanvasfillMode(StellarX::FillMode::Null);
	log_Canvas_ptr->setShape(StellarX::ControlShape::B_RECTANGLE);
	SxTestSetStretchY(log_Canvas_ptr);

	//将log界面控价加入logCanvas统一管理
	for (auto& b : logIn_Button)
		log_Canvas_ptr->addControl(std::move(b));
	for (auto& tb : logIn_textBox)
		log_Canvas_ptr->addControl(std::move(tb));
	for (auto& la : logIn_label)
		log_Canvas_ptr->addControl(std::move(la));

	/**************业务UI****************/

	auto tabControl = std::make_unique<TabControl>(10, 10, 1280, 780);
	auto tabControl_ptr = tabControl.get();
	tabControl_ptr->setIsVisible(false);
	tabControl_ptr->setCanvasfillMode(StellarX::FillMode::Null);
	tabControl_ptr->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabControl_ptr->setTabPlacement(StellarX::TabPlacement::Left);
	tabControl_ptr->setTabBarHeight(60);
	//添加页签及页
	auto tabP = std::make_pair(std::make_unique<Button>(0, 0, 100, 100, "点餐"), std::make_unique<Canvas>(0, 0, 1290, 790));
	tabP.second->setShape(StellarX::ControlShape::ROUND_RECTANGLE);
	tabControl_ptr->add(std::move(tabP));

	/*------------login事件-------------*/
	//管理员登录按钮事件
	logIn_Button_ptr[0]->setOnClickListener([&tabControl_ptr, &log_Canvas_ptr, &logIn_textBox_ptr, &win]()
		{
			if ("\0" == logIn_textBox_ptr[0]->getText() || "\0" == logIn_textBox_ptr[1]->getText())
			{
				if ("\0" == logIn_textBox_ptr[0]->getText())logIn_textBox_ptr[0]->setTextBoxBk(RGB(255, 0, 0));
				if ("\0" == logIn_textBox_ptr[1]->getText())logIn_textBox_ptr[1]->setTextBoxBk(RGB(255, 0, 0));
				std::cout << "\a";
				StellarX::MessageBox::showAsync(win, "账号或密码不能为空！", "提示");
			}
			else if("admin" == logIn_textBox_ptr[0]->getText() && "123" == logIn_textBox_ptr[1]->getText())
			{
				log_Canvas_ptr->setIsVisible(false);
				tabControl_ptr->setIsVisible(true);
				win.draw("image\\bk1.jpg");
			}
			else
			{
				std::cout << "\a";
				StellarX::MessageBox::showModal(win, "账号或密码错误！", "提示");
			}
		});
	//操作员登录按钮事件
	logIn_Button_ptr[1]->setOnClickListener([&tabControl_ptr, &log_Canvas_ptr, &logIn_textBox_ptr, &win]()
		{
			if ("\0" == logIn_textBox_ptr[0]->getText() || "\0" == logIn_textBox_ptr[1]->getText())
			{
				if ("\0" == logIn_textBox_ptr[0]->getText())logIn_textBox_ptr[0]->setTextBoxBk(RGB(255, 0, 0));
				if ("\0" == logIn_textBox_ptr[1]->getText())logIn_textBox_ptr[1]->setTextBoxBk(RGB(255, 0, 0));
				std::cout << "\a";
				StellarX::MessageBox::showModal(win, "账号或密码不能为空！", "提示");
			}
			else
			{
				log_Canvas_ptr->setIsVisible(false);
				tabControl_ptr->setIsVisible(true);
				win.draw("image\\bk1.jpg");
			}
		});

	win.addControl(std::move(log_Canvas));
	win.addControl(std::move(tabControl));
	win.draw("image\\bk1.jpg");

	return win.runEventLoop();
}

#endif