From 35a82ee26f4b51fa2b43ebb8d6040033986be3bc Mon Sep 17 00:00:00 2001 From: x-tools-author Date: Thu, 21 Mar 2024 10:50:08 +0800 Subject: [PATCH] chore: update files of project --- Source/MainWindow.cpp | 4 +- .../ModbusStudio/xToolsModbusStudio.cpp | 52 ++-- .../ModbusStudio/xToolsModbusStudio.h | 8 +- .../ModbusStudioUI/xToolsModbusStudioUi.cpp | 268 +++++++++--------- .../ModbusStudioUI/xToolsModbusStudioUi.h | 10 +- .../ModbusStudioUI/xToolsModbusStudioUi.ui | 4 +- Source/ModbusStudio/main.cpp | 4 +- 7 files changed, 175 insertions(+), 175 deletions(-) diff --git a/Source/MainWindow.cpp b/Source/MainWindow.cpp index a20563ee..c766ba07 100644 --- a/Source/MainWindow.cpp +++ b/Source/MainWindow.cpp @@ -48,7 +48,7 @@ #endif #ifdef X_TOOLS_IMPORT_MODULE_MODBUS_STUDIO -#include "xToolsModbusUi.h" +#include "xToolsModbusStudioUi.h" #endif #define SAK_QT_CONF (qApp->applicationDirPath() + "/qt.conf") @@ -647,7 +647,7 @@ void MainWindow::initNav() QString path = ":/Resources/Icon/IconModbus.svg"; #ifdef X_TOOLS_IMPORT_MODULE_MODBUS_STUDIO - xToolsModbusUi* modbus = new xToolsModbusUi(this); + xToolsModbusStudioUi* modbus = new xToolsModbusStudioUi(this); initNav( {&navButtonGroup, xToolsUiInterface::cookedIcon(QIcon(path)), "Modbus Studio", modbus, tb}); #endif diff --git a/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.cpp b/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.cpp index 4314348f..f15102cf 100644 --- a/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.cpp +++ b/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.cpp @@ -6,7 +6,7 @@ * xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source * code directory. **************************************************************************************************/ -#include "xToolsModbusFactory.h" +#include "xToolsModbusStudio.h" #include #include @@ -19,24 +19,24 @@ #include #endif -xToolsModbusFactory::xToolsModbusFactory(QObject *parent) +xToolsModbusStudio::xToolsModbusStudio(QObject *parent) : QObject(parent) {} -xToolsModbusFactory::~xToolsModbusFactory() {} +xToolsModbusStudio::~xToolsModbusStudio() {} -xToolsModbusFactory *xToolsModbusFactory::Instance() +xToolsModbusStudio *xToolsModbusStudio::Instance() { - static xToolsModbusFactory *factory = Q_NULLPTR; + static xToolsModbusStudio *factory = Q_NULLPTR; if (!factory) { - factory = new xToolsModbusFactory(qApp); + factory = new xToolsModbusStudio(qApp); } return factory; } -const QString xToolsModbusFactory::TypeName(int type) +const QString xToolsModbusStudio::TypeName(int type) { if (type == kModbusRtuSerialClient) { return tr("RTU Client"); @@ -54,7 +54,7 @@ const QString xToolsModbusFactory::TypeName(int type) return "Unknown"; } -QModbusDevice *xToolsModbusFactory::CreateDevice(int type) +QModbusDevice *xToolsModbusStudio::CreateDevice(int type) { if (type == kModbusRtuSerialClient) { qCInfo(kLoggingCategory) << "Create rtu serial client."; @@ -84,7 +84,7 @@ QModbusDevice *xToolsModbusFactory::CreateDevice(int type) return Q_NULLPTR; } -bool xToolsModbusFactory::IsTcpDevice(QModbusDevice *modbus_device) +bool xToolsModbusStudio::IsTcpDevice(QModbusDevice *modbus_device) { if (modbus_device) { if (qobject_cast(modbus_device)) { @@ -97,7 +97,7 @@ bool xToolsModbusFactory::IsTcpDevice(QModbusDevice *modbus_device) return false; } -bool xToolsModbusFactory::IsRtuSerialDevice(QModbusDevice *modbus_device) +bool xToolsModbusStudio::IsRtuSerialDevice(QModbusDevice *modbus_device) { if (modbus_device) { #if QT_VERSION >= QT_VERSION_CHECK(6, 2, 0) @@ -118,7 +118,7 @@ bool xToolsModbusFactory::IsRtuSerialDevice(QModbusDevice *modbus_device) return false; } -bool xToolsModbusFactory::IsTcpDeviceType(int type) +bool xToolsModbusStudio::IsTcpDeviceType(int type) { bool is_tcp = (type == kModbusTcpClient); is_tcp |= (type == kModbusTcpServer); @@ -126,7 +126,7 @@ bool xToolsModbusFactory::IsTcpDeviceType(int type) return is_tcp; } -bool xToolsModbusFactory::IsRtuSerialDeviceType(int type) +bool xToolsModbusStudio::IsRtuSerialDeviceType(int type) { bool is_rtu = (type == kModbusRtuSerialClient); is_rtu |= (type == kModbusRtuSerialServer); @@ -134,7 +134,7 @@ bool xToolsModbusFactory::IsRtuSerialDeviceType(int type) return is_rtu; } -bool xToolsModbusFactory::IsServerDevice(QModbusDevice *modbus_device) +bool xToolsModbusStudio::IsServerDevice(QModbusDevice *modbus_device) { if (modbus_device && qobject_cast(modbus_device)) { return true; @@ -143,7 +143,7 @@ bool xToolsModbusFactory::IsServerDevice(QModbusDevice *modbus_device) return false; } -bool xToolsModbusFactory::IsClientDevice(QModbusDevice *modbus_device) +bool xToolsModbusStudio::IsClientDevice(QModbusDevice *modbus_device) { if (modbus_device && qobject_cast(modbus_device)) { return true; @@ -152,7 +152,7 @@ bool xToolsModbusFactory::IsClientDevice(QModbusDevice *modbus_device) return false; } -bool xToolsModbusFactory::ConnectDeivce(QModbusDevice *modbus_device) +bool xToolsModbusStudio::ConnectDeivce(QModbusDevice *modbus_device) { if (modbus_device) { return modbus_device->connectDevice(); @@ -161,7 +161,7 @@ bool xToolsModbusFactory::ConnectDeivce(QModbusDevice *modbus_device) return false; } -bool xToolsModbusFactory::IsConnected(QModbusDevice *modbus_device) +bool xToolsModbusStudio::IsConnected(QModbusDevice *modbus_device) { if (modbus_device) { if (modbus_device->state() == QModbusDevice::ConnectedState) { @@ -172,7 +172,7 @@ bool xToolsModbusFactory::IsConnected(QModbusDevice *modbus_device) return false; } -bool xToolsModbusFactory::IsValidModbusReply(QModbusReply *reply) +bool xToolsModbusStudio::IsValidModbusReply(QModbusReply *reply) { if (reply && !reply->isFinished()) { return true; @@ -181,7 +181,7 @@ bool xToolsModbusFactory::IsValidModbusReply(QModbusReply *reply) return false; } -bool xToolsModbusFactory::SetServerData(QModbusDevice *server, +bool xToolsModbusStudio::SetServerData(QModbusDevice *server, QModbusDataUnit::RegisterType table, int address, int data, @@ -200,7 +200,7 @@ bool xToolsModbusFactory::SetServerData(QModbusDevice *server, return is_ok; } -QList xToolsModbusFactory::GetServerData(QModbusDevice *server, +QList xToolsModbusStudio::GetServerData(QModbusDevice *server, QModbusDataUnit::RegisterType table, int address, int quantity) @@ -224,7 +224,7 @@ QList xToolsModbusFactory::GetServerData(QModbusDevice *server, return values; } -void xToolsModbusFactory::DeleteModbusDevuce(QModbusDevice **modbus_device) +void xToolsModbusStudio::DeleteModbusDevuce(QModbusDevice **modbus_device) { if (*modbus_device) { QModbusServer *server = qobject_cast(*modbus_device); @@ -237,7 +237,7 @@ void xToolsModbusFactory::DeleteModbusDevuce(QModbusDevice **modbus_device) } } -QModbusDevice *xToolsModbusFactory::CreateRtuSerialDevice( +QModbusDevice *xToolsModbusStudio::CreateRtuSerialDevice( int type, const QString &port_name, int parity, int baud_rate, int data_bits, int stop_bits) { QModbusDevice *device = CreateDevice(type); @@ -257,7 +257,7 @@ QModbusDevice *xToolsModbusFactory::CreateRtuSerialDevice( return device; } -QModbusDevice *xToolsModbusFactory::CreateTcpDevice(int type, QString address, int port) +QModbusDevice *xToolsModbusStudio::CreateTcpDevice(int type, QString address, int port) { QModbusDevice *device = CreateDevice(type); if (IsTcpDevice(device)) { @@ -271,7 +271,7 @@ QModbusDevice *xToolsModbusFactory::CreateTcpDevice(int type, QString address, i return device; } -void xToolsModbusFactory::SetClientDeviceParameters(QModbusDevice *client, +void xToolsModbusStudio::SetClientDeviceParameters(QModbusDevice *client, int timeout, int number_of_retries) { @@ -286,7 +286,7 @@ void xToolsModbusFactory::SetClientDeviceParameters(QModbusDevice *client, } } -void xToolsModbusFactory::SetServerDeviceParameters(QModbusDevice *server, +void xToolsModbusStudio::SetServerDeviceParameters(QModbusDevice *server, int address, bool device_busy, bool listen_only_mode) @@ -303,7 +303,7 @@ void xToolsModbusFactory::SetServerDeviceParameters(QModbusDevice *server, } } -QModbusReply *xToolsModbusFactory::SendWriteRequest(QModbusDevice *modbus_device, +QModbusReply *xToolsModbusStudio::SendWriteRequest(QModbusDevice *modbus_device, int register_type, int start_address, #if QT_VERSION < QT_VERSION_CHECK(6, 2, 0) @@ -332,7 +332,7 @@ QModbusReply *xToolsModbusFactory::SendWriteRequest(QModbusDevice *modbus_device return Q_NULLPTR; } -QModbusReply *xToolsModbusFactory::SendRawRequest(QModbusDevice *modbus_device, +QModbusReply *xToolsModbusStudio::SendRawRequest(QModbusDevice *modbus_device, int server_address, int function_code, const QByteArray &data) diff --git a/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.h b/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.h index c3fa8b46..f9ba27e3 100644 --- a/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.h +++ b/Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.h @@ -14,7 +14,7 @@ #include #include -class xToolsModbusFactory : public QObject +class xToolsModbusStudio : public QObject { Q_OBJECT public: @@ -27,11 +27,11 @@ public: Q_ENUM(ModbusDeviceType) private: - xToolsModbusFactory(QObject *parent = Q_NULLPTR); + xToolsModbusStudio(QObject *parent = Q_NULLPTR); public: - ~xToolsModbusFactory(); - static xToolsModbusFactory *Instance(); + ~xToolsModbusStudio(); + static xToolsModbusStudio *Instance(); public: const QString TypeName(int type); diff --git a/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.cpp b/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.cpp index dc56d329..4c6d941e 100644 --- a/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.cpp +++ b/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.cpp @@ -6,8 +6,8 @@ * xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source * code directory. **************************************************************************************************/ -#include "xToolsModbusUi.h" -#include "ui_xToolsModbusUi.h" +#include "xToolsModbusStudioUi.h" +#include "ui_xToolsModbusStudioUi.h" #include #include @@ -39,7 +39,7 @@ #include #endif -#include "xToolsModbusFactory.h" +#include "xToolsModbusStudio.h" #include "xToolsSettings.h" #define RXCOLOR "green" @@ -97,9 +97,9 @@ public: } }; -xToolsModbusUi::xToolsModbusUi(QWidget *parent) +xToolsModbusStudioUi::xToolsModbusStudioUi(QWidget *parent) : QWidget{parent} - , ui(new Ui::xToolsModbusUi) + , ui(new Ui::xToolsModbusStudioUi) , modbus_device_(Q_NULLPTR) , register_model_(Q_NULLPTR) , key_ctx_(new SAKModbusUiSettingKeys) @@ -120,12 +120,12 @@ xToolsModbusUi::xToolsModbusUi(QWidget *parent) UpdateClientReadWriteButtonState(); } -xToolsModbusUi::~xToolsModbusUi() +xToolsModbusStudioUi::~xToolsModbusStudioUi() { delete ui; } -void xToolsModbusUi::InitComponents() +void xToolsModbusStudioUi::InitComponents() { InitComponentDevices(); InitComponentAddress(); @@ -140,15 +140,15 @@ void xToolsModbusUi::InitComponents() InitComponentRegisterTabWidget(); } -void xToolsModbusUi::InitComponentDevices() +void xToolsModbusStudioUi::InitComponentDevices() { - ui->device_list_->addItem(tr("RtuClient"), xToolsModbusFactory::kModbusRtuSerialClient); - ui->device_list_->addItem(tr("RtuServer"), xToolsModbusFactory::kModbusRtuSerialServer); - ui->device_list_->addItem(tr("TcpClient"), xToolsModbusFactory::kModbusTcpClient); - ui->device_list_->addItem(tr("TcpServer"), xToolsModbusFactory::kModbusTcpServer); + ui->device_list_->addItem(tr("RtuClient"), xToolsModbusStudio::kModbusRtuSerialClient); + ui->device_list_->addItem(tr("RtuServer"), xToolsModbusStudio::kModbusRtuSerialServer); + ui->device_list_->addItem(tr("TcpClient"), xToolsModbusStudio::kModbusTcpClient); + ui->device_list_->addItem(tr("TcpServer"), xToolsModbusStudio::kModbusTcpServer); } -void xToolsModbusUi::InitComponentAddress() +void xToolsModbusStudioUi::InitComponentAddress() { ui->address_combo_box->clear(); QList addresses = QNetworkInterface::allAddresses(); @@ -159,7 +159,7 @@ void xToolsModbusUi::InitComponentAddress() } } -void xToolsModbusUi::InitComponentPortName() +void xToolsModbusStudioUi::InitComponentPortName() { ui->port_name_->clear(); QList infos = QSerialPortInfo::availablePorts(); @@ -168,7 +168,7 @@ void xToolsModbusUi::InitComponentPortName() } } -void xToolsModbusUi::InitComponnetBaudRate() +void xToolsModbusStudioUi::InitComponnetBaudRate() { ui->baud_rate_->clear(); QList bds = QSerialPortInfo::standardBaudRates(); @@ -177,7 +177,7 @@ void xToolsModbusUi::InitComponnetBaudRate() } } -void xToolsModbusUi::InitComponnetDataBits() +void xToolsModbusStudioUi::InitComponnetDataBits() { ui->data_bits_->clear(); ui->data_bits_->addItem("8", QSerialPort::Data8); @@ -186,7 +186,7 @@ void xToolsModbusUi::InitComponnetDataBits() ui->data_bits_->addItem("5", QSerialPort::Data5); } -void xToolsModbusUi::InitComponnetStopBits() +void xToolsModbusStudioUi::InitComponnetStopBits() { ui->stop_bits_->clear(); ui->stop_bits_->addItem("1", QSerialPort::OneStop); @@ -196,7 +196,7 @@ void xToolsModbusUi::InitComponnetStopBits() ui->stop_bits_->addItem("2", QSerialPort::TwoStop); } -void xToolsModbusUi::InitComponnetParity() +void xToolsModbusStudioUi::InitComponnetParity() { ui->parity_->clear(); ui->parity_->addItem(tr("NoParity"), QSerialPort::NoParity); @@ -206,7 +206,7 @@ void xToolsModbusUi::InitComponnetParity() ui->parity_->addItem(tr("MarkParity"), QSerialPort::MarkParity); } -void xToolsModbusUi::InitComponentFunctionCode() +void xToolsModbusStudioUi::InitComponentFunctionCode() { const QString str0x01 = tr("0x01-ReadCoils"); const QString str0x02 = tr("0x02-ReadDiscreteInputs"); @@ -236,13 +236,13 @@ void xToolsModbusUi::InitComponentFunctionCode() ui->function_code_->addItem(str0x10, func0x10); } -void xToolsModbusUi::InitComponentRegisterTableView() +void xToolsModbusStudioUi::InitComponentRegisterTableView() { QTableView *table_view = CreateTableView(1, ui->client_registers_); register_model_ = qobject_cast(table_view->model()); } -void xToolsModbusUi::InitComponentInput() +void xToolsModbusStudioUi::InitComponentInput() { QRegularExpression re("([0-9a-fA-F][0-9a-fA-F][ ])*"); QLineEdit *le = ui->pdu_->lineEdit(); @@ -251,7 +251,7 @@ void xToolsModbusUi::InitComponentInput() le->clear(); } -void xToolsModbusUi::InitComponentRegisterTabWidget() +void xToolsModbusStudioUi::InitComponentRegisterTabWidget() { QTabWidget *tab_widget = ui->server_registers_; QStringList titles = QStringList() << tr("Coils") << tr("DiscreteInputs") @@ -263,7 +263,7 @@ void xToolsModbusUi::InitComponentRegisterTabWidget() } } -void xToolsModbusUi::InitSettings() +void xToolsModbusStudioUi::InitSettings() { InitSettingsDevice(); InitSettingsNetwork(); @@ -274,7 +274,7 @@ void xToolsModbusUi::InitSettings() InitSettingsInput(); } -void xToolsModbusUi::InitSettingsDevice() +void xToolsModbusStudioUi::InitSettingsDevice() { int deviceIndex = settings_->value(key_ctx_->device_index).toInt(); if (deviceIndex >= 0 && deviceIndex < ui->device_list_->count()) { @@ -282,7 +282,7 @@ void xToolsModbusUi::InitSettingsDevice() } } -void xToolsModbusUi::InitSettingsNetwork() +void xToolsModbusStudioUi::InitSettingsNetwork() { QString address = settings_->value(key_ctx_->address).toString(); ui->address_combo_box->setCurrentText(address); @@ -295,7 +295,7 @@ void xToolsModbusUi::InitSettingsNetwork() ui->port_spin_box->setValue(port); } -void xToolsModbusUi::InitSettingsSerialPort() +void xToolsModbusStudioUi::InitSettingsSerialPort() { auto SetComboBoxIndex = [](int index, QComboBox *cb) { if (index >= 0 && index < cb->count()) { @@ -320,7 +320,7 @@ void xToolsModbusUi::InitSettingsSerialPort() SetComboBoxIndex(index, ui->stop_bits_); } -void xToolsModbusUi::InitSettingsClient() +void xToolsModbusStudioUi::InitSettingsClient() { int timeout = settings_->value(key_ctx_->client_timeout).toInt(); ui->timeout_->setValue(timeout < 100 ? 100 : timeout); @@ -330,7 +330,7 @@ void xToolsModbusUi::InitSettingsClient() ui->repeat_time_->setValue(repeatTimes); } -void xToolsModbusUi::InitSettingsServer() +void xToolsModbusStudioUi::InitSettingsServer() { bool isBusy = settings_->value(key_ctx_->server_is_busy).toBool(); ui->device_busy_->setChecked(isBusy); @@ -343,7 +343,7 @@ void xToolsModbusUi::InitSettingsServer() ui->server_address->setValue(address); } -void xToolsModbusUi::InitSettingsClientOperations() +void xToolsModbusStudioUi::InitSettingsClientOperations() { int index = settings_->value(key_ctx_->function_code).toInt(); if (index >= 0 && index < ui->function_code_->count()) { @@ -360,7 +360,7 @@ void xToolsModbusUi::InitSettingsClientOperations() ui->quantity_->setValue(number); } -void xToolsModbusUi::InitSettingsInput() +void xToolsModbusStudioUi::InitSettingsInput() { ui->pdu_->clear(); settings_->beginReadArray(key_ctx_->send_history); @@ -377,7 +377,7 @@ void xToolsModbusUi::InitSettingsInput() ui->pdu_->setCurrentIndex(index - 1); } -void xToolsModbusUi::InitSignals() +void xToolsModbusStudioUi::InitSignals() { InitSignalsDevice(); InitSignalsNetworking(); @@ -387,95 +387,95 @@ void xToolsModbusUi::InitSignals() InitSignalsClientOperations(); } -void xToolsModbusUi::InitSignalsDevice() +void xToolsModbusStudioUi::InitSignalsDevice() { connect(ui->device_list_, QOverload::of(&QComboBox::currentIndexChanged), this, - &xToolsModbusUi::OnDeviceTypeChanged); - connect(ui->open_button_, &QPushButton::clicked, this, &xToolsModbusUi::OnOpenClicked); - connect(ui->cloese_button_, &QPushButton::clicked, this, &xToolsModbusUi::OnCloseClicked); + &xToolsModbusStudioUi::OnDeviceTypeChanged); + connect(ui->open_button_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnOpenClicked); + connect(ui->cloese_button_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnCloseClicked); } -void xToolsModbusUi::InitSignalsNetworking() +void xToolsModbusStudioUi::InitSignalsNetworking() { connect(ui->address_combo_box, &QComboBox::currentTextChanged, this, - &xToolsModbusUi::OnAddressChanged); + &xToolsModbusStudioUi::OnAddressChanged); connect(ui->port_spin_box, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnPortChanged); + &xToolsModbusStudioUi::OnPortChanged); } -void xToolsModbusUi::InitSignalsSerialPort() +void xToolsModbusStudioUi::InitSignalsSerialPort() { - connect(ui->port_name_, &QComboBox::currentTextChanged, this, &xToolsModbusUi::OnPortNameChanged); + connect(ui->port_name_, &QComboBox::currentTextChanged, this, &xToolsModbusStudioUi::OnPortNameChanged); connect(ui->parity_, QOverload::of(&QComboBox::currentIndexChanged), this, - &xToolsModbusUi::OnParityChanged); - connect(ui->baud_rate_, &QComboBox::currentTextChanged, this, &xToolsModbusUi::OnBaudRateChanged); + &xToolsModbusStudioUi::OnParityChanged); + connect(ui->baud_rate_, &QComboBox::currentTextChanged, this, &xToolsModbusStudioUi::OnBaudRateChanged); connect(ui->data_bits_, QOverload::of(&QComboBox::currentIndexChanged), this, - &xToolsModbusUi::OnDataBitsChanged); + &xToolsModbusStudioUi::OnDataBitsChanged); connect(ui->stop_bits_, QOverload::of(&QComboBox::currentIndexChanged), this, - &xToolsModbusUi::OnStopBistChanged); + &xToolsModbusStudioUi::OnStopBistChanged); } -void xToolsModbusUi::InitSignalsClient() +void xToolsModbusStudioUi::InitSignalsClient() { connect(ui->timeout_, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnClientTimeoutChanged); + &xToolsModbusStudioUi::OnClientTimeoutChanged); connect(ui->repeat_time_, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnClientRepeatTimeChanged); + &xToolsModbusStudioUi::OnClientRepeatTimeChanged); } -void xToolsModbusUi::InitSignalsServer() +void xToolsModbusStudioUi::InitSignalsServer() { - connect(ui->device_busy_, &QCheckBox::clicked, this, &xToolsModbusUi::OnServerIsBusyChanged); + connect(ui->device_busy_, &QCheckBox::clicked, this, &xToolsModbusStudioUi::OnServerIsBusyChanged); connect(ui->listen_only_mode_, &QCheckBox::clicked, this, - &xToolsModbusUi::OnServerJustListenChanged); + &xToolsModbusStudioUi::OnServerJustListenChanged); connect(ui->server_address, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnServerAddressChanged); + &xToolsModbusStudioUi::OnServerAddressChanged); } -void xToolsModbusUi::InitSignalsClientOperations() +void xToolsModbusStudioUi::InitSignalsClientOperations() { connect(ui->function_code_, &QComboBox::currentTextChanged, this, - &xToolsModbusUi::OnFunctionCodeChanged); + &xToolsModbusStudioUi::OnFunctionCodeChanged); connect(ui->device_address_, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnTargetAddressChanged); + &xToolsModbusStudioUi::OnTargetAddressChanged); connect(ui->start_address_, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnStartAddressChanged); + &xToolsModbusStudioUi::OnStartAddressChanged); connect(ui->quantity_, QOverload::of(&QSpinBox::valueChanged), this, - &xToolsModbusUi::OnAddressNumberChanged); - connect(ui->read_, &QPushButton::clicked, this, &xToolsModbusUi::OnReadClicked); - connect(ui->write_, &QPushButton::clicked, this, &xToolsModbusUi::OnWriteClicked); - connect(ui->send_, &QPushButton::clicked, this, &xToolsModbusUi::OnSendClicked); + &xToolsModbusStudioUi::OnAddressNumberChanged); + connect(ui->read_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnReadClicked); + connect(ui->write_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnWriteClicked); + connect(ui->send_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnSendClicked); } -void xToolsModbusUi::OnErrorOccurred() +void xToolsModbusStudioUi::OnErrorOccurred() { outputMessage(modbus_device_->errorString(), true, "", "error"); if (modbus_device_->error() == QModbusDevice::ConnectionError) { @@ -485,13 +485,13 @@ void xToolsModbusUi::OnErrorOccurred() } } -void xToolsModbusUi::OnDeviceTypeChanged() +void xToolsModbusStudioUi::OnDeviceTypeChanged() { int type = ui->device_list_->currentData().toInt(); - bool isSerial = (type == xToolsModbusFactory::kModbusRtuSerialClient - || type == xToolsModbusFactory::kModbusRtuSerialServer); - bool isClient = (type == xToolsModbusFactory::kModbusRtuSerialClient - || type == xToolsModbusFactory::kModbusTcpClient); + bool isSerial = (type == xToolsModbusStudio::kModbusRtuSerialClient + || type == xToolsModbusStudio::kModbusRtuSerialServer); + bool isClient = (type == xToolsModbusStudio::kModbusRtuSerialClient + || type == xToolsModbusStudio::kModbusTcpClient); // Hide ui component first then show ui component, // or the window will be resize to the max size of default. @@ -522,20 +522,20 @@ void xToolsModbusUi::OnDeviceTypeChanged() settings_->setValue(key_ctx_->device_index, type); } -void xToolsModbusUi::OnCloseClicked() +void xToolsModbusStudioUi::OnCloseClicked() { - xToolsModbusFactory::Instance()->DeleteModbusDevuce(&modbus_device_); + xToolsModbusStudio::Instance()->DeleteModbusDevuce(&modbus_device_); UpdateUiState(false); } -void xToolsModbusUi::OnOpenClicked() +void xToolsModbusStudioUi::OnOpenClicked() { ui->open_button_->setEnabled(false); - xToolsModbusFactory::Instance()->DeleteModbusDevuce(&modbus_device_); + xToolsModbusStudio::Instance()->DeleteModbusDevuce(&modbus_device_); modbus_device_ = CreateModbusDevice(); - if (xToolsModbusFactory::Instance()->IsServerDevice(modbus_device_)) { + if (xToolsModbusStudio::Instance()->IsServerDevice(modbus_device_)) { if (!UpdateServerMap(modbus_device_)) { ui->open_button_->setEnabled(true); qCWarning(kLoggingCategory) << "Can not reset server map!"; @@ -546,8 +546,8 @@ void xToolsModbusUi::OnOpenClicked() QModbusServer *server = qobject_cast(modbus_device_); UpdateServerRegistersData(); - connect(server, &QModbusServer::dataWritten, this, &xToolsModbusUi::OnDateWritten); - } else if (xToolsModbusFactory::Instance()->IsClientDevice(modbus_device_)) { + connect(server, &QModbusServer::dataWritten, this, &xToolsModbusStudioUi::OnDateWritten); + } else if (xToolsModbusStudio::Instance()->IsClientDevice(modbus_device_)) { UpdateClientParameters(); } else { ui->open_button_->setEnabled(true); @@ -555,8 +555,8 @@ void xToolsModbusUi::OnOpenClicked() return; } - connect(modbus_device_, &QModbusDevice::errorOccurred, this, &xToolsModbusUi::OnErrorOccurred); - xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); + connect(modbus_device_, &QModbusDevice::errorOccurred, this, &xToolsModbusStudioUi::OnErrorOccurred); + xToolsModbusStudio *factory = xToolsModbusStudio::Instance(); bool connected = factory->ConnectDeivce(modbus_device_); if (!connected) { QString errStr = modbus_device_->errorString(); @@ -569,106 +569,106 @@ void xToolsModbusUi::OnOpenClicked() UpdateUiState(connected); } -void xToolsModbusUi::OnAddressChanged() +void xToolsModbusStudioUi::OnAddressChanged() { settings_->setValue(key_ctx_->address, ui->address_combo_box->currentText()); } -void xToolsModbusUi::OnPortChanged() +void xToolsModbusStudioUi::OnPortChanged() { settings_->setValue(key_ctx_->port, ui->port_spin_box->value()); } -void xToolsModbusUi::OnPortNameChanged() +void xToolsModbusStudioUi::OnPortNameChanged() { settings_->setValue(key_ctx_->port_name, ui->port_name_->currentText()); } -void xToolsModbusUi::OnParityChanged() +void xToolsModbusStudioUi::OnParityChanged() { settings_->setValue(key_ctx_->parity, ui->parity_->currentIndex()); } -void xToolsModbusUi::OnBaudRateChanged() +void xToolsModbusStudioUi::OnBaudRateChanged() { settings_->setValue(key_ctx_->baud_rate, ui->baud_rate_->currentText()); } -void xToolsModbusUi::OnDataBitsChanged() +void xToolsModbusStudioUi::OnDataBitsChanged() { settings_->setValue(key_ctx_->data_bits, ui->data_bits_->currentIndex()); } -void xToolsModbusUi::OnStopBistChanged() +void xToolsModbusStudioUi::OnStopBistChanged() { settings_->setValue(key_ctx_->stop_bits, ui->stop_bits_->currentIndex()); } -void xToolsModbusUi::OnInvokeRefresh() +void xToolsModbusStudioUi::OnInvokeRefresh() { InitComponentPortName(); } -void xToolsModbusUi::OnClientTimeoutChanged() +void xToolsModbusStudioUi::OnClientTimeoutChanged() { settings_->setValue(key_ctx_->client_timeout, ui->timeout_->value()); UpdateClientParameters(); } -void xToolsModbusUi::OnClientRepeatTimeChanged() +void xToolsModbusStudioUi::OnClientRepeatTimeChanged() { settings_->setValue(key_ctx_->client_repeat_time, ui->repeat_time_->value()); UpdateClientParameters(); } -void xToolsModbusUi::OnServerIsBusyChanged() +void xToolsModbusStudioUi::OnServerIsBusyChanged() { settings_->setValue(key_ctx_->server_is_busy, ui->device_busy_->isChecked()); UpdateServerParameters(); } -void xToolsModbusUi::OnServerJustListenChanged() +void xToolsModbusStudioUi::OnServerJustListenChanged() { settings_->setValue(key_ctx_->server_just_listen, ui->listen_only_mode_->isChecked()); UpdateServerParameters(); } -void xToolsModbusUi::OnServerAddressChanged() +void xToolsModbusStudioUi::OnServerAddressChanged() { settings_->setValue(key_ctx_->server_address, ui->server_address->value()); UpdateServerParameters(); } -void xToolsModbusUi::OnFunctionCodeChanged() +void xToolsModbusStudioUi::OnFunctionCodeChanged() { settings_->setValue(key_ctx_->function_code, ui->function_code_->currentIndex()); UpdateClientReadWriteButtonState(); } -void xToolsModbusUi::OnTargetAddressChanged() +void xToolsModbusStudioUi::OnTargetAddressChanged() { settings_->setValue(key_ctx_->target_address, ui->device_address_->value()); } -void xToolsModbusUi::OnStartAddressChanged() +void xToolsModbusStudioUi::OnStartAddressChanged() { settings_->setValue(key_ctx_->start_address, ui->start_address_->value()); UpdateClientTableView(); } -void xToolsModbusUi::OnAddressNumberChanged() +void xToolsModbusStudioUi::OnAddressNumberChanged() { settings_->setValue(key_ctx_->address_number, ui->quantity_->value()); UpdateClientTableView(); } -void xToolsModbusUi::OnReadClicked() +void xToolsModbusStudioUi::OnReadClicked() { if (!IsConnected()) { return; } - if (!xToolsModbusFactory::Instance()->IsClientDevice(modbus_device_)) { + if (!xToolsModbusStudio::Instance()->IsClientDevice(modbus_device_)) { return; } @@ -688,7 +688,7 @@ void xToolsModbusUi::OnReadClicked() QModbusDataUnit data_unit(type, start_address, quantity); QModbusClient *client = qobject_cast(modbus_device_); QModbusReply *reply = client->sendReadRequest(data_unit, server_address); - if (!xToolsModbusFactory::Instance()->IsValidModbusReply(reply)) { + if (!xToolsModbusStudio::Instance()->IsValidModbusReply(reply)) { return; } @@ -704,7 +704,7 @@ void xToolsModbusUi::OnReadClicked() }); } -void xToolsModbusUi::OnWriteClicked() +void xToolsModbusStudioUi::OnWriteClicked() { if (!IsConnected()) { return; @@ -715,13 +715,13 @@ void xToolsModbusUi::OnWriteClicked() int server_address = ui->device_address_->value(); quint8 function_code = GetClientFunctionCode(); QList values = GetClientRegisterValue(); - xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); + xToolsModbusStudio *factory = xToolsModbusStudio::Instance(); QModbusReply *reply = factory->SendWriteRequest(modbus_device_, registerType, start_address, values, server_address); - if (xToolsModbusFactory::Instance()->IsValidModbusReply(reply)) { + if (xToolsModbusStudio::Instance()->IsValidModbusReply(reply)) { connect(reply, &QModbusReply::finished, this, [=]() { OutputModbusReply(reply, function_code); reply->deleteLater(); @@ -732,7 +732,7 @@ void xToolsModbusUi::OnWriteClicked() } } -void xToolsModbusUi::OnSendClicked() +void xToolsModbusStudioUi::OnSendClicked() { if (!IsConnected()) { return; @@ -749,7 +749,7 @@ void xToolsModbusUi::OnSendClicked() if (!pdu.isEmpty()) { function_code = pdu.at(0); } - xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); + xToolsModbusStudio *factory = xToolsModbusStudio::Instance(); QModbusReply *reply = factory->SendRawRequest(modbus_device_, server_address, function_code, @@ -759,7 +759,7 @@ void xToolsModbusUi::OnSendClicked() << "server address:" << server_address << "function code:" << function_code << "data:" << QString(pdu.toHex(' ')); - if (xToolsModbusFactory::Instance()->IsValidModbusReply(reply)) { + if (xToolsModbusStudio::Instance()->IsValidModbusReply(reply)) { connect(reply, &QModbusReply::finished, this, [=]() { OutputModbusReply(reply, function_code); reply->deleteLater(); @@ -791,14 +791,14 @@ void xToolsModbusUi::OnSendClicked() settings_->setValue(key_ctx_->send_history_index, index); } -void xToolsModbusUi::OnDateWritten(QModbusDataUnit::RegisterType table, int address, int size) +void xToolsModbusStudioUi::OnDateWritten(QModbusDataUnit::RegisterType table, int address, int size) { qCInfo(kLoggingCategory) << "Data written:" << "table:" << table << "start address:" << address << "size:" << size; QTableView *tv = GetTableView(table); QStandardItemModel *model = qobject_cast(tv->model()); QModbusServer *server = qobject_cast(modbus_device_); - QList data = xToolsModbusFactory::Instance()->GetServerData(server, table, address, size); + QList data = xToolsModbusStudio::Instance()->GetServerData(server, table, address, size); size = qMin(data.count(), size); for (int i = 0; i < size; i++) { int row = address + i; @@ -817,7 +817,7 @@ void xToolsModbusUi::OnDateWritten(QModbusDataUnit::RegisterType table, int addr tv->viewport()->update(); } -void xToolsModbusUi::OnItemChanged(QStandardItem *item) +void xToolsModbusStudioUi::OnItemChanged(QStandardItem *item) { if (!item) { return; @@ -827,7 +827,7 @@ void xToolsModbusUi::OnItemChanged(QStandardItem *item) return; } - if (xToolsModbusFactory::Instance()->IsServerDevice(modbus_device_)) { + if (xToolsModbusStudio::Instance()->IsServerDevice(modbus_device_)) { int address = item->row(); int current_index = ui->server_registers_->currentIndex(); QModbusDataUnit::RegisterType table = QModbusDataUnit::Invalid; @@ -845,31 +845,31 @@ void xToolsModbusUi::OnItemChanged(QStandardItem *item) } quint16 value = item->text().toInt(Q_NULLPTR, 16); - xToolsModbusFactory::Instance()->SetServerData(modbus_device_, table, address, value); + xToolsModbusStudio::Instance()->SetServerData(modbus_device_, table, address, value); } } -QModbusDevice *xToolsModbusUi::CreateModbusDevice() +QModbusDevice *xToolsModbusStudioUi::CreateModbusDevice() { QModbusDevice *device = Q_NULLPTR; int type = ui->device_list_->currentData().toInt(); - if (xToolsModbusFactory::Instance()->IsRtuSerialDeviceType(type)) { + if (xToolsModbusStudio::Instance()->IsRtuSerialDeviceType(type)) { QString port_name = ui->port_name_->currentText(); int parity = ui->parity_->currentData().toInt(); int baud_rate = ui->baud_rate_->currentData().toInt(); int data_bits = ui->data_bits_->currentData().toInt(); int stop_bits = ui->stop_bits_->currentData().toInt(); - xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); + xToolsModbusStudio *factory = xToolsModbusStudio::Instance(); device = factory->CreateRtuSerialDevice(type, port_name, parity, baud_rate, data_bits, stop_bits); - } else if (xToolsModbusFactory::Instance()->IsTcpDeviceType(type)) { + } else if (xToolsModbusStudio::Instance()->IsTcpDeviceType(type)) { QString address = ui->address_combo_box->currentText(); int port = ui->port_spin_box->value(); - xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); + xToolsModbusStudio *factory = xToolsModbusStudio::Instance(); device = factory->CreateTcpDevice(type, address, port); } else { Q_ASSERT_X(false, __FUNCTION__, "Unknown device type"); @@ -878,7 +878,7 @@ QModbusDevice *xToolsModbusUi::CreateModbusDevice() return device; } -QTableView *xToolsModbusUi::CreateTableView(int row_count, QTableView *table_view) +QTableView *xToolsModbusStudioUi::CreateTableView(int row_count, QTableView *table_view) { if (!table_view) { table_view = new QTableView(this); @@ -909,12 +909,12 @@ QTableView *xToolsModbusUi::CreateTableView(int row_count, QTableView *table_vie } model->blockSignals(false); - connect(model, &QStandardItemModel::itemChanged, this, &xToolsModbusUi::OnItemChanged); + connect(model, &QStandardItemModel::itemChanged, this, &xToolsModbusStudioUi::OnItemChanged); return table_view; } -void xToolsModbusUi::UpdateUiState(bool connected) +void xToolsModbusStudioUi::UpdateUiState(bool connected) { ui->device_list_->setEnabled(!connected); ui->cloese_button_->setEnabled(connected); @@ -927,7 +927,7 @@ void xToolsModbusUi::UpdateUiState(bool connected) #endif } -void xToolsModbusUi::UpdateClientTableView() +void xToolsModbusStudioUi::UpdateClientTableView() { int number = ui->quantity_->value(); int rowCount = register_model_->rowCount(); @@ -942,7 +942,7 @@ void xToolsModbusUi::UpdateClientTableView() UpdateClientTableViewAddress(ui->client_registers_, start_address); } -void xToolsModbusUi::UpdateClientTableViewData(const QList &values) +void xToolsModbusStudioUi::UpdateClientTableViewData(const QList &values) { for (int row = 0; row < values.count(); row++) { int value = values.at(row); @@ -961,7 +961,7 @@ void xToolsModbusUi::UpdateClientTableViewData(const QList &values) ui->client_registers_->viewport()->update(); } -void xToolsModbusUi::UpdateClientReadWriteButtonState() +void xToolsModbusStudioUi::UpdateClientReadWriteButtonState() { QStringList list = ui->function_code_->currentText().split('-'); int code = list.length() ? list.first().toInt(Q_NULLPTR, 16) : 0; @@ -978,14 +978,14 @@ void xToolsModbusUi::UpdateClientReadWriteButtonState() ui->write_->setEnabled(!is_reading_operation); } -void xToolsModbusUi::UpdateClientParameters() +void xToolsModbusStudioUi::UpdateClientParameters() { int timeout = ui->timeout_->value(); int repeat_time = ui->repeat_time_->value(); - xToolsModbusFactory::Instance()->SetClientDeviceParameters(modbus_device_, timeout, repeat_time); + xToolsModbusStudio::Instance()->SetClientDeviceParameters(modbus_device_, timeout, repeat_time); } -void xToolsModbusUi::UpdateClientTableViewAddress(QTableView *view, int start_address) +void xToolsModbusStudioUi::UpdateClientTableViewAddress(QTableView *view, int start_address) { auto *model = qobject_cast(view->model()); for (int row = 0; row < model->rowCount(); row++) { @@ -1003,18 +1003,18 @@ void xToolsModbusUi::UpdateClientTableViewAddress(QTableView *view, int start_ad } } -void xToolsModbusUi::UpdateServerParameters() +void xToolsModbusStudioUi::UpdateServerParameters() { bool device_busy = ui->device_busy_->isChecked(); bool listen_only_mode = ui->listen_only_mode_->isChecked(); int address = ui->server_address->value(); - xToolsModbusFactory::Instance()->SetServerDeviceParameters(modbus_device_, + xToolsModbusStudio::Instance()->SetServerDeviceParameters(modbus_device_, address, device_busy, listen_only_mode); } -bool xToolsModbusUi::UpdateServerMap(QModbusDevice *server) +bool xToolsModbusStudioUi::UpdateServerMap(QModbusDevice *server) { if (server && qobject_cast(server)) { QVector values(UINT16_MAX + 1, 0); @@ -1036,7 +1036,7 @@ bool xToolsModbusUi::UpdateServerMap(QModbusDevice *server) return false; } -void xToolsModbusUi::UpdateServerRegistersData() +void xToolsModbusStudioUi::UpdateServerRegistersData() { for (int i = 0; i < 4; i++) { QWidget *widget = ui->server_registers_->widget(i); @@ -1060,12 +1060,12 @@ void xToolsModbusUi::UpdateServerRegistersData() QStandardItem *item = model->item(row, 1); quint16 value = item ? item->text().toInt(Q_NULLPTR, 16) : 0; auto table = static_cast(type); - xToolsModbusFactory::Instance()->SetServerData(modbus_device_, table, row, value, false); + xToolsModbusStudio::Instance()->SetServerData(modbus_device_, table, row, value, false); } } } -quint8 xToolsModbusUi::GetClientFunctionCode() +quint8 xToolsModbusStudioUi::GetClientFunctionCode() { QString txt = ui->function_code_->currentText(); QStringList list = txt.split('-', Qt::SkipEmptyParts); @@ -1076,7 +1076,7 @@ quint8 xToolsModbusUi::GetClientFunctionCode() return 0; } -QList xToolsModbusUi::GetClientRegisterValue() +QList xToolsModbusStudioUi::GetClientRegisterValue() { QList values; for (int row = 0; row < register_model_->rowCount(); row++) { @@ -1092,7 +1092,7 @@ QList xToolsModbusUi::GetClientRegisterValue() return values; } -QByteArray xToolsModbusUi::GetClientPdu() +QByteArray xToolsModbusStudioUi::GetClientPdu() { QString text = ui->pdu_->currentText(); #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0) @@ -1108,7 +1108,7 @@ QByteArray xToolsModbusUi::GetClientPdu() return data; } -QTableView *xToolsModbusUi::GetTableView(QModbusDataUnit::RegisterType table) +QTableView *xToolsModbusStudioUi::GetTableView(QModbusDataUnit::RegisterType table) { QWidget *tv = Q_NULLPTR; if (table == QModbusDataUnit::Coils) { @@ -1127,7 +1127,7 @@ QTableView *xToolsModbusUi::GetTableView(QModbusDataUnit::RegisterType table) return qobject_cast(tv); } -QList xToolsModbusUi::GetTableValues(QTableView *table_view, int row, int count) +QList xToolsModbusStudioUi::GetTableValues(QTableView *table_view, int row, int count) { if (!table_view) { qCWarning(kLoggingCategory) << "Table view can not be null!"; @@ -1154,7 +1154,7 @@ QList xToolsModbusUi::GetTableValues(QTableView *table_view, int row, i return values; } -void xToolsModbusUi::OutputModbusReply(QModbusReply *reply, int function_code) +void xToolsModbusStudioUi::OutputModbusReply(QModbusReply *reply, int function_code) { if (reply->error() != QModbusDevice::NoError) { outputMessage(reply->errorString(), true, "", "error"); @@ -1178,7 +1178,7 @@ void xToolsModbusUi::OutputModbusReply(QModbusReply *reply, int function_code) } } -void xToolsModbusUi::outputMessage(const QString &msg, +void xToolsModbusStudioUi::outputMessage(const QString &msg, bool isError, const QString &color, const QString &flag) @@ -1201,9 +1201,9 @@ void xToolsModbusUi::outputMessage(const QString &msg, ui->text_browser_->append(cookedMsg); } -bool xToolsModbusUi::IsConnected() +bool xToolsModbusStudioUi::IsConnected() { - if (xToolsModbusFactory::Instance()->IsConnected(modbus_device_)) { + if (xToolsModbusStudio::Instance()->IsConnected(modbus_device_)) { return true; } @@ -1214,7 +1214,7 @@ bool xToolsModbusUi::IsConnected() return false; } -bool xToolsModbusUi::WriteSettingsArray( +bool xToolsModbusStudioUi::WriteSettingsArray( const QString &group, const QString &key, const QString &value, int index, int max_index) { settings_->beginWriteArray(group); diff --git a/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.h b/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.h index 816a6995..cd7ecbd6 100644 --- a/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.h +++ b/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.h @@ -21,22 +21,22 @@ #include namespace Ui { -class xToolsModbusUi; +class xToolsModbusStudioUi; } struct SAKModbusUiSettingKeys; -class xToolsModbusUi : public QWidget +class xToolsModbusStudioUi : public QWidget { Q_OBJECT public: - explicit xToolsModbusUi(QWidget *parent = Q_NULLPTR); - ~xToolsModbusUi(); + explicit xToolsModbusStudioUi(QWidget *parent = Q_NULLPTR); + ~xToolsModbusStudioUi(); signals: void deviceChanged(QModbusDevice *device); private: - Ui::xToolsModbusUi *ui; + Ui::xToolsModbusStudioUi *ui; QModbusDevice *modbus_device_{Q_NULLPTR}; QSettings *settings_{Q_NULLPTR}; QStandardItemModel *register_model_{Q_NULLPTR}; diff --git a/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.ui b/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.ui index 8debfff6..f8fa29fd 100644 --- a/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.ui +++ b/Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.ui @@ -1,7 +1,7 @@ - xToolsModbusUi - + xToolsModbusStudioUi + 0 diff --git a/Source/ModbusStudio/main.cpp b/Source/ModbusStudio/main.cpp index f116137d..84172e8b 100644 --- a/Source/ModbusStudio/main.cpp +++ b/Source/ModbusStudio/main.cpp @@ -6,11 +6,11 @@ * xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source * code directory. **************************************************************************************************/ -#include "xToolsModbusUi.h" +#include "xToolsModbusStudioUi.h" #include "xToolsUi.h" int main(int argc, char* argv[]) { const QString appName = QObject::tr("Modbus Studio"); - return xToolsExec(argc, argv, appName); + return xToolsExec(argc, argv, appName); }