Codex
9155a86a8a
收口 Dialog/overlay 后鼠标状态同步、Tooltip 临时 coverage 与持久 coverage 拆分、跨 root 脏区补提交、TextBox/Button 绘制副作用修复，并补充 KEY6 回归用例和 BUG/Fix/Feature 开发记录。
1675 lines
69 KiB
C++
1675 lines
69 KiB
C++
// 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
|