927 lines
26 KiB
C++
927 lines
26 KiB
C++
#include "MainWidget.h"
|
|
|
|
#include "./ui_MainWidget.h"
|
|
#include "src/data_edit.h"
|
|
#include "public_def.h"
|
|
#include <QClipboard>
|
|
#include <QDateTime>
|
|
#include <QFile>
|
|
#include <QKeyEvent>
|
|
#include <QRegularExpression>
|
|
#include <QScreen>
|
|
#include <QSettings>
|
|
#include <filesystem>
|
|
|
|
constexpr std::size_t g_OnePage = 100;
|
|
namespace fs = std::filesystem;
|
|
MainWidget::MainWidget(QWidget* parent) : QWidget(parent), ui(new Ui::MainWidget)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
setWindowTitle(u8"OneLevelXmlOpr v1.3.0");
|
|
setWindowIcon(QIcon("://resource/xml.ico"));
|
|
|
|
QScreen* primaryScreen = QGuiApplication::primaryScreen();
|
|
QRect screenGeometry = primaryScreen->geometry();
|
|
|
|
setBaseSize(screenGeometry.width() * 0.6, screenGeometry.height() * 0.9);
|
|
|
|
// setMinimumWidth(900);
|
|
// setMinimumHeight(800);
|
|
|
|
his_ = new CHistory();
|
|
attri_edit_ = new CAttributeEdit();
|
|
ini_oper_ = new CGroupIni();
|
|
ini_oper_->load_ini();
|
|
group_set_ = new CGroupSetting(this, ini_oper_);
|
|
|
|
ui->edStatus->setReadOnly(true);
|
|
ui->btnSave->setEnabled(false);
|
|
ui->edAllPage->setEnabled(false);
|
|
ui->cbCaseSensitive->setChecked(false);
|
|
ui->btnImport->setEnabled(false);
|
|
ui->btnExport->setEnabled(false);
|
|
ui->btnBackup->setEnabled(false);
|
|
ui->rbReplaceSelect->setChecked(true);
|
|
ui->btnRead->setFixedWidth(100);
|
|
ui->btnSave->setFixedWidth(100);
|
|
ui->btnExit->setFixedWidth(100);
|
|
ui->btnSearch->setFixedWidth(120);
|
|
|
|
connect(ui->btnSelectFile, &QPushButton::clicked, this, [&]() {
|
|
QString file = CUtil::select_file(this, u8"请选择xml文件", u8"XML(*.xml);;所有文件 (*)");
|
|
if (file.isEmpty()) {
|
|
return;
|
|
}
|
|
ui->edStatus->setText(file);
|
|
});
|
|
connect(ui->btnSearch, &QPushButton::clicked, this, [&]() { search(ui->edSearchKey->text()); });
|
|
connect(ui->btnBackup, &QPushButton::clicked, this, [&]() { backup_file(); });
|
|
connect(ui->btnRead, &QPushButton::clicked, this, [&]() { read(ui->edStatus->text().trimmed()); });
|
|
connect(ui->btnSave, &QPushButton::clicked, this, [&]() { save(); });
|
|
connect(ui->btnExit, &QPushButton::clicked, this, [&]() { QApplication::exit(0); });
|
|
connect(ui->btnReset, &QPushButton::clicked, this, &MainWidget::reset);
|
|
connect(ui->btnReplace, &QPushButton::clicked, this, [&]() { replace_content(true); });
|
|
connect(ui->btnRxReplace, &QPushButton::clicked, this, [&]() { replace_content(false); });
|
|
connect(ui->cbUnit, &QComboBox::currentTextChanged, this, [&](const QString& content) { unit_change(); });
|
|
connect(ui->btnExport, &QPushButton::clicked, this, &MainWidget::copy_multi_data);
|
|
connect(ui->btnPagePre, &QPushButton::clicked, this, [&]() {
|
|
unsigned int cur = ui->edCurPage->text().toUInt();
|
|
push_content(current_, cur - 1);
|
|
});
|
|
connect(ui->btnImport, &QPushButton::clicked, this, [&]() {
|
|
CDataEdit edit;
|
|
edit.is_import_ = true;
|
|
edit.set_xml_opr(&xml_);
|
|
edit.exec();
|
|
|
|
if (!edit.is_import_sucess_) {
|
|
return;
|
|
}
|
|
xml_.get_all_elements(vec_);
|
|
current_.clear();
|
|
current_ = vec_;
|
|
push_content(current_);
|
|
});
|
|
|
|
connect(ui->btnSet, &QPushButton::clicked, this, [&]() {
|
|
group_set_->exec();
|
|
base_init();
|
|
});
|
|
connect(ui->btnHis, &QPushButton::clicked, this, [&]() {
|
|
CUIHistory his(this, his_);
|
|
his.exec();
|
|
|
|
if (his.cur_ != "") {
|
|
ui->edStatus->setText(his.cur_);
|
|
}
|
|
});
|
|
|
|
connect(ui->btnPageNext, &QPushButton::clicked, this, [&]() {
|
|
unsigned int cur = ui->edCurPage->text().toUInt();
|
|
push_content(current_, cur + 1);
|
|
});
|
|
connect(ui->btnJump, &QPushButton::clicked, this, [&]() {
|
|
unsigned int cur = ui->edCurPage->text().toUInt();
|
|
push_content(current_, cur);
|
|
});
|
|
connect(ui->btnResort, &QPushButton::clicked, this, [&]() {
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
sort_by_repeat(vec_);
|
|
std::vector<Element_t*> nvec{};
|
|
xml_.copy_and_del(vec_, nvec);
|
|
vec_.clear();
|
|
std::swap(vec_, nvec);
|
|
current_ = vec_;
|
|
push_content(current_);
|
|
});
|
|
|
|
QSettings settings;
|
|
settings.beginGroup("xmlopr");
|
|
restoreGeometry(settings.value("geometry").toByteArray());
|
|
settings.endGroup();
|
|
|
|
// QFile qss_file("://qss/lightblue.css");
|
|
QFile qss_file("://qss/flatgray.css");
|
|
if (qss_file.open(QFile::ReadOnly)) {
|
|
qApp->setStyleSheet(qss_file.readAll());
|
|
}
|
|
|
|
init_menu();
|
|
|
|
if (cur_config_.max_blank_add > 20) {
|
|
blank_with_ = cur_config_.max_blank_add;
|
|
}
|
|
// 基本处理
|
|
base_init();
|
|
}
|
|
|
|
void MainWidget::copy_key()
|
|
{
|
|
Element_t* target = get_current_select_key();
|
|
if (target == nullptr) {
|
|
return;
|
|
}
|
|
QClipboard* clip = QApplication::clipboard();
|
|
clip->setText(QString(target->Attribute(keys_[0].c_str())));
|
|
// CUtil::msg(this, u8"已复制");
|
|
}
|
|
|
|
void MainWidget::closeEvent(QCloseEvent* event)
|
|
{
|
|
QSettings settings;
|
|
settings.beginGroup("xmlopr");
|
|
settings.setValue("geometry", saveGeometry());
|
|
settings.endGroup();
|
|
QWidget::closeEvent(event);
|
|
}
|
|
|
|
void MainWidget::keyPressEvent(QKeyEvent* event)
|
|
{
|
|
switch (event->key()) {
|
|
case Qt::Key_Return:
|
|
search(ui->edSearchKey->text());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
QWidget::keyPressEvent(event);
|
|
}
|
|
|
|
MainWidget::~MainWidget()
|
|
{
|
|
delete ui;
|
|
delete attri_edit_;
|
|
delete ini_oper_;
|
|
delete his_;
|
|
}
|
|
|
|
void MainWidget::set_work_exe(char* path)
|
|
{
|
|
exe_path_.clear();
|
|
exe_path_.append(path);
|
|
}
|
|
|
|
void MainWidget::show_custom_menu()
|
|
{
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
QModelIndexList indexList = tab_widget_->selectionModel()->selectedRows();
|
|
|
|
if (indexList.size() == 1) {
|
|
menu_simple_->exec(QCursor::pos());
|
|
} else {
|
|
menu_multi_->exec(QCursor::pos());
|
|
}
|
|
}
|
|
|
|
void MainWidget::generate_table_widget()
|
|
{
|
|
tab_widget_ = new QTableWidget();
|
|
metrics_ = std::make_shared<QFontMetrics>(tab_widget_->font());
|
|
tab_widget_->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(tab_widget_, &QTableWidget::itemChanged, this, [&](QTableWidgetItem* item) { item_changed_handle(item); });
|
|
connect(tab_widget_, &QTableWidget::customContextMenuRequested, this, &MainWidget::show_custom_menu);
|
|
auto keys = CUtil::splitString(cur_config_.propertis, ",");
|
|
keys_.clear();
|
|
|
|
QStringList list;
|
|
for (const auto& item : keys) {
|
|
if (item.empty()) {
|
|
continue;
|
|
}
|
|
keys_.push_back(item);
|
|
list.append(QString::fromStdString(item));
|
|
}
|
|
|
|
col_with_.clear();
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
col_with_[i] = 0;
|
|
}
|
|
|
|
tab_widget_->setColumnCount(list.size());
|
|
tab_widget_->setHorizontalHeaderLabels(list);
|
|
tab_widget_->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
// tab_widget_->setSelectionMode(QAbstractItemView::SelectionMode::SingleSelection);
|
|
|
|
for (auto i = 0; i < keys.size(); ++i) {
|
|
tab_widget_->setColumnWidth(i, col_with_[i]);
|
|
}
|
|
|
|
QHBoxLayout* lay = new QHBoxLayout();
|
|
lay->addWidget(tab_widget_);
|
|
ui->widget->setLayout(lay);
|
|
}
|
|
|
|
void MainWidget::push_content(const std::vector<tinyxml2::XMLElement*>& eles, std::size_t page)
|
|
{
|
|
if (tab_widget_ == nullptr || page == 0) {
|
|
return;
|
|
}
|
|
|
|
std::size_t all_size = eles.size();
|
|
std::size_t max_show = g_OnePage * page;
|
|
all_page_ = all_size / 100;
|
|
|
|
if (all_size % 100 != 0) {
|
|
++all_page_;
|
|
}
|
|
|
|
if (page < 1 || page > all_page_) {
|
|
if (eles.size() > 0) {
|
|
CUtil::msg(this, u8"页码不在范围内");
|
|
return;
|
|
}
|
|
tab_widget_->clearContents();
|
|
tab_widget_->setRowCount(0);
|
|
cur_page_ = 0;
|
|
ui->edCurPage->setText(QString::number(cur_page_));
|
|
ui->edAllPage->setText(QString::number(all_page_));
|
|
return;
|
|
}
|
|
|
|
tab_widget_->clearContents();
|
|
tab_widget_->setRowCount(0);
|
|
|
|
auto_add_ = true;
|
|
for (auto p = (page - 1) * g_OnePage; p < all_size && p < max_show; ++p) {
|
|
int row_cnt = tab_widget_->rowCount();
|
|
tab_widget_->insertRow(row_cnt);
|
|
insert_one_line(eles[p], row_cnt);
|
|
}
|
|
ui->edCurPage->setText(QString::number(page));
|
|
cur_page_ = page;
|
|
ui->edAllPage->setText(QString::number(all_page_));
|
|
judge_btn_page();
|
|
auto_add_ = false;
|
|
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
tab_widget_->setColumnWidth(static_cast<int>(i), col_with_[i]);
|
|
}
|
|
}
|
|
|
|
void MainWidget::judge_btn_page()
|
|
{
|
|
int cur = ui->edCurPage->text().trimmed().toUInt();
|
|
if (cur <= 1) {
|
|
ui->btnPagePre->setEnabled(false);
|
|
} else {
|
|
ui->btnPagePre->setEnabled(true);
|
|
}
|
|
|
|
if (cur >= all_page_) {
|
|
ui->btnPageNext->setEnabled(false);
|
|
} else {
|
|
ui->btnPageNext->setEnabled(true);
|
|
}
|
|
}
|
|
|
|
bool MainWidget::read(const QString& file_path)
|
|
{
|
|
// 获取配置
|
|
cur_config_.name = ui->cbConfig->currentText().toStdString();
|
|
if (!ini_oper_->get_item(cur_config_)) {
|
|
CUtil::msg(this, u8"获取配置失败。");
|
|
return false;
|
|
}
|
|
|
|
if (!xml_.open(file_path.toStdString())) {
|
|
CUtil::msg(this, u8"打开xml失败。");
|
|
return false;
|
|
}
|
|
xml_.set_baseinfo(cur_config_);
|
|
if (!xml_.parse_xml(vec_)) {
|
|
CUtil::msg(this, u8"解析xml失败。");
|
|
return false;
|
|
}
|
|
|
|
if (cur_config_.is_same) {
|
|
std::vector<std::string> units;
|
|
xml_.get_all_unit(units);
|
|
QStringList list;
|
|
for (const auto& unit : units) {
|
|
list.append(QString::fromStdString(unit));
|
|
}
|
|
u_ = true;
|
|
ui->cbUnit->clear();
|
|
if (!list.isEmpty()) {
|
|
ui->cbUnit->addItems(list);
|
|
ui->cbUnit->setCurrentIndex(0);
|
|
}
|
|
u_ = false;
|
|
}
|
|
else {
|
|
ui->cbUnit->setEnabled(false);
|
|
}
|
|
|
|
if (cur_config_.max_col_len < 0 || cur_config_.max_col_len > 1000) {
|
|
allow_max_with_ = 100;
|
|
} else {
|
|
allow_max_with_ = cur_config_.max_col_len;
|
|
}
|
|
|
|
generate_table_widget();
|
|
push_content(vec_);
|
|
current_ = vec_;
|
|
|
|
ui->edStatus->setText(file_path);
|
|
ui->btnRead->setEnabled(false);
|
|
ui->btnSave->setEnabled(true);
|
|
ui->btnSelectFile->setEnabled(false);
|
|
ui->btnImport->setEnabled(true);
|
|
ui->btnExport->setEnabled(true);
|
|
ui->btnBackup->setEnabled(true);
|
|
|
|
ui->cbConfig->setEnabled(false);
|
|
ui->btnSet->setEnabled(false);
|
|
|
|
his_->push(ui->edStatus->text().toStdString());
|
|
|
|
return true;
|
|
}
|
|
|
|
void MainWidget::search(const QString& key)
|
|
{
|
|
QString bkey = key;
|
|
if (bkey.isEmpty()) {
|
|
current_ = vec_;
|
|
push_content(current_);
|
|
return;
|
|
}
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (!ui->cbCaseSensitive->isChecked()) {
|
|
bkey = bkey.toUpper();
|
|
}
|
|
|
|
current_.clear();
|
|
for (const auto& item : vec_) {
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
const char* data = item->Attribute(keys_[i].c_str());
|
|
QString qdata(data);
|
|
if (!ui->cbCaseSensitive->isChecked()) {
|
|
qdata = qdata.toUpper();
|
|
}
|
|
if (!qdata.contains(bkey)) {
|
|
continue;
|
|
}
|
|
current_.push_back(item);
|
|
break;
|
|
}
|
|
}
|
|
push_content(current_);
|
|
}
|
|
|
|
void MainWidget::item_changed_handle(QTableWidgetItem* item)
|
|
{
|
|
if (auto_add_) {
|
|
return;
|
|
}
|
|
if (item == nullptr) {
|
|
return;
|
|
}
|
|
int row = item->row();
|
|
int col = item->column();
|
|
|
|
QString xml_key = tab_widget_->item(row, 0)->text();
|
|
Element_t* result = get_element_by_key(xml_key);
|
|
if (result == nullptr) {
|
|
return;
|
|
}
|
|
result->SetAttribute(keys_[col].c_str(), item->text().toStdString().c_str());
|
|
}
|
|
|
|
void MainWidget::save()
|
|
{
|
|
if (xml_.save()) {
|
|
CUtil::msg(this, u8"保存成功");
|
|
} else {
|
|
CUtil::msg(this, u8"保存失败");
|
|
}
|
|
}
|
|
|
|
void MainWidget::copy_select_line()
|
|
{
|
|
// if (!CUtil::affirm(this, u8"确认", u8"确认复制吗？")) {
|
|
// return;
|
|
// }
|
|
|
|
QTableWidgetItem* cur_item = get_current_select_item();
|
|
if (cur_item == nullptr) {
|
|
return;
|
|
}
|
|
|
|
Element_t* target = get_element_by_key(cur_item->text());
|
|
if (target == nullptr) {
|
|
return;
|
|
}
|
|
Element_t* newer = xml_.copy_element(target);
|
|
|
|
if (!edit_property(newer, cur_item->row())) {
|
|
return;
|
|
}
|
|
|
|
xml_.insert_brother_node(target, newer);
|
|
|
|
tab_widget_->insertRow(cur_item->row() + 1);
|
|
insert_one_line(newer, cur_item->row() + 1);
|
|
|
|
std::vector<Element_t*>::iterator it;
|
|
for (it = vec_.begin(); it != vec_.end(); ++it) {
|
|
if (*it == target) {
|
|
break;
|
|
}
|
|
}
|
|
int df = it - vec_.begin() + 1;
|
|
vec_.insert(vec_.begin() + df, newer);
|
|
search(ui->edSearchKey->text());
|
|
}
|
|
|
|
// 返回 true 表示确认编辑了， false 表示取消编辑了。
|
|
bool MainWidget::edit_property(Element_t* target, int row)
|
|
{
|
|
if (target == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
Property_t property;
|
|
xml_.get_attributes(target, property);
|
|
|
|
// 检测key值是否变化
|
|
std::string value_pre = property[0].value;
|
|
attri_edit_->set_attribute(property);
|
|
attri_edit_->exec();
|
|
|
|
if (!attri_edit_->is_ok_) {
|
|
return false;
|
|
}
|
|
|
|
attri_edit_->get_attribute(property);
|
|
if (property[0].value != value_pre) {
|
|
while (xml_.check_key_exists(property)) {
|
|
CUtil::msg(attri_edit_, u8"不能有相同的key，请检查。");
|
|
attri_edit_->exec();
|
|
attri_edit_->get_attribute(property);
|
|
if (!attri_edit_->is_ok_) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
xml_.attributes_to_element(target, property);
|
|
|
|
// 这里要同步到界面
|
|
ele_update_gui(target, row);
|
|
return true;
|
|
}
|
|
|
|
// ele_update_gui 的 row 参数暂时废弃，无意义。
|
|
void MainWidget::ele_update_gui(Element_t* target, int row)
|
|
{
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
|
|
QString tkey = QString::fromLocal8Bit(target->Attribute(keys_[0].c_str()));
|
|
int target_row = -1;
|
|
// 获取当前显示的内容，查找更改。
|
|
int cur_show_cnt = tab_widget_->rowCount();
|
|
for (int i = 0; i < cur_show_cnt; ++i) {
|
|
if (tab_widget_->item(i, 0)->text() == tkey) {
|
|
target_row = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (target_row < 0) {
|
|
return;
|
|
}
|
|
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
const char* v = target->Attribute(keys_[i].c_str());
|
|
auto* qitem = tab_widget_->item(target_row, i);
|
|
qitem->setText(QString(v));
|
|
}
|
|
}
|
|
|
|
void MainWidget::init_menu()
|
|
{
|
|
menu_simple_ = new QMenu();
|
|
menu_multi_ = new QMenu();
|
|
|
|
ac_edit_property_ = new QAction(u8"编辑");
|
|
ac_copy_curline_ = new QAction(u8"复制项");
|
|
ac_del_curline_ = new QAction(u8"删除项");
|
|
ac_copy_key_ = new QAction(u8"复制key");
|
|
|
|
menu_simple_->addAction(ac_edit_property_);
|
|
menu_simple_->addAction(ac_copy_curline_);
|
|
menu_simple_->addAction(ac_del_curline_);
|
|
menu_simple_->addAction(ac_copy_key_);
|
|
menu_multi_->addAction(ac_del_curline_);
|
|
|
|
connect(ac_edit_property_, &QAction::triggered, this, [&]() {
|
|
QTableWidgetItem* cur_item = get_current_select_item();
|
|
if (cur_item == nullptr) {
|
|
return;
|
|
}
|
|
|
|
Element_t* target = get_element_by_key(cur_item->text());
|
|
if (target == nullptr) {
|
|
return;
|
|
}
|
|
edit_property(target, cur_item->row());
|
|
});
|
|
connect(ac_copy_curline_, &QAction::triggered, this, [&]() { copy_select_line(); });
|
|
connect(ac_del_curline_, &QAction::triggered, this, [&]() { del_select_line(); });
|
|
connect(ac_copy_key_, &QAction::triggered, this, [&]() { copy_key(); });
|
|
}
|
|
|
|
void MainWidget::insert_one_line(Element_t* ele, int row)
|
|
{
|
|
if (ele == nullptr) {
|
|
return;
|
|
}
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
const char* data = ele->Attribute(keys_[i].c_str());
|
|
QTableWidgetItem* wgItem = new QTableWidgetItem();
|
|
|
|
if (i == 0) {
|
|
wgItem->setFlags(wgItem->flags() & ~Qt::ItemIsEditable);
|
|
// wgItem->setFlags(wgItem->flags() | Qt::ItemIsUserCheckable);
|
|
// wgItem->setCheckState(Qt::Checked);
|
|
}
|
|
QString sda(data);
|
|
int dwidth = metrics_->horizontalAdvance(sda) + blank_with_;
|
|
int need_set_width = dwidth > allow_max_with_ ? allow_max_with_ : dwidth;
|
|
col_with_[i] = col_with_[i] < need_set_width ? need_set_width : col_with_[i];
|
|
wgItem->setText(sda);
|
|
tab_widget_->setItem(row, i, wgItem);
|
|
}
|
|
}
|
|
|
|
void MainWidget::del_select_line()
|
|
{
|
|
if (!CUtil::affirm(this, u8"确认", u8"确认删除吗？")) {
|
|
return;
|
|
}
|
|
|
|
QModelIndexList indexList = tab_widget_->selectionModel()->selectedRows();
|
|
int size = indexList.size();
|
|
std::vector<int> erase_row;
|
|
for (auto i = size - 1; i > -1; --i) {
|
|
Element_t* target = get_element_by_row(indexList[i].row());
|
|
if (target == nullptr) {
|
|
continue;
|
|
}
|
|
xml_.del_element(target);
|
|
tab_widget_->removeRow(indexList[i].row());
|
|
erase_row.push_back(indexList[i].row());
|
|
std::vector<Element_t*>::iterator it;
|
|
for (it = vec_.begin(); it != vec_.end(); ++it) {
|
|
if (*it == target) {
|
|
break;
|
|
}
|
|
}
|
|
vec_.erase(it);
|
|
}
|
|
// std::sort(erase_row.begin(), erase_row.end(), std::greater<int>());
|
|
// for (const auto& item : erase_row) {
|
|
// tab_widget_->removeRow(item);
|
|
// }
|
|
search(ui->edSearchKey->text());
|
|
}
|
|
|
|
Element_t* MainWidget::get_current_select_key()
|
|
{
|
|
Element_t* ret = nullptr;
|
|
QTableWidgetItem* item = get_current_select_item();
|
|
if (item == nullptr) {
|
|
return ret;
|
|
}
|
|
ret = get_element_by_key(item->text());
|
|
return ret;
|
|
}
|
|
|
|
QTableWidgetItem* MainWidget::get_current_select_item()
|
|
{
|
|
QTableWidgetItem* ret = nullptr;
|
|
if (tab_widget_ == nullptr) {
|
|
return ret;
|
|
}
|
|
QList<QTableWidgetItem*> selectedItems = tab_widget_->selectedItems();
|
|
if (selectedItems.size() < 1) {
|
|
CUtil::msg(this, u8"没有选中数据");
|
|
return ret;
|
|
}
|
|
ret = selectedItems[0];
|
|
return ret;
|
|
}
|
|
|
|
void MainWidget::reset()
|
|
{
|
|
current_.clear();
|
|
current_ = vec_;
|
|
push_content(current_);
|
|
}
|
|
|
|
tinyxml2::XMLElement* MainWidget::get_element_by_key(const QString& key)
|
|
{
|
|
Element_t* ret = nullptr;
|
|
for (const auto& ele : current_) {
|
|
const char* data = ele->Attribute(keys_[0].c_str());
|
|
QString qdata(data);
|
|
if (qdata != key) {
|
|
continue;
|
|
}
|
|
ret = ele;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Element_t* MainWidget::get_element_by_row(int row)
|
|
{
|
|
Element_t* ret = nullptr;
|
|
if (row < 0 || !tab_widget_ || row >= tab_widget_->rowCount()) {
|
|
return ret;
|
|
}
|
|
QTableWidgetItem* item = tab_widget_->item(row, 0);
|
|
ret = get_element_by_key(item->text());
|
|
return ret;
|
|
}
|
|
|
|
void MainWidget::sort_by_repeat(std::vector<Element_t*>& vec)
|
|
{
|
|
std::vector<SElement_t> turn_vec{};
|
|
for (const auto& item : vec) {
|
|
const char* str = item->Attribute(keys_[0].c_str());
|
|
std::string d(str);
|
|
turn_vec.emplace_back(item, d);
|
|
}
|
|
std::sort(turn_vec.begin(), turn_vec.end(), [&](const SElement_t& se1, const SElement_t& se2) { return compare_by_prefix(se1, se2); });
|
|
vec.clear();
|
|
for (const auto& item : turn_vec) {
|
|
vec.push_back(item.ele);
|
|
}
|
|
}
|
|
|
|
void MainWidget::copy_multi_data()
|
|
{
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
std::vector<OperElement*> vec;
|
|
|
|
if (ui->rbAllPage->isChecked()) {
|
|
get_related_elements(vec, AREA_ALL_PAGE);
|
|
} else if (ui->rbReplaceSelect->isChecked()) {
|
|
get_related_elements(vec, AREA_SELECT);
|
|
} else if (ui->rbRepCurPage->isChecked()) {
|
|
get_related_elements(vec, AREA_CUR_PAGE);
|
|
} else {
|
|
get_related_elements(vec, AREA_ALL);
|
|
}
|
|
|
|
if (vec.size() < 1) {
|
|
CUtil::msg(this, u8"无选择数据");
|
|
return;
|
|
}
|
|
QString ret;
|
|
for (auto& item : vec) {
|
|
if (item == nullptr) {
|
|
continue;
|
|
}
|
|
tinyxml2::XMLPrinter printer;
|
|
item->element_->Accept(&printer);
|
|
ret.append(printer.CStr());
|
|
delete item;
|
|
}
|
|
|
|
CDataEdit edit;
|
|
edit.set_data(ret);
|
|
edit.exec();
|
|
}
|
|
|
|
void MainWidget::replace_content(bool is_common)
|
|
{
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
QString key = ui->edRepPre->text();
|
|
QString after = ui->edRepAfter->text();
|
|
if (key.isEmpty()) {
|
|
CUtil::msg(this, u8"替换前数据为空。");
|
|
return;
|
|
}
|
|
auto handle = [&](const std::vector<OperElement*>& vec, bool is_search) {
|
|
// qDebug() << "要处理的数量为：" << vec.size();
|
|
for (auto& item : vec) {
|
|
if (is_common) {
|
|
replace_str(key, after, item->element_);
|
|
} else {
|
|
replace_str(item->element_, key, after);
|
|
}
|
|
if (!is_search) {
|
|
ele_update_gui(item->element_, item->row_);
|
|
}
|
|
delete item;
|
|
}
|
|
};
|
|
|
|
std::vector<OperElement*> vec;
|
|
if (ui->rbReplaceSelect->isChecked()) {
|
|
QModelIndexList indexList = tab_widget_->selectionModel()->selectedRows();
|
|
if (indexList.size() < 1) {
|
|
CUtil::msg(this, u8"无选择数据");
|
|
return;
|
|
}
|
|
get_related_elements(vec, AREA_SELECT);
|
|
handle(vec, false);
|
|
} else if (ui->rbAllPage->isChecked()) {
|
|
get_related_elements(vec, AREA_ALL_PAGE);
|
|
handle(vec, false);
|
|
xml_.get_all_elements(vec_);
|
|
current_.clear();
|
|
current_ = vec_;
|
|
search(ui->edSearchKey->text());
|
|
} else if (ui->rbRepCurPage->isChecked()) {
|
|
get_related_elements(vec, AREA_CUR_PAGE);
|
|
handle(vec, false);
|
|
} else {
|
|
if (!CUtil::affirm(this, u8"确认", u8"确认进行全局替换吗？")) {
|
|
return;
|
|
}
|
|
get_related_elements(vec, AREA_ALL);
|
|
handle(vec, true);
|
|
xml_.get_all_elements(vec_);
|
|
current_.clear();
|
|
current_ = vec_;
|
|
search(ui->edSearchKey->text());
|
|
}
|
|
}
|
|
|
|
void MainWidget::replace_str(const QString& pre, const QString& after, Element_t* ele)
|
|
{
|
|
if (ele == nullptr) {
|
|
return;
|
|
}
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
auto* value = ele->Attribute(keys_[i].c_str());
|
|
QString content(value);
|
|
if (content.contains(pre)) {
|
|
content.replace(pre, after);
|
|
ele->SetAttribute(keys_[i].c_str(), content.toStdString().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWidget::replace_str(Element_t* ele, const QString& rg, const QString& after)
|
|
{
|
|
QRegularExpression rx(rg);
|
|
if (ele == nullptr) {
|
|
return;
|
|
}
|
|
for (auto i = 0; i < keys_.size(); ++i) {
|
|
auto* value = ele->Attribute(keys_[i].c_str());
|
|
QString content(value);
|
|
// qDebug() << content;
|
|
content.replace(rx, after);
|
|
// qDebug() << content;
|
|
// qDebug() << "\n";
|
|
ele->SetAttribute(keys_[i].c_str(), content.toStdString().c_str());
|
|
}
|
|
}
|
|
|
|
void MainWidget::get_related_elements(std::vector<OperElement*>& out, ReplaceArea area)
|
|
{
|
|
assert(tab_widget_);
|
|
out.clear();
|
|
switch (area) {
|
|
case AREA_ALL_PAGE: {
|
|
out.resize(current_.size());
|
|
std::transform(current_.begin(), current_.end(), out.begin(), [](Element_t* ele) { return new OperElement(ele, 0); });
|
|
break;
|
|
}
|
|
case AREA_CUR_PAGE: {
|
|
int rows = tab_widget_->rowCount();
|
|
for (int i = 0; i < rows; ++i) {
|
|
out.emplace_back(new OperElement(get_element_by_row(i), i));
|
|
}
|
|
break;
|
|
}
|
|
case AREA_ALL: {
|
|
out.resize(vec_.size());
|
|
std::transform(vec_.begin(), vec_.end(), out.begin(), [](Element_t* ele) { return new OperElement(ele, 0); });
|
|
break;
|
|
}
|
|
default: {
|
|
QModelIndexList indexList = tab_widget_->selectionModel()->selectedRows();
|
|
for (int i = 0; i < indexList.size(); ++i) {
|
|
out.emplace_back(new OperElement(get_element_by_row(indexList[i].row()), indexList[i].row()));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWidget::backup_file()
|
|
{
|
|
if (tab_widget_ == nullptr) {
|
|
return;
|
|
}
|
|
|
|
QString time = QDateTime::currentDateTime().toString("yyyy-MMdd-hhmmss");
|
|
if (!xml_.backup_file(fs::path(exe_path_).parent_path().append("backup").string(), time.toStdString())) {
|
|
CUtil::msg(this, u8"备份失败。");
|
|
} else {
|
|
CUtil::msg(this, u8"备份完成。");
|
|
}
|
|
}
|
|
|
|
void MainWidget::base_init()
|
|
{
|
|
StrVec_t vec;
|
|
ini_oper_->get_all_node(vec);
|
|
|
|
QStringList list;
|
|
for (const auto& data : vec) {
|
|
list.append(QString::fromStdString(data));
|
|
}
|
|
ui->cbConfig->clear();
|
|
|
|
if (list.empty()) {
|
|
return;
|
|
}
|
|
|
|
ui->cbConfig->addItems(list);
|
|
ui->cbConfig->setCurrentIndex(0);
|
|
}
|
|
|
|
void MainWidget::unit_change()
|
|
{
|
|
if (u_) {
|
|
return;
|
|
}
|
|
std::string unit = ui->cbUnit->currentText().toStdString();
|
|
if (!xml_.get_all_elements(vec_, unit)) {
|
|
CUtil::msg(this, u8"获取单元信息失败:" + QString::fromStdString(unit));
|
|
return;
|
|
}
|
|
push_content(vec_);
|
|
current_ = vec_;
|
|
}
|
|
|
|
std::string MainWidget::extract_prefix(const std::string& name)
|
|
{
|
|
auto pos = name.find('.');
|
|
return (pos == std::string::npos) ? name : name.substr(0, pos);
|
|
}
|
|
|
|
bool MainWidget::compare_by_prefix(const SElement_t& se1, const SElement_t& se2)
|
|
{
|
|
std::string a = extract_prefix(se1.str);
|
|
std::string b = extract_prefix(se2.str);
|
|
if (a != b) {
|
|
return a < b;
|
|
}
|
|
return se1.str < se2.str; // 按照原始顺序排序
|
|
}
|
|
|
|
OperElement::OperElement(Element_t* ele, int row)
|
|
{
|
|
element_ = ele;
|
|
row_ = row;
|
|
}
|
|
|
|
SElement_t::SElement_t(Element_t* e, std::string& s)
|
|
{
|
|
ele = e;
|
|
str = std::move(s);
|
|
}
|