OneLevelXmlOpr/MainWidget.cpp

#include "MainWidget.h"
#include <QClipboard>
#include "./ui_MainWidget.h"

constexpr std::size_t g_OnePage = 100;

MainWidget::MainWidget(QWidget* parent) : QWidget(parent), ui(new Ui::MainWidget)
{
    ui->setupUi(this);

    setWindowTitle(u8"OneLevelXmlOpr v1.1");
    setWindowIcon(QIcon("://resource/xml.ico"));

    setMinimumWidth(900);
    setMinimumHeight(800);

    width_.push_back(280);
    for (int i = 0; i < 30; ++i) {
        width_.push_back(160);
    }

    attri_edit_ = new CAttributeEdit();

    ui->edStatus->setEnabled(false);
    ui->btnSave->setEnabled(false);
    ui->btnCopySelectLine->setEnabled(false);
    ui->btnDelSelectLine->setEnabled(false);
    ui->edAllPage->setEnabled(false);

    connect(ui->btnRead, &QPushButton::clicked, this, [&]() { read(); });
    connect(ui->btnSearch, &QPushButton::clicked, this, [&]() { search(); });
    connect(ui->btnSave, &QPushButton::clicked, this, [&]() { save(); });
    connect(ui->btnCopySelectLine, &QPushButton::clicked, this, [&]() { copy_select_line(); });
    connect(ui->btnDelSelectLine, &QPushButton::clicked, this, [&]() { del_select_line(); });
    connect(ui->btnReset, &QPushButton::clicked, this, &MainWidget::reset);
    connect(ui->btnPagePre, &QPushButton::clicked, this, [&]() {
        unsigned int cur = ui->edCurPage->text().toUInt();
        push_content(current_, cur - 1);
    });
    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->btnCopyKey, &QPushButton::clicked, this, &MainWidget::copy_key);
}

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"已复制");
}

MainWidget::~MainWidget()
{
    delete attri_edit_;
    delete ui;
}

void MainWidget::set_work_exe(char* path)
{
    exe_path_.clear();
    exe_path_.append(path);
}

void MainWidget::generate_table_widget()
{
    tab_widget_ = new QTableWidget();
    connect(tab_widget_, &QTableWidget::itemChanged, this, [&](QTableWidgetItem* item) { item_changed_handle(item); });

    auto config = ini_.get_config();
    auto keys = splitString(config.purpose, ",");
    keys_.clear();
    QStringList list;
    for (const auto& item : keys) {
        if (item.empty()) {
            continue;
        }
        keys_.push_back(item);
        list.append(QString::fromStdString(item));
    }

    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, width_[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_) {
        CUtil::msg(this, u8"不在范围内");
        ui->edCurPage->setText(QString::number(cur_page_));
        return;
    }

    tab_widget_->clearContents();
    tab_widget_->setRowCount(0);

    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);
        for (auto i = 0; i < keys_.size(); ++i) {
            const char*       data = eles[p]->Attribute(keys_[i].c_str());
            QTableWidgetItem* wgItem = new QTableWidgetItem();

            if (i == 0) {
                wgItem->setFlags(wgItem->flags() & ~Qt::ItemIsEditable);
            }

            wgItem->setText(QString(data));
            tab_widget_->setItem(row_cnt, i, wgItem);
        }
    }
    ui->edCurPage->setText(QString::number(page));
    cur_page_ = page;
    ui->edAllPage->setText(QString::number(all_page_));
    judge_btn_page();
}

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);
    }
}

void MainWidget::read()
{
    if (!ini_.set_work_exe(exe_path_)) {
        return;
    }
    OprBase base = ini_.get_config();
    if (!xml_.open(base.xml_path)) {
        QString status = u8"Open【" + QString::fromStdString(base.xml_path.c_str()) + u8"】Failed.";
        return;
    }
    xml_.set_baseinfo(base);
    if (!xml_.parse_xml(vec_)) {
        QString status = u8"parse_xml【" + QString::fromStdString(base.xml_path.c_str()) + u8"】Failed.";
        return;
    }

    auto_add_ = true;
    generate_table_widget();
    push_content(vec_);
    current_ = vec_;
    auto_add_ = false;

    QString status = u8"Open And Parse【" + QString::fromLocal8Bit(base.xml_path.c_str()) + u8"】Success.";
    ui->edStatus->setText(status);

    ui->btnRead->setEnabled(false);
    ui->btnSave->setEnabled(true);
    ui->btnCopySelectLine->setEnabled(true);
    ui->btnDelSelectLine->setEnabled(true);
}

void MainWidget::search()
{
    QString key = ui->edSearchKey->text().trimmed();
    if (key.isEmpty()) {
        return;
    }
    if (tab_widget_ == nullptr) {
        return;
    }
    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 (!qdata.contains(key)) {
                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_bykey(xml_key);
    if (result == nullptr) {
        return;
    }
    result->SetAttribute(keys_[col].c_str(), item->text().toLocal8Bit().constData());
}

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;
    }
    Element_t* target = get_current_select_key();
    if (target == nullptr) {
        return;
    }
    Element_t* newer = xml_.copy_element(target);

    Property_t property;
    xml_.get_key_value(newer, property);

    attri_edit_->set_attribute(property);
    attri_edit_->exec();

    if (!attri_edit_->is_ok_) {
        return;
    }

    attri_edit_->get_attribute(property);
    xml_.key_value_to_element(newer, property);
    xml_.insert_brother_node(target, newer);

    // TODO: 添加到界面
}

void MainWidget::del_select_line()
{
    if (!CUtil::affirm(this, u8"确认", u8"确认删除吗？")) {
        return;
    }
    Element_t* target = get_current_select_key();
    if (target == nullptr) {
        return;
    }
    xml_.del_element(target);

    // TODO: 添加到界面
}

Element_t* MainWidget::get_current_select_key()
{
    Element_t* ret = nullptr;
    if (tab_widget_ == nullptr) {
        return ret;
    }
    QList<QTableWidgetItem*> selectedItems = tab_widget_->selectedItems();
    if (selectedItems.size() < 1) {
        CUtil::msg(this, u8"没有选中数据");
        return ret;
    }
    QTableWidgetItem* item = selectedItems[0];
    int               row = item->row();
    ret = get_element_bykey(item->text());
    return ret;
}

void MainWidget::reset()
{
    current_.clear();
    current_ = vec_;
    push_content(current_);
}

tinyxml2::XMLElement* MainWidget::get_element_bykey(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;
}