AtguiguCorp/0417_QT_code
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
89b23b229114f32ded231146a41e96f07e0a8b6a
0417_QT_code/APP/APP_UIWindow.cpp

871 lines
33 KiB
C++
Raw Blame History

#include "APP/APP_UIWindow.h"
#include "APP/APP_GlassCard.h"
#include "APP/APP_KeyButton.h"
#include "APP/APP_Theme.h"
#include "APP/APP_UIWindow_Private.h"
#include <QtGui/QFontDatabase>
#include <QtGui/QPainter>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QFormLayout>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QPlainTextEdit>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QScrollBar>
#include <QtWidgets/QSizePolicy>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QStackedWidget>
#include <QtWidgets/QTabWidget>
#include <QtWidgets/QTableWidget>
#include <QtWidgets/QTableWidgetItem>
#include <QtWidgets/QVBoxLayout>
#include <Windows.h>
namespace APP {
namespace
{
enum App_Enum_PacketTestRow
{
App_Enum_PacketTestRow_TxHelloReq = 0,
App_Enum_PacketTestRow_RxHelloRsp,
App_Enum_PacketTestRow_TxBitmap,
App_Enum_PacketTestRow_RxFunctionKeyEvent,
App_Enum_PacketTestRow_RxLedState,
App_Enum_PacketTestRow_TxTimeSync,
App_Enum_PacketTestRow_TxThemeRgb,
App_Enum_PacketTestRow_RxAck,
App_Enum_PacketTestRow_RxError,
App_Enum_PacketTestRow_Count
};
QLabel* App_Func_CreateLabel(
QWidget* parent,
const QString& Text,
const QFont& Font,
bool WordWrap = false)
{
QLabel* p_Label = new QLabel(Text, parent);
p_Label->setFont(Font);
p_Label->setAttribute(Qt::WA_TranslucentBackground, true);
p_Label->setWordWrap(WordWrap);
return p_Label;
}
APP_GlassCard* App_Func_CreateCard(QWidget* parent, QVBoxLayout** pp_Layout)
{
APP_GlassCard* p_Card = new APP_GlassCard(parent);
QVBoxLayout* p_Layout = new QVBoxLayout(p_Card);
p_Layout->setContentsMargins(20, 20, 20, 20);
p_Layout->setSpacing(14);
*pp_Layout = p_Layout;
return p_Card;
}
void App_Func_SetGridStretch(QGridLayout* p_Grid, int ColumnCount, int RowCount)
{
for (int Column = 0; Column < ColumnCount; ++Column)
{
p_Grid->setColumnStretch(Column, 1);
}
for (int Row = 0; Row < RowCount; ++Row)
{
p_Grid->setRowStretch(Row, 1);
}
}
bool App_Func_RegisterRawInputWindow(WId WindowId)
{
RAWINPUTDEVICE Device = {};
Device.usUsagePage = 0x01;
Device.usUsage = 0x06;
Device.dwFlags = RIDEV_INPUTSINK;
Device.hwndTarget = reinterpret_cast<HWND>(WindowId);
return RegisterRawInputDevices(&Device, 1, sizeof(Device)) == TRUE;
}
QString App_Func_BoolText(bool Value)
{
return Value ? QStringLiteral("Yes") : QStringLiteral("No");
}
Com_Enum_RawPacketSource App_Func_GetPacketTestTargetSource(const QComboBox* p_Combo)
{
return p_Combo == nullptr
? Com_Enum_RawPacketSource_None
: static_cast<Com_Enum_RawPacketSource>(p_Combo->currentData().toInt());
}
QString App_Func_GetPacketTestTargetText(Com_Enum_RawPacketSource Source)
{
switch (Source)
{
case Com_Enum_RawPacketSource_UsbCdc:
return QStringLiteral("USB CDC only");
case Com_Enum_RawPacketSource_BleNus:
return QStringLiteral("BLE NUS only");
default:
return QStringLiteral("Auto (ready transport)");
}
}
QString App_Func_FormatPacketType(quint32 RawType)
{
switch (static_cast<Com_Enum_ProtocolType>(RawType & 0xFFU))
{
case Com_Enum_ProtocolType_HelloReq: return QStringLiteral("HelloReq");
case Com_Enum_ProtocolType_HelloRsp: return QStringLiteral("HelloRsp");
case Com_Enum_ProtocolType_Bitmap: return QStringLiteral("Bitmap");
case Com_Enum_ProtocolType_FunctionKeyEvent: return QStringLiteral("FunctionKeyEvent");
case Com_Enum_ProtocolType_LedState: return QStringLiteral("LedState");
case Com_Enum_ProtocolType_TimeSync: return QStringLiteral("TimeSync");
case Com_Enum_ProtocolType_ThemeRgb: return QStringLiteral("ThemeRgb");
case Com_Enum_ProtocolType_Ack: return QStringLiteral("Ack");
case Com_Enum_ProtocolType_Error: return QStringLiteral("Error");
default:
return RawType == 0
? QStringLiteral("None")
: QStringLiteral("0x%1").arg(RawType, 0, 16).toUpper();
}
}
QString App_Func_FormatVidPid(quint32 VendorId, quint32 ProductId)
{
return QStringLiteral("%1:%2")
.arg(VendorId, 4, 16, QLatin1Char('0'))
.arg(ProductId, 4, 16, QLatin1Char('0'))
.toUpper();
}
QFont App_Func_GetMonoFont()
{
QFont Font = QFontDatabase::systemFont(QFontDatabase::FixedFont);
Font.setPointSize(9);
return Font;
}
} // namespace
int App_Func_GetFeatureStackIndex(Lgc_FunctionFeature_Type Type)
{
switch (Type)
{
case Lgc_FunctionFeature_Type::KeyCombination:
case Lgc_FunctionFeature_Type::KeySequence:
return 0;
case Lgc_FunctionFeature_Type::Website:
return 1;
default:
return 0;
}
}
bool App_Func_IsKeyRecordFeatureType(Lgc_FunctionFeature_Type Type)
{
return (Type == Lgc_FunctionFeature_Type::KeyCombination) ||
(Type == Lgc_FunctionFeature_Type::KeySequence);
}
QString App_Func_GetWebsiteEditText(const QString& UrlText)
{
const QString DisplayText = UrlText.trimmed();
return DisplayText.isEmpty() ? QStringLiteral("https://") : DisplayText;
}
App_UIWindow::App_UIWindow(QWidget* parent)
: QWidget(parent)
{
App_Func_InitWindow();
App_Func_InitUi();
App_Func_InitConnect();
App_Func_InitLogic();
App_Func_RefreshKeypadButtons();
App_Func_RefreshFunctionStatus();
App_Func_RefreshPacketTestPanel();
update();
}
App_UIWindow::~App_UIWindow()
{
Lgc_Core_Close(&appLgcState);
}
void App_UIWindow::paintEvent(QPaintEvent* event)
{
Q_UNUSED(event);
QPainter Painter(this);
Painter.setRenderHint(QPainter::Antialiasing, true);
Painter.fillRect(rect(), palette().color(QPalette::Window));
}
void App_UIWindow::resizeEvent(QResizeEvent* event)
{
QWidget::resizeEvent(event);
App_Func_UpdateFeatureEditorHeight();
}
bool App_UIWindow::nativeEvent(const QByteArray& EventType, void* p_Message, long* p_Result)
{
Q_UNUSED(EventType);
App_Func_HandleSequenceRecordMessage(p_Message);
Lgc_Core_HandleNativeMessage(&appLgcState, p_Message);
return QWidget::nativeEvent(EventType, p_Message, p_Result);
}
void App_UIWindow::App_Func_InitWindow()
{
setWindowTitle(QStringLiteral("Keyboard Control"));
setMinimumSize(760, 820);
resize(820, 900);
setAttribute(Qt::WA_StyledBackground, true);
}
void App_UIWindow::App_Func_InitUi()
{
QVBoxLayout* p_RootLayout = new QVBoxLayout(this);
p_RootLayout->setContentsMargins(26, 22, 26, 24);
p_RootLayout->setSpacing(14);
appPageTab = new QTabWidget(this);
appPageTab->setDocumentMode(true);
appPageTab->setMovable(false);
appPageTab->addTab(App_Func_CreatePadCard(), QStringLiteral("Keypad"));
appFeaturePageIndex =
appPageTab->addTab(App_Func_CreateFunctionConfigCard(), QStringLiteral("Functions"));
appPacketTestPageIndex =
appPageTab->addTab(App_Func_CreatePacketTestCard(), QStringLiteral("Device Test"));
p_RootLayout->addWidget(appPageTab, 1);
}
void App_UIWindow::App_Func_InitConnect()
{
connect(&appTimerPoll, &QTimer::timeout, this, [this]()
{
if (Lgc_Core_Poll(&appLgcState))
{
App_Func_RefreshAfterLogicChange();
}
});
connect(&appTimerAutoRefreshDevice, &QTimer::timeout, this, [this]()
{
const Lgc_Core_Struct_View View = Lgc_Core_GetView(&appLgcState);
if (View.IsConnected || View.HasOpenTransport)
{
return;
}
Lgc_Core_RefreshDevice(&appLgcState);
App_Func_RefreshKeypadState();
App_Func_RefreshKeypadButtons();
App_Func_RefreshFunctionStatus();
App_Func_RefreshPacketTestPanel();
update();
});
connect(appFeatureAddButton, &QPushButton::clicked, this, &App_UIWindow::App_Func_AddFeature);
connect(appFeatureDeleteButton, &QPushButton::clicked, this, &App_UIWindow::App_Func_DeleteFeature);
connect(appFeatureTimeSyncButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_SendTimeSync(&appLgcState);
App_Func_RefreshAfterLogicChange();
});
connect(appFeatureThemeSwitchButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_SendThemeSwitch(&appLgcState);
App_Func_RefreshAfterLogicChange();
});
connect(appFeatureTable, &QTableWidget::itemSelectionChanged, this, [this]()
{
const QModelIndexList IndexList = appFeatureTable->selectionModel()->selectedRows();
if (IndexList.isEmpty())
{
App_Func_SelectFeature(0);
return;
}
const int Row = IndexList.first().row();
App_Func_SelectFeature(appFeatureTable->item(Row, 0)->data(Qt::UserRole).toInt());
});
const auto ConnectSaveSignal = [this](auto Sender, auto Signal)
{
connect(Sender, Signal, this, [this]()
{
if (!appIsUpdatingFeatureUi)
{
App_Func_SaveFeatureFromUi();
}
});
};
ConnectSaveSignal(appFeatureNameEdit, &QLineEdit::textChanged);
ConnectSaveSignal(appFeatureDescriptionEdit, &QLineEdit::textChanged);
ConnectSaveSignal(appFeatureTypeCombo, qOverload<int>(&QComboBox::currentIndexChanged));
ConnectSaveSignal(appFeatureSequenceEdit, &QLineEdit::textChanged);
ConnectSaveSignal(appFeatureWebsiteEdit, &QLineEdit::textChanged);
connect(
appFeatureSequenceRecordStartButton,
&QPushButton::clicked,
this,
&App_UIWindow::App_Func_StartSequenceRecording);
connect(
appFeatureSequenceRecordStopButton,
&QPushButton::clicked,
this,
&App_UIWindow::App_Func_StopSequenceRecording);
connect(appPacketTestRefreshButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_RefreshDevice(&appLgcState);
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestTargetCombo, qOverload<int>(&QComboBox::currentIndexChanged), this, [this]()
{
App_Func_RefreshPacketTestPanel();
});
connect(appPacketTestSendHelloButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_TestSendHello(
&appLgcState,
App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestSendBitmapCurrentButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_TestSendBitmapCurrentConfig(
&appLgcState,
App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestSendBitmapAllOnButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_TestSendBitmapAllEnabled(
&appLgcState,
App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestSendBitmapAllOffButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_TestSendBitmapAllDisabled(
&appLgcState,
App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestSendTimeSyncButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_TestSendTimeSync(
&appLgcState,
App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestSendThemeButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_TestSendThemeRgb(
&appLgcState,
static_cast<quint8>(appPacketTestThemeRedSpin->value()),
static_cast<quint8>(appPacketTestThemeGreenSpin->value()),
static_cast<quint8>(appPacketTestThemeBlueSpin->value()),
App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
App_Func_RefreshAfterLogicChange();
});
connect(appPacketTestClearLogButton, &QPushButton::clicked, this, [this]()
{
Lgc_Core_ClearTestLog(&appLgcState);
App_Func_RefreshAfterLogicChange();
});
}
void App_UIWindow::App_Func_InitLogic()
{
Lgc_Core_Init(&appLgcState);
const WId WindowId = winId();
Lgc_Core_SetWindowHandle(&appLgcState, reinterpret_cast<void*>(WindowId));
if (!App_Func_RegisterRawInputWindow(WindowId))
{
Lgc_Core_SetStatusText(&appLgcState, QStringLiteral("Raw keyboard capture init failed."));
}
Lgc_Core_LoadFunctionConfig(&appLgcState);
App_Func_RefreshFeatureTable();
Lgc_Core_Start(&appLgcState);
appTimerPoll.setInterval(30);
appTimerPoll.start();
appTimerAutoRefreshDevice.setInterval(1500);
appTimerAutoRefreshDevice.start();
App_Func_RefreshKeypadState();
App_Func_RefreshKeypadButtons();
App_Func_RefreshFunctionStatus();
App_Func_RefreshPacketTestPanel();
update();
}
QWidget* App_UIWindow::App_Func_CreatePadCard()
{
QVBoxLayout* p_Layout = nullptr;
APP_GlassCard* p_Card = App_Func_CreateCard(this, &p_Layout);
p_Layout->addWidget(
App_Func_CreateLabel(p_Card, QStringLiteral("Keypad"), APP_Theme::App_Func_GetMetricFont()));
p_Layout->addWidget(App_Func_CreateLabel(
p_Card,
QStringLiteral(
"Left click simulates a real press/release. Right click binds the current key to a "
"function. After binding, the button shows the function name and tooltip."),
APP_Theme::App_Func_GetBodyFont(),
true));
QGridLayout* p_Grid = new QGridLayout();
p_Grid->setSpacing(14);
for (const APP_KeyInfo& Key : appKeypadModel.App_Func_GetKeyList())
{
APP_KeyButton* p_Button = new APP_KeyButton(Key, p_Card);
p_Button->setContextMenuPolicy(Qt::CustomContextMenu);
connect(
p_Button,
&QPushButton::pressed,
this,
[this, Key]()
{
Lgc_Core_HandleUiKeyPress(&appLgcState, Key.usage);
App_Func_RefreshUi();
});
connect(
p_Button,
&QPushButton::released,
this,
[this, Key]()
{
Lgc_Core_HandleUiKeyRelease(&appLgcState, Key.usage);
App_Func_RefreshUi();
});
connect(
p_Button,
&QWidget::customContextMenuRequested,
this,
[this, p_Button, Key](const QPoint&)
{
App_Func_ShowKeyMenu(
Key.usage,
p_Button->mapToGlobal(QPoint(p_Button->width() / 2, p_Button->height() / 2)));
});
appKeypadButtonMap.insert(Key.id, p_Button);
p_Grid->addWidget(p_Button, Key.row, Key.column, Key.rowSpan, Key.columnSpan);
}
App_Func_SetGridStretch(p_Grid, 4, 5);
p_Layout->addLayout(p_Grid, 1);
return p_Card;
}
QWidget* App_UIWindow::App_Func_CreateFunctionConfigCard()
{
QVBoxLayout* p_Layout = nullptr;
APP_GlassCard* p_Card = App_Func_CreateCard(this, &p_Layout);
const auto AddRow = [p_Card](QFormLayout* p_Form, const QString& LabelText, QWidget* p_Field)
{
p_Form->addRow(
App_Func_CreateLabel(p_Card, LabelText, APP_Theme::App_Func_GetBodyFont()),
p_Field);
};
p_Layout->addWidget(
App_Func_CreateLabel(p_Card, QStringLiteral("Functions"), APP_Theme::App_Func_GetMetricFont()));
p_Layout->addWidget(App_Func_CreateLabel(
p_Card,
QStringLiteral(
"The function list starts empty. Add a function first, then bind keypad keys to it. "
"Current types: shortcut, shortcut sequence, and website."),
APP_Theme::App_Func_GetBodyFont(),
true));
QHBoxLayout* p_TopRow = new QHBoxLayout();
p_TopRow->setContentsMargins(0, 0, 0, 0);
p_TopRow->setSpacing(10);
appFeatureAddButton = new QPushButton(QStringLiteral("Add Function"), p_Card);
appFeatureDeleteButton = new QPushButton(QStringLiteral("Delete Function"), p_Card);
appFeatureTimeSyncButton = new QPushButton(QStringLiteral("Time Sync"), p_Card);
appFeatureThemeSwitchButton = new QPushButton(QStringLiteral("Theme Switch"), p_Card);
appFeatureDeleteButton->setEnabled(false);
p_TopRow->addWidget(appFeatureAddButton);
p_TopRow->addWidget(appFeatureDeleteButton);
p_TopRow->addWidget(appFeatureTimeSyncButton);
p_TopRow->addWidget(appFeatureThemeSwitchButton);
p_TopRow->addStretch(1);
p_Layout->addLayout(p_TopRow);
appFeatureTable = new QTableWidget(p_Card);
appFeatureTable->setColumnCount(3);
appFeatureTable->setHorizontalHeaderLabels(
{ QStringLiteral("Name"), QStringLiteral("Description"), QStringLiteral("Type") });
appFeatureTable->setSelectionBehavior(QAbstractItemView::SelectRows);
appFeatureTable->setSelectionMode(QAbstractItemView::SingleSelection);
appFeatureTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
appFeatureTable->setAlternatingRowColors(true);
appFeatureTable->verticalHeader()->setVisible(false);
appFeatureTable->horizontalHeader()->setStretchLastSection(false);
appFeatureTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
appFeatureTable->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
appFeatureTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
appFeatureTable->setMinimumHeight(220);
p_Layout->addWidget(appFeatureTable);
QFormLayout* p_Form = new QFormLayout();
p_Form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
p_Form->setLabelAlignment(Qt::AlignLeft | Qt::AlignVCenter);
p_Form->setHorizontalSpacing(10);
p_Form->setVerticalSpacing(10);
appFeatureNameEdit = new QLineEdit(p_Card);
appFeatureNameEdit->setPlaceholderText(
QStringLiteral("Example: Function 1 / Open 4399 / Prefix Macro"));
AddRow(p_Form, QStringLiteral("Name"), appFeatureNameEdit);
appFeatureDescriptionEdit = new QLineEdit(p_Card);
appFeatureDescriptionEdit->setPlaceholderText(
QStringLiteral("Example: Open the 4399 home page"));
AddRow(p_Form, QStringLiteral("Description"), appFeatureDescriptionEdit);
appFeatureTypeCombo = new QComboBox(p_Card);
appFeatureTypeCombo->addItem(
Lgc_Core_GetFeatureTypeText(Lgc_FunctionFeature_Type::KeyCombination),
static_cast<int>(Lgc_FunctionFeature_Type::KeyCombination));
appFeatureTypeCombo->addItem(
Lgc_Core_GetFeatureTypeText(Lgc_FunctionFeature_Type::KeySequence),
static_cast<int>(Lgc_FunctionFeature_Type::KeySequence));
appFeatureTypeCombo->addItem(
Lgc_Core_GetFeatureTypeText(Lgc_FunctionFeature_Type::Website),
static_cast<int>(Lgc_FunctionFeature_Type::Website));
AddRow(p_Form, QStringLiteral("Type"), appFeatureTypeCombo);
appFeatureEditorStack = new QStackedWidget(p_Card);
appFeatureEditorStack->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
QWidget* p_SequencePage = new QWidget(appFeatureEditorStack);
QFormLayout* p_SequenceForm = new QFormLayout(p_SequencePage);
p_SequenceForm->setContentsMargins(0, 0, 0, 0);
p_SequenceForm->setHorizontalSpacing(10);
p_SequenceForm->setVerticalSpacing(10);
QWidget* p_SequenceEditor = new QWidget(p_SequencePage);
QHBoxLayout* p_SequenceEditorLayout = new QHBoxLayout(p_SequenceEditor);
p_SequenceEditorLayout->setContentsMargins(0, 0, 0, 0);
p_SequenceEditorLayout->setSpacing(8);
appFeatureSequenceEdit = new QLineEdit(p_SequenceEditor);
appFeatureSequenceEdit->setPlaceholderText(QStringLiteral("Example: Ctrl+C"));
appFeatureSequenceRecordStartButton =
new QPushButton(QStringLiteral("Start Record"), p_SequenceEditor);
appFeatureSequenceRecordStopButton =
new QPushButton(QStringLiteral("Stop Record"), p_SequenceEditor);
appFeatureSequenceRecordStopButton->setEnabled(false);
p_SequenceEditorLayout->addWidget(appFeatureSequenceEdit, 1);
p_SequenceEditorLayout->addWidget(appFeatureSequenceRecordStartButton);
p_SequenceEditorLayout->addWidget(appFeatureSequenceRecordStopButton);
p_SequenceForm->addRow(QStringLiteral("Shortcut"), p_SequenceEditor);
QWidget* p_WebsitePage = new QWidget(appFeatureEditorStack);
QVBoxLayout* p_WebsiteLayout = new QVBoxLayout(p_WebsitePage);
p_WebsiteLayout->setContentsMargins(0, 0, 0, 0);
p_WebsiteLayout->setSpacing(0);
appFeatureWebsiteEdit = new QLineEdit(p_WebsitePage);
appFeatureWebsiteEdit->setPlaceholderText(QStringLiteral("Example: 4399.com or www.4399.com"));
p_WebsiteLayout->addWidget(appFeatureWebsiteEdit);
appFeatureEditorStack->addWidget(p_SequencePage);
appFeatureEditorStack->addWidget(p_WebsitePage);
AddRow(p_Form, QStringLiteral("Parameter"), appFeatureEditorStack);
appFeatureBindingSummaryLabel = App_Func_CreateLabel(
p_Card,
QStringLiteral("No function selected yet."),
APP_Theme::App_Func_GetBodyFont(),
true);
AddRow(p_Form, QStringLiteral("Bindings"), appFeatureBindingSummaryLabel);
appFunctionLabelStatus = App_Func_CreateLabel(
p_Card,
QStringLiteral("Waiting for function-key activity."),
APP_Theme::App_Func_GetBodyFont(),
true);
AddRow(p_Form, QStringLiteral("Latest Action"), appFunctionLabelStatus);
p_Layout->addLayout(p_Form);
p_Layout->addStretch(1);
return p_Card;
}
QWidget* App_UIWindow::App_Func_CreatePacketTestCard()
{
QVBoxLayout* p_Layout = nullptr;
APP_GlassCard* p_Card = App_Func_CreateCard(this, &p_Layout);
p_Layout->addWidget(
App_Func_CreateLabel(p_Card, QStringLiteral("Device Packet Test"), APP_Theme::App_Func_GetMetricFont()));
p_Layout->addWidget(App_Func_CreateLabel(
p_Card,
QStringLiteral(
"Use this page to drive the real device. Choose Auto / USB CDC / BLE NUS first, "
"then send packets and watch the rolling log for HelloRsp / FunctionKeyEvent / "
"LedState / Ack / Error."),
APP_Theme::App_Func_GetBodyFont(),
true));
QHBoxLayout* p_TargetRow = new QHBoxLayout();
p_TargetRow->setContentsMargins(0, 0, 0, 0);
p_TargetRow->setSpacing(8);
p_TargetRow->addWidget(
App_Func_CreateLabel(
p_Card,
QStringLiteral("Target Transport"),
APP_Theme::App_Func_GetBodyFont()));
appPacketTestTargetCombo = new QComboBox(p_Card);
appPacketTestTargetCombo->addItem(
QStringLiteral("Auto (ready transport)"),
static_cast<int>(Com_Enum_RawPacketSource_None));
appPacketTestTargetCombo->addItem(
QStringLiteral("USB CDC only"),
static_cast<int>(Com_Enum_RawPacketSource_UsbCdc));
appPacketTestTargetCombo->addItem(
QStringLiteral("BLE NUS only"),
static_cast<int>(Com_Enum_RawPacketSource_BleNus));
p_TargetRow->addWidget(appPacketTestTargetCombo, 1);
p_Layout->addLayout(p_TargetRow);
QGridLayout* p_ButtonGrid = new QGridLayout();
p_ButtonGrid->setContentsMargins(0, 0, 0, 0);
p_ButtonGrid->setHorizontalSpacing(10);
p_ButtonGrid->setVerticalSpacing(10);
appPacketTestRefreshButton = new QPushButton(QStringLiteral("Refresh Device"), p_Card);
appPacketTestSendHelloButton = new QPushButton(QStringLiteral("Send HelloReq"), p_Card);
appPacketTestSendBitmapCurrentButton = new QPushButton(QStringLiteral("Send Bitmap(Config)"), p_Card);
appPacketTestSendBitmapAllOnButton = new QPushButton(QStringLiteral("Send Bitmap(All On)"), p_Card);
appPacketTestSendBitmapAllOffButton = new QPushButton(QStringLiteral("Send Bitmap(All Off)"), p_Card);
appPacketTestSendTimeSyncButton = new QPushButton(QStringLiteral("Send TimeSync"), p_Card);
p_ButtonGrid->addWidget(appPacketTestRefreshButton, 0, 0);
p_ButtonGrid->addWidget(appPacketTestSendHelloButton, 0, 1);
p_ButtonGrid->addWidget(appPacketTestSendTimeSyncButton, 0, 2);
p_ButtonGrid->addWidget(appPacketTestSendBitmapCurrentButton, 1, 0);
p_ButtonGrid->addWidget(appPacketTestSendBitmapAllOnButton, 1, 1);
p_ButtonGrid->addWidget(appPacketTestSendBitmapAllOffButton, 1, 2);
p_ButtonGrid->setColumnStretch(0, 1);
p_ButtonGrid->setColumnStretch(1, 1);
p_ButtonGrid->setColumnStretch(2, 1);
p_Layout->addLayout(p_ButtonGrid);
QHBoxLayout* p_ThemeRow = new QHBoxLayout();
p_ThemeRow->setContentsMargins(0, 0, 0, 0);
p_ThemeRow->setSpacing(8);
p_ThemeRow->addWidget(
App_Func_CreateLabel(p_Card, QStringLiteral("Theme RGB"), APP_Theme::App_Func_GetBodyFont()));
const auto CreateSpin = [p_Card](int Value)
{
QSpinBox* p_Spin = new QSpinBox(p_Card);
p_Spin->setRange(0, 255);
p_Spin->setValue(Value);
p_Spin->setButtonSymbols(QAbstractSpinBox::NoButtons);
p_Spin->setAlignment(Qt::AlignCenter);
p_Spin->setFixedWidth(56);
return p_Spin;
};
appPacketTestThemeRedSpin = CreateSpin(247);
appPacketTestThemeGreenSpin = CreateSpin(37);
appPacketTestThemeBlueSpin = CreateSpin(133);
appPacketTestSendThemeButton = new QPushButton(QStringLiteral("Send ThemeRgb"), p_Card);
appPacketTestClearLogButton = new QPushButton(QStringLiteral("Clear Log"), p_Card);
p_ThemeRow->addWidget(appPacketTestThemeRedSpin);
p_ThemeRow->addWidget(appPacketTestThemeGreenSpin);
p_ThemeRow->addWidget(appPacketTestThemeBlueSpin);
p_ThemeRow->addWidget(appPacketTestSendThemeButton);
p_ThemeRow->addWidget(appPacketTestClearLogButton);
p_ThemeRow->addStretch(1);
p_Layout->addLayout(p_ThemeRow);
appPacketTestTransportLabel =
App_Func_CreateLabel(p_Card, QStringLiteral("Transport: -"), APP_Theme::App_Func_GetBodyFont(), true);
appPacketTestProtocolLabel =
App_Func_CreateLabel(p_Card, QStringLiteral("Protocol: -"), APP_Theme::App_Func_GetBodyFont(), true);
appPacketTestHelloLabel =
App_Func_CreateLabel(p_Card, QStringLiteral("HelloRsp: -"), APP_Theme::App_Func_GetBodyFont(), true);
appPacketTestAckLabel =
App_Func_CreateLabel(p_Card, QStringLiteral("Ack: -"), APP_Theme::App_Func_GetBodyFont(), true);
appPacketTestErrorLabel =
App_Func_CreateLabel(p_Card, QStringLiteral("Error: -"), APP_Theme::App_Func_GetBodyFont(), true);
appPacketTestBitmapLabel =
App_Func_CreateLabel(p_Card, QStringLiteral("Bitmaps: -"), APP_Theme::App_Func_GetBodyFont(), true);
p_Layout->addWidget(appPacketTestTransportLabel);
p_Layout->addWidget(appPacketTestProtocolLabel);
p_Layout->addWidget(appPacketTestHelloLabel);
p_Layout->addWidget(appPacketTestAckLabel);
p_Layout->addWidget(appPacketTestErrorLabel);
p_Layout->addWidget(appPacketTestBitmapLabel);
appPacketTestTable = new QTableWidget(App_Enum_PacketTestRow_Count, 3, p_Card);
appPacketTestTable->setFont(App_Func_GetMonoFont());
appPacketTestTable->setHorizontalHeaderLabels(
{ QStringLiteral("Packet"), QStringLiteral("Direction"), QStringLiteral("Count") });
appPacketTestTable->verticalHeader()->setVisible(false);
appPacketTestTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
appPacketTestTable->setSelectionMode(QAbstractItemView::NoSelection);
appPacketTestTable->setFocusPolicy(Qt::NoFocus);
appPacketTestTable->horizontalHeader()->setStretchLastSection(false);
appPacketTestTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
appPacketTestTable->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
appPacketTestTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
appPacketTestTable->setMinimumHeight(220);
const QStringList PacketNames = {
QStringLiteral("HelloReq"),
QStringLiteral("HelloRsp"),
QStringLiteral("Bitmap"),
QStringLiteral("FunctionKeyEvent"),
QStringLiteral("LedState"),
QStringLiteral("TimeSync"),
QStringLiteral("ThemeRgb"),
QStringLiteral("Ack"),
QStringLiteral("Error")
};
const QStringList Directions = {
QStringLiteral("Host -> Device"),
QStringLiteral("Device -> Host"),
QStringLiteral("Host -> Device"),
QStringLiteral("Device -> Host"),
QStringLiteral("Device -> Host"),
QStringLiteral("Host -> Device"),
QStringLiteral("Host -> Device"),
QStringLiteral("Device -> Host"),
QStringLiteral("Device -> Host")
};
for (int Row = 0; Row < App_Enum_PacketTestRow_Count; ++Row)
{
appPacketTestTable->setItem(Row, 0, new QTableWidgetItem(PacketNames.at(Row)));
appPacketTestTable->setItem(Row, 1, new QTableWidgetItem(Directions.at(Row)));
appPacketTestTable->setItem(Row, 2, new QTableWidgetItem(QStringLiteral("0")));
}
p_Layout->addWidget(appPacketTestTable);
appPacketTestLogEdit = new QPlainTextEdit(p_Card);
appPacketTestLogEdit->setFont(App_Func_GetMonoFont());
appPacketTestLogEdit->setReadOnly(true);
appPacketTestLogEdit->setLineWrapMode(QPlainTextEdit::NoWrap);
appPacketTestLogEdit->setMinimumHeight(190);
p_Layout->addWidget(appPacketTestLogEdit, 1);
return p_Card;
}
void App_UIWindow::App_Func_RefreshPacketTestTable()
{
if (appPacketTestTable == nullptr)
{
return;
}
const Lgc_Core_Struct_TestView TestView = Lgc_Core_GetTestView(&appLgcState);
const int Counts[App_Enum_PacketTestRow_Count] = {
TestView.TxHelloReqCount,
TestView.RxHelloRspCount,
TestView.TxBitmapCount,
TestView.RxFunctionKeyEventCount,
TestView.RxLedStateCount,
TestView.TxTimeSyncCount,
TestView.TxThemeRgbCount,
TestView.RxAckCount,
TestView.RxErrorCount
};
for (int Row = 0; Row < App_Enum_PacketTestRow_Count; ++Row)
{
if (QTableWidgetItem* p_Item = appPacketTestTable->item(Row, 2))
{
p_Item->setText(QString::number(Counts[Row]));
}
}
}
void App_UIWindow::App_Func_RefreshPacketTestPanel()
{
if (appPacketTestTransportLabel == nullptr)
{
return;
}
const Lgc_Core_Struct_TestView TestView = Lgc_Core_GetTestView(&appLgcState);
const QString TargetText =
App_Func_GetPacketTestTargetText(App_Func_GetPacketTestTargetSource(appPacketTestTargetCombo));
appPacketTestTransportLabel->setText(
QStringLiteral("Transport\nTarget: %1\nUSB: Open=%2 | Port=%3\nBLE: Open=%4 | Connected=%5 | Endpoint=%6")
.arg(TargetText)
.arg(App_Func_BoolText(TestView.IsUsbOpened))
.arg(TestView.UsbPortName.isEmpty() ? QStringLiteral("-") : TestView.UsbPortName)
.arg(App_Func_BoolText(TestView.IsNusOpened))
.arg(App_Func_BoolText(TestView.IsNusConnected))
.arg(TestView.NusEndpointSummary.isEmpty()
? QStringLiteral("-")
: TestView.NusEndpointSummary));
appPacketTestProtocolLabel->setText(
QStringLiteral("Protocol\nReady: Device=%1 | USB=%2 | BLE=%3\nPending: USB=0x%4 | BLE=0x%5\nStatus: %6")
.arg(App_Func_BoolText(TestView.DeviceReady))
.arg(App_Func_BoolText(TestView.IsUsbProtocolReady))
.arg(App_Func_BoolText(TestView.IsNusProtocolReady))
.arg(QString::number(TestView.PendingUsbCommandBits, 16).toUpper())
.arg(QString::number(TestView.PendingNusCommandBits, 16).toUpper())
.arg(TestView.StatusText.isEmpty() ? QStringLiteral("-") : TestView.StatusText));
appPacketTestHelloLabel->setText(
QStringLiteral("HelloRsp\nVersion: v%1 | FW %2.%3\nVID/PID: %4 | Caps: 0x%5")
.arg(TestView.HelloProtocolVersion)
.arg(TestView.HelloFirmwareMajor)
.arg(TestView.HelloFirmwareMinor)
.arg(App_Func_FormatVidPid(TestView.HelloVendorId, TestView.HelloProductId))
.arg(QString::number(TestView.HelloCapabilityFlags, 16).toUpper()));
appPacketTestAckLabel->setText(
QStringLiteral("Ack\nLastAck: %1\nLastTx: %2\nPayload: %3")
.arg(App_Func_FormatPacketType(TestView.LastAckedType))
.arg(TestView.LastTxSummary.isEmpty() ? QStringLiteral("-") : TestView.LastTxSummary)
.arg(TestView.LastTxHex));
appPacketTestErrorLabel->setText(
QStringLiteral("Error\nType: %1 | Code: %2\nLastRx: %3\nPayload: %4")
.arg(App_Func_FormatPacketType(TestView.LastErrorType))
.arg(TestView.LastErrorCode)
.arg(TestView.LastRxSummary.isEmpty() ? QStringLiteral("-") : TestView.LastRxSummary)
.arg(TestView.LastRxHex));
appPacketTestBitmapLabel->setText(
QStringLiteral("Bitmap\nCurrent: %1\nLastEvent: %2\nLED Mask: 0x%3")
.arg(TestView.FunctionMaskHex)
.arg(TestView.LastFunctionEventHex)
.arg(QString::number(TestView.DeviceLedMask, 16).toUpper()));
App_Func_RefreshPacketTestTable();
if (appPacketTestLogEdit->toPlainText() != TestView.LogText)
{
appPacketTestLogEdit->setPlainText(TestView.LogText);
appPacketTestLogEdit->verticalScrollBar()->setValue(
appPacketTestLogEdit->verticalScrollBar()->maximum());
}
}
void App_UIWindow::App_Func_RefreshUi()
{
App_Func_RefreshKeypadState();
App_Func_RefreshKeypadButtons();
App_Func_RefreshFunctionStatus();
App_Func_RefreshPacketTestPanel();
update();
}
void App_UIWindow::App_Func_RefreshAfterLogicChange()
{
App_Func_RefreshUi();
}
} // namespace APP
Reference in New Issue View Git Blame Copy Permalink