ElemsConfigTool/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "changenamedialog.h"
#include "collectionwindow.h"
#include "resfiledialog.h"
#include "actionSettingDialog.h"
#include <QListWidgetItem>
#include <QListWidget>
#include <QLabel>
#include <iostream>
#include <QHBoxLayout>
#include <QMessageBox>
#include <QFileDialog>
#include <QDragEnterEvent>
#include <QMimeData>
#include <QUrl>
#include <QFormLayout>
#include <QDialogButtonBox>
#include "dataManager.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    jsonTemp = new ReadJsonSrc(":/file/file/template.json");
    ui->setupUi(this);
    QPixmap pix(":/icon/icon/pic.png");
    ui->label_pic->setPixmap(pix.scaled(50,50,Qt::KeepAspectRatio));
    this->setAcceptDrops(true);
    ui->tableWidget_animation->setHorizontalHeaderLabels({"名称","资源","时间线","z-Order"});
    ui->tableWidget_containerPool->setHorizontalHeaderLabels({"键值","资源名","初始时间线","点击时间线","影响时间线","消失时间线","消失z-Order"});
    ui->tableWidget_childElem->setHorizontalHeaderLabels({"名称","使用的池子"});
    ui->tableWidget_event->setHorizontalHeaderLabels({"事件名称","是否需要颜色一致","状态变化幅度","特效","根据格子数量消除","触发动作","触发动作设置"});
    ui->tabWidget->setCurrentIndex(0);
    ui->lineEdit_collectionType->setReadOnly(true);
    ui->widget_dynamic->setLayout(new QFormLayout);
    updateTempRelatedUi();
}

MainWindow::~MainWindow()
{
    delete ui;
    delete jsonTemp;
}

///创建普通下拉选项
QComboBox* MainWindow::createBox(QString choice,QStringList list)
{
    QComboBox* box = new QComboBox;
    box->addItem("尚未选择");
    box->addItems(list);
    int index = box->findText(choice);
    if(index == -1) index = 0;
    box->setCurrentIndex(index);
    return box;
}

///创建一个时间线下拉选项
QComboBox* MainWindow::createTimelineBox(QString chosenTimeline,QString fileName,TimelineType type)
{
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QComboBox* timeLine = new QComboBox;
    if(fileName == "双击添加资源文件") return timeLine;
    QStringList list = elem->getTimelineList(fileName);
    timeLine = createBox(chosenTimeline,list);
    if(type == TimelineType::Animation){
        connect(timeLine,SIGNAL(currentTextChanged(QString)),this,SLOT(onTimelineTextChanged(QString)));
    }
    else if(type == TimelineType::Pool){
        connect(timeLine,SIGNAL(currentTextChanged(QString)),this,SLOT(onPoolTimelineTextChanged(QString)));
    }
    return timeLine;
}

///创建事件下拉选项
QComboBox* MainWindow::createEventBox(QString chosenEvent)
{
    QStringList list;
    for(const auto &i:jsonTemp->templateMap["eventTemp"]) list.push_back(i.name);
    QComboBox* event = createBox(chosenEvent,list);
    connect(event,SIGNAL(currentTextChanged(QString)),this,SLOT(onEventBoxTextChanged(QString)));
    return event;
}

///创建一个使用池子下拉选项
QComboBox* MainWindow::createPoolBox(QString chosenPool)
{
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QStringList list;
    for(const auto &i:elem->container) list.push_back(i.poolName);
    QComboBox* pools = createBox(chosenPool,list);
    connect(pools,SIGNAL(currentTextChanged(QString)),this,SLOT(onPoolsTextChanged(QString)));
    return pools;
}

///创建一个checkBox
QCheckBox* MainWindow::createCheckBox(bool chosen)
{
    QCheckBox* check = new QCheckBox;
    if(chosen) check->setCheckState(Qt::Checked);
    else check->setCheckState(Qt::Unchecked);
    connect(check,SIGNAL(stateChanged(int)),this,SLOT(onCheckBoxStateChanged(int)));
    return check;
}

///创建一个特效下拉选项
QComboBox* MainWindow::createEffectBox(QString chosenEffect)
{
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QStringList list;
    for(const auto &i:elem->statusEffect){
        list.push_back(i.name);
    }
    QComboBox* effect = createBox(chosenEffect,list);
    connect(effect,SIGNAL(currentTextChanged(QString)),this,SLOT(onEventBoxTextChanged(QString)));
    return effect;
}

///创建一个触发动作
QComboBox* MainWindow::createTriggerAction(QString chosenAction)
{
    QStringList actionlist;
    for(const auto &i:jsonTemp->templateMap["actionTemp"]) actionlist.push_back(i.name);
    QComboBox* actions = createBox(chosenAction,actionlist);
    connect(actions,SIGNAL(currentTextChanged(QString)),this,SLOT(onEventBoxTextChanged(QString)));
    return actions;
}

///创建一个触发动作设置按钮
QPushButton* MainWindow::createSetButton()
{
    QPushButton* setAction = new QPushButton("设置");
    connect(setAction,SIGNAL(clicked()),this,SLOT(onSetActionButtonClicked()));
    return setAction;
}

///动画删除或改名后其它下拉选项的更新
void MainWindow::updateAnimComboBox(QString changedAnim)
{
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    //收集动画界面
    if(ui->listWidget_collectAnim->currentItem() != nullptr){
        int index = ui->listWidget_collectAnim->currentRow();
        if(elem->collAnim[index].anim == changedAnim) ui->comboBox_animation->setCurrentIndex(0);
    }
    //状态配置界面
    if(ui->listWidget_status->currentItem() != nullptr){
        int index = ui->listWidget_status->currentRow();
        if(elem->statusConfig[index].initAnim == changedAnim) ui->comboBox_initAnim->setCurrentIndex(0);
        if(elem->statusConfig[index].clickAnim == changedAnim) ui->comboBox_clickAnim->setCurrentIndex(0);
        int rowNum = ui->tableWidget_event->rowCount();
        for(int i=0;i<rowNum;i++){
            QComboBox *effect = qobject_cast<QComboBox*>(ui->tableWidget_event->cellWidget(i,3));
            if(effect->currentText() == changedAnim) effect->setCurrentIndex(0);
        }
    }
}

///收集动画删除或改名后下拉选项更新
void MainWindow::updateCollAnimComboBox(QString changedAnim)
{
    std::cout<<"收集动画改变，更新下拉选项"<<std::endl;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    //状态配置界面
    if(ui->listWidget_status->currentItem() != nullptr){
        int index = ui->listWidget_status->currentRow();
        if(elem->statusConfig[index].collAnim == changedAnim) ui->comboBox_collectAnimation->setCurrentIndex(0);
    }
}

///切换元素时重置界面数据
void MainWindow::setUi(QString elem)
{
    std::cout<<"切换成元素"<<qPrintable(elem)<<",刷新界面"<<std::endl;
    //基础元素区域的设置
    QPixmap pix(DataManager::getInstance()->getIconPath(elem));
    ui->label_pic->setPixmap(pix.scaled(50,50,Qt::KeepAspectRatio));
    ui->lineEdit_name->setText(DataManager::getInstance()->getMarkValue(elem));
    ui->lineEdit_size->setText(DataManager::getInstance()->getSize(elem));
    ui->lineEdit_maxlayer->setText(DataManager::getInstance()->getMaxLayer(elem));
    ui->lineEdit_score->setText(DataManager::getInstance()->getScore(elem));
    ui->spinBox_drop->setValue(DataManager::getInstance()->getDropConfig(elem));

    //TODO:调用各个界面的刷新显示
    //设置状态与效果动画表格显示


    //设置收集动画的显示并聚焦到收集动画列表的最后一个元素
    ui->listWidget_collectAnim->clear();
    for(const auto &i:elem->collAnim){
        ui->listWidget_collectAnim->addItem(i.name);
    }
//    ui->listWidget_collectAnim->item(0)->setSelected(true); // 设置选中

    //设置状态配置界面
    ui->listWidget_status->clear();
    for(const auto &i:elem->statusConfig){
        ui->listWidget_status->addItem(i.statusValue);
    }
    //切换元素时状态尚未选中，先清除事件表格内容
    rowCnt = ui->tableWidget_event->rowCount();
    for(int i=0;i<rowCnt;i++){
        ui->tableWidget_event->removeRow(0);
    }

    //设置收集动画和状态配置的comboBox
    ui->comboBox_initAnim->clear();
    ui->comboBox_clickAnim->clear();
    ui->comboBox_collectAnimation->clear();
    ui->comboBox_animation->clear();
    ui->comboBox_initAnim->addItem("尚未选择");
    ui->comboBox_clickAnim->addItem("尚未选择");
    ui->comboBox_collectAnimation->addItem("尚未选择");
    ui->comboBox_animation->addItem("尚未选择");
    for(const auto &i:elem->statusEffect){
        ui->comboBox_clickAnim->addItem(i.name);
        ui->comboBox_animation->addItem(i.name);
        ui->comboBox_initAnim->addItem(i.name);
    }
    for(const auto &i:elem->collAnim){
        ui->comboBox_collectAnimation->addItem(i.name);
    }

    //设置容器池界面
    ui->listWidget_pool->clear();
    for(const auto &i:elem->container){
        ui->listWidget_pool->addItem(i.poolName);
    }

    //切换元素时容器尚未选中，先清除表格内容
    int rowNum = ui->tableWidget_containerPool->rowCount();
    for(int i=0;i<rowNum;i++){
        ui->tableWidget_containerPool->removeRow(0);
    }

    //设置子元素界面
    rowCnt = ui->tableWidget_childElem->rowCount();
    for(int i=0;i<rowCnt;i++){
        ui->tableWidget_childElem->removeRow(0);
    }
    for(const auto &i:elem->childElem){
        int rowNum = ui->tableWidget_childElem->rowCount();
        ui->tableWidget_childElem->insertRow(rowNum);
        ui->tableWidget_childElem->setItem(rowNum,0,new QTableWidgetItem(i.name));
        ui->tableWidget_childElem->setCellWidget(rowNum,1,createPoolBox(i.container));
    }
}

void MainWindow::on_pushButton_chooseFile_clicked()
{
    //如果未选中列表中的按钮，无法触发此按钮
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString elem = ui->listWidget_elem->currentItem()->text();
    QString file_name = QFileDialog::getOpenFileName(this,"Open a file",QDir::homePath());
    if(file_name == nullptr){
        file_name = elements[elem]->iconPath;
    }
    QPixmap pix(file_name);
    ui->label_pic->setPixmap(pix.scaled(50,50,Qt::KeepAspectRatio));
    ui->listWidget_elem->currentItem()->setIcon(QIcon(file_name));
    DataManager::getInstance()->changeIconPath(elem,file_name);
}


void MainWindow::on_pushButton_addElem_clicked()
{
    QString elemName = "新加元素";
    int id = 1;
    while(1){
        if(!DataManager::getInstance()->existElem(elemName)){
            break;
        }
        elemName = "新加元素" + QString::number(id++);
    }
    QListWidgetItem* item = new QListWidgetItem(QIcon(":/icon/icon/菜狗.png"),elemName);
    ui->listWidget_elem->addItem(item);
    DataManager::getInstance()->addElem(elemName);
}


void MainWindow::on_pushButton_delElem_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除元素","确定要删除此元素吗？");
    if(reply == QMessageBox::Yes){
        QString elemName = ui->listWidget_elem->currentItem()->text();
        delete ui->listWidget_elem->takeItem(ui->listWidget_elem->currentRow());
        DataManager::getInstance()->delElem(elemName);
    }
}


void MainWindow::on_listWidget_elem_itemDoubleClicked(QListWidgetItem *item)
{
    ChangeNameDialog newName;
    newName.setModal(true);
    newName.exec();
    QString name = newName.getNewName();
    if(!name.isEmpty()){
        if(DataManager::getInstance()->existElem(name)){
            QMessageBox::critical(this,"警告","该元素名已存在！");
            return;
        }
        QString oriName = ui->listWidget_elem->currentItem()->text();
        item->setText(name);
        DataManager::getInstance()->changeElemName(oriName,name);
    }
}

//基础元素数据变化触发保存
void MainWindow::on_lineEdit_name_editingFinished()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString key = ui->listWidget_elem->currentItem()->text();
    DataManager::getInstance()->changeMarkValue(key,ui->lineEdit_name->text());
}

void MainWindow::on_lineEdit_size_editingFinished()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString key = ui->listWidget_elem->currentItem()->text();
    DataManager::getInstance()->changeSize(key,ui->lineEdit_size->text());
}

void MainWindow::on_lineEdit_maxlayer_editingFinished()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString key = ui->listWidget_elem->currentItem()->text();
    DataManager::getInstance()->changeMaxLayer(key,ui->lineEdit_maxlayer->text());
}

void MainWindow::on_lineEdit_score_editingFinished()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString key = ui->listWidget_elem->currentItem()->text();
    DataManager::getInstance()->changeScore(key,ui->lineEdit_score->text());
}


void MainWindow::on_spinBox_drop_valueChanged(int arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString key = ui->listWidget_elem->currentItem()->text();
    DataManager::getInstance()->changeDropConfig(key,arg1);
}


void MainWindow::on_listWidget_elem_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)
{
   setUi(current->text());
}

//替换资源文件
void MainWindow::on_tableWidget_animation_cellDoubleClicked(int row, int column)
{
    if(ui->listWidget_elem->currentItem()==nullptr) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    //表格内容修改flag
    animTableItemChanged = true;
    if(column == 1){
        ResFileDialog res;
        res.setModal(true);
        res.exec();
        QString fileName = res.getResName();
        if(!fileName.isEmpty()){
            QTableWidgetItem* res = new QTableWidgetItem(getFileName(fileName));
            // 此单元格不可编辑
            res->setFlags(res->flags() & ~Qt::ItemIsEditable);
            ui->tableWidget_animation->setItem(row,1,res);
            QComboBox* timeLine = createTimelineBox("",fileName,TimelineType::Animation);
            ui->tableWidget_animation->setCellWidget(row,column+1,timeLine);
            //保存当前数据
            elem->statusEffect[row].res = fileName;
        }
    }
}

///动画区时间线数据发生改变
void MainWindow::onTimelineTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    //获取时间线列表所在位置
    std::cout<<"current timeline is:"<<qPrintable(arg1)<<std::endl;
    QComboBox *timeline = dynamic_cast<QComboBox*>(this->sender());
    int x = timeline->frameGeometry().x();
    int y = timeline->frameGeometry().y();
    QModelIndex index = ui->tableWidget_animation->indexAt(QPoint(x,y));
    int row = index.row();
    //修改数据
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    elem->statusEffect[row].timeline = timeline->currentText();
    std::cout<<"row:"<<row<<std::endl;
}

///容器池区时间线数据发生改变
void MainWindow::onPoolTimelineTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() == nullptr) return;
    //获取时间线列表所在位置
    std::cout<<"current timeline is:"<<qPrintable(arg1)<<std::endl;
    QComboBox *timeline = dynamic_cast<QComboBox*>(this->sender());
    int x = timeline->frameGeometry().x();
    int y = timeline->frameGeometry().y();
    QModelIndex index = ui->tableWidget_containerPool->indexAt(QPoint(x,y));
    int row = index.row();
    int column = index.column();
    //修改数据
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int poolIndex = ui->listWidget_pool->currentRow();
    if(column == 2) elem->container[poolIndex].table[row].initTimeline = timeline->currentText();
    else if(column == 3) elem->container[poolIndex].table[row].clickTimeline = timeline->currentText();
    else if(column == 4) elem->container[poolIndex].table[row].effectTimeline = timeline->currentText();
    else if(column == 5) elem->container[poolIndex].table[row].vanishTimeline = timeline->currentText();
    std::cout<<"row:"<<row<<"\tcolumn:"<<column<<std::endl;
}

///子元素使用池子数据发生改变
void MainWindow::onPoolsTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    //获取池子列表所在位置
    QComboBox *pools = dynamic_cast<QComboBox*>(this->sender());
    int x = pools->frameGeometry().x();
    int y = pools->frameGeometry().y();
    QModelIndex index = ui->tableWidget_childElem->indexAt(QPoint(x,y));
    int row = index.row();
    //修改数据
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    elem->childElem[row].container = arg1;
}

///事件配置checkBox状态发生改变
void MainWindow::onCheckBoxStateChanged(int state)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    //获取checkBox所在位置
    QCheckBox *check = dynamic_cast<QCheckBox*>(this->sender());
    int x = check->frameGeometry().x();
    int y = check->frameGeometry().y();
    QModelIndex index = ui->tableWidget_event->indexAt(QPoint(x,y));
    int row = index.row();
    int column = index.column();
    //修改数据
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int statusIndex = elem->getStatusValIndex(ui->listWidget_status->currentItem()->text());
    ElemPropertyData::EventConfig &eventData = elem->statusConfig[statusIndex].eventConfig[row];
    //是否需要颜色一致
    if(column == 1){
        if(state == 0) eventData.consisColor = false;
        else eventData.consisColor = true;
        std::cout<<"颜色是否需要一致状态："<<state<<std::endl;
    }
    else if(column == 4){
        if(state == 0) eventData.elimATLattices = false;
        else eventData.elimATLattices = true;
        std::cout<<"根据格子数量消除状态："<<state<<std::endl;
    }
    std::cout<<"row:"<<row<<"\tcolumn:"<<column<<std::endl;
}

///事件配置ComboBox选择发生改变
void MainWindow::onEventBoxTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    //获取特效列表所在位置
    QComboBox *box = dynamic_cast<QComboBox*>(this->sender());
    int x = box->frameGeometry().x();
    int y = box->frameGeometry().y();
    QModelIndex index = ui->tableWidget_event->indexAt(QPoint(x,y));
    int row = index.row();
    int column = index.column();
    //修改数据
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int statusIndex = elem->getStatusValIndex(ui->listWidget_status->currentItem()->text());
    QVector<ElemPropertyData::EventConfig> &eventTable = elem->statusConfig[statusIndex].eventConfig;
    if(column == 0) eventTable[row].name = arg1;
    else if(column == 3) eventTable[row].specialEffect = arg1;
    else if(column == 5) eventTable[row].triggerAction = arg1;
    std::cout<<"row:"<<row<<"\tcolumn:"<<column<<std::endl;
}

///动作配置中的设置点击后
void MainWindow::onSetActionButtonClicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    //获取设置按钮所在位置
    QPushButton *button = dynamic_cast<QPushButton*>(this->sender());
    int x = button->frameGeometry().x();
    int y = button->frameGeometry().y();
    QModelIndex index = ui->tableWidget_event->indexAt(QPoint(x,y));
    int row = index.row();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int statusIndex = elem->getStatusValIndex(ui->listWidget_status->currentItem()->text());
    QVector<ElemPropertyData::EventConfig> &eventTable = elem->statusConfig[statusIndex].eventConfig;
    QString action = eventTable[row].triggerAction;
    std::cout<<"row:"<<row<<std::endl;
    std::cout<<qPrintable(action)<<std::endl;
    createSetWindow(action,row);
}

///点击动作配置的设置按钮后生成新窗口
void MainWindow::createSetWindow(QString actionName,int row)
{
    QVector<ReadJsonSrc::Template> tempVec = jsonTemp->templateMap["actionTemp"];
    int index = jsonTemp->getTemplateIndex("actionTemp",actionName);
    if(index == -1){
        std::cout<<"未找到"<<qPrintable(actionName)<<"该动作配置模板"<<std::endl;
        return;
    }
    QVector<ReadJsonSrc::Fields> fields = tempVec[index].fields;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    //由于目前list只有动画，所以只做了一种情况；后期如果有多种list，可以将函数参数改为map
    QStringList list;
    for(const auto &i:elem->statusEffect) list.push_back(i.name);
    ActionSettingDialog setDialog;
    QMap<QString,QString> &dataMap = elem->statusConfig[ui->listWidget_status->currentRow()].eventConfig[row].actionConfig;
    setDialog.setDialogUi(fields,dataMap,list);
    setDialog.exec();
    if(!setDialog.dataMap.empty()) dataMap = setDialog.dataMap;
}

void MainWindow::on_pushButton_addAnimation_clicked()
{
    if(ui->listWidget_elem->currentItem()==nullptr) return;
    int rowNum = ui->tableWidget_animation->rowCount();
    ui->tableWidget_animation->insertRow(rowNum);
    QString elemName = ui->listWidget_elem->currentItem()->text();
    ElemPropertyData* elem = elements[elemName];
    QString animName = "anim";
    int id = 1;
    while(1){
        if(elem->isSingleAnimName(animName)){
            break;
        }
        animName = "anim" + QString::number(id++);
    }
    ui->tableWidget_animation->setItem(rowNum,0,new QTableWidgetItem(animName));
    QTableWidgetItem* res = new QTableWidgetItem("双击添加资源文件");
    // 此单元格不可编辑
    res->setFlags(res->flags() & ~Qt::ItemIsEditable);
    ui->tableWidget_animation->setItem(rowNum,1,res);
    ui->tableWidget_animation->setCellWidget(rowNum,2,createBox("",{}));
    ui->tableWidget_animation->setItem(rowNum,3,new QTableWidgetItem("0"));
    elem->statusEffect.push_back(ElemPropertyData::StatusEffect(animName));
    //更新与动画相关的下拉选项
    ui->comboBox_initAnim->addItem(animName);
    ui->comboBox_clickAnim->addItem(animName);
    ui->comboBox_animation->addItem(animName);
    //更新状态配置表格当前状态的特效下拉选项
    if(ui->listWidget_status->currentItem() != nullptr){
        int rowNum = ui->tableWidget_event->rowCount();
        for(int i=0;i<rowNum;i++){
            QComboBox *effect = qobject_cast<QComboBox*>(ui->tableWidget_event->cellWidget(i,3));
            effect->addItem(animName);
        }
    }
}


void MainWindow::on_pushButton_delAnimation_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->tableWidget_animation->currentRow() == -1) return;
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除动画","确定要删除此动画吗？");
    if(reply == QMessageBox::Yes){
        int curRow = ui->tableWidget_animation->currentRow();
        QString animName = ui->tableWidget_animation->item(curRow,0)->text();
        QVector<ElemPropertyData::StatusEffect> &animVec = elements[ui->listWidget_elem->currentItem()->text()]->statusEffect;
        animVec.remove(curRow);
        ui->tableWidget_animation->removeRow(curRow);
        //更新动画相关的下拉选项
        updateAnimComboBox(animName);
        ui->comboBox_initAnim->removeItem(ui->comboBox_initAnim->findText(animName));
        ui->comboBox_clickAnim->removeItem(ui->comboBox_clickAnim->findText(animName));
        ui->comboBox_animation->removeItem(ui->comboBox_animation->findText(animName));
    }  
}

void MainWindow::on_tableWidget_animation_itemChanged(QTableWidgetItem *item)
{
    if(!animTableItemChanged) return;
    animTableItemChanged = false;
    int column = item->column();
    int row = item->row();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QVector<ElemPropertyData::StatusEffect> &animVec = elem->statusEffect;
    if(column == 0){
        QString newName = ui->tableWidget_animation->item(row,0)->text();
        if(!elem->isSingleAnimName(newName)){
            QMessageBox::critical(this,"警告","该动画名已存在！");
            ui->tableWidget_animation->item(row,0)->setText(animVec[row].name);
            return;
        }
        std::cout<<"名字发生改变，新名字:"<<qPrintable(newName)<<std::endl;
        //更新动画相关的下拉选项
        updateAnimComboBox(animVec[row].name);
        ui->comboBox_initAnim->removeItem(ui->comboBox_initAnim->findText(animVec[row].name));
        ui->comboBox_clickAnim->removeItem(ui->comboBox_clickAnim->findText(animVec[row].name));
        ui->comboBox_animation->removeItem(ui->comboBox_animation->findText(animVec[row].name));
        ui->comboBox_initAnim->addItem(newName);
        ui->comboBox_clickAnim->addItem(newName);
        ui->comboBox_animation->addItem(newName);
        animVec[row].name = newName;
    }
    //资源名发生修改
    else if(column == 1){
        std::cout<<"动画资源发生改变，新资源名："<<qPrintable(ui->tableWidget_animation->item(row,1)->text())<<std::endl;
    }
    else{
        bool ok;double a = ui->tableWidget_animation->item(row,3)->text().toDouble(&ok);
        int zOrder = ui->tableWidget_animation->item(row,3)->text().toInt();
        if(!ok || zOrder<0 || zOrder>100000){
            QMessageBox::critical(this,"警告","z-Order值超出范围！");
            ui->tableWidget_animation->item(row,3)->setText(animVec[row].zOrder);
            return;
        }
        std::cout<<"z-Order值发生改变，新值为:"<<zOrder<<std::endl;
        animVec[row].zOrder = item->text();
    }
}

void MainWindow::on_pushButton_addCollectAnim_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString collAnimName = "collAnim";
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int id = 1;
    while(1){
        if(elem->getCollAnimIndex(collAnimName) == -1){
            break;
        }
        collAnimName = "collAnim" + QString::number(id++);
    }
    ui->listWidget_collectAnim->addItem(new QListWidgetItem(collAnimName));
    ElemPropertyData::CollAnim collAnim(collAnimName);
    elem->collAnim.push_back(collAnim);
    ui->comboBox_collectAnimation->addItem(collAnimName);
//    ui->listWidget_collectAnim->item(ui->listWidget_collectAnim->count() - 1)->setSelected(true); // 设置选中
//    ui->listWidget_collectAnim->scrollToBottom();
}

void MainWindow::on_pushButton_delCollectAnim_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_collectAnim->currentItem() == nullptr) return;
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除收集动画","确定要删除此收集动画吗？");
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    if(reply == QMessageBox::Yes){
        QString delName = ui->listWidget_collectAnim->currentItem()->text();
        QVector<ElemPropertyData::CollAnim> &collAnimVec = elem->collAnim;
        collAnimVec.remove(ui->listWidget_collectAnim->currentRow());
        delete ui->listWidget_collectAnim->takeItem(ui->listWidget_collectAnim->currentRow());
        updateCollAnimComboBox(delName);
        ui->comboBox_collectAnimation->removeItem(ui->comboBox_collectAnimation->findText(delName));
    }
}


void MainWindow::on_listWidget_collectAnim_itemDoubleClicked(QListWidgetItem *item)
{
    ChangeNameDialog newName;
    newName.setModal(true);
    newName.exec();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QString name = newName.getNewName();
    if(!name.isEmpty()){
        if(elem->getCollAnimIndex(name) != -1){
            QMessageBox::critical(this,"警告","该收集动画名已存在！");
            return;
        }
        updateCollAnimComboBox(item->text());
        ui->comboBox_collectAnimation->removeItem(ui->comboBox_collectAnimation->findText(item->text()));
        ui->comboBox_collectAnimation->addItem(name);
        elem->collAnim[elem->getCollAnimIndex(item->text())].name = name;
        item->setText(name);
    }
}

void MainWindow::on_comboBox_animationType_currentTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_collectAnim->currentItem() ==  nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_collectAnim->currentRow();
    elem->collAnim[index].type = arg1;
    std::cout<<"收集动画第"<<index<<"行动画类型改变："<<qPrintable(arg1)<<std::endl;
    elem->collAnim[index].dataMap.clear();
    setCollAnimWidget();
}

///设置收集动画动态界面
void MainWindow::setCollAnimWidget()
{
    QString animType = ui->comboBox_animationType->currentText();
    QFormLayout* formlayout = dynamic_cast<QFormLayout*>(ui->widget_dynamic->layout());
    int rowCout = formlayout->rowCount();
    for(int i=0;i<rowCout;i++) formlayout->removeRow(0);
    if(animType == "尚未选择") return;
    int index = jsonTemp->getTemplateIndex("collAnimTemp",animType);
    if(index == -1) {
        std::cout<<"未找到"<<qPrintable(animType)<<"收集动画类型对应模板"<<std::endl;
        return;
    }
    QVector<ReadJsonSrc::Template> tempVec = jsonTemp->templateMap["collAnimTemp"];
    QVector<ReadJsonSrc::Fields> fields = tempVec[index].fields;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QMap<QString,QString> &data = elem->collAnim[ui->listWidget_collectAnim->currentRow()].dataMap;
    for(const auto &i:fields){
        if(i.type == "list"){
            QStringList list;
            if(i.src == "animations"){
                for(const auto &anim:elem->statusEffect) list.push_back(anim.name);
            }
            QString val;
            if(data.find(i.name) != data.end()) val = data[i.name];
            else val = i.defaultVal;
            QComboBox* combo = createBox(val,list);
            connect(combo,SIGNAL(currentTextChanged(QString)),this,SLOT(onComboBoxTextChanged(QString)));
            formlayout->addRow(i.name,combo);
            data[i.name] = val;
        }
        else if(i.type == "input"){
            QString val;
            if(data.find(i.name) != data.end()) val = data[i.name];
            else val = i.defaultVal;
            QLineEdit* edit = new QLineEdit(val);
            connect(edit,SIGNAL(editingFinished()),this,SLOT(onLineEditTextChanged()));
            formlayout->addRow(i.name,edit);
            data[i.name] = val;
        }
    }
}

///收集动画动态界面下拉选项数据变化时
void MainWindow::onComboBoxTextChanged(QString arg)
{
    QComboBox *box = dynamic_cast<QComboBox*>(this->sender());
    QFormLayout* formlayout = dynamic_cast<QFormLayout*>(ui->widget_dynamic->layout());
    QLabel *label = dynamic_cast<QLabel*>(formlayout->labelForField(box));
    std::cout<<qPrintable(label->text())<<": "<<qPrintable(arg)<<std::endl;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    elem->collAnim[ui->listWidget_collectAnim->currentRow()].dataMap[label->text()] = arg;
}

///收集动画动态界面单行编辑数据变化时
void MainWindow::onLineEditTextChanged()
{
    QLineEdit *edit = dynamic_cast<QLineEdit*>(this->sender());
    QFormLayout* formlayout = dynamic_cast<QFormLayout*>(ui->widget_dynamic->layout());
    QLabel *label = dynamic_cast<QLabel*>(formlayout->labelForField(edit));
    std::cout<<qPrintable(label->text())<<": "<<qPrintable(edit->text())<<std::endl;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    elem->collAnim[ui->listWidget_collectAnim->currentRow()].dataMap[label->text()] = edit->text();
}


void MainWindow::on_comboBox_animation_currentTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_collectAnim->currentItem() ==  nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_collectAnim->currentRow();
    elem->collAnim[index].anim = arg1;
}

//设置收集动画显示
void MainWindow::setCollectAnimUi(QString collectAnimName)
{
    if(ui->listWidget_collectAnim->currentItem() != nullptr){
        isSetUi = true;
        ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
        ElemPropertyData::CollAnim collAnimData = elem->collAnim[elem->getCollAnimIndex(collectAnimName)];
        int typeIndex = ui->comboBox_animationType->findText(collAnimData.type);
        if(typeIndex == -1){
            typeIndex = 0;
            elem->collAnim[ui->listWidget_collectAnim->currentRow()].type = "尚未选择";
        }
        ui->comboBox_animationType->setCurrentIndex(typeIndex);
        setCollAnimWidget();
        int index = ui->comboBox_animation->findText(collAnimData.anim);
        if(index == -1) index = 0;
        ui->comboBox_animation->setCurrentIndex(index);
        isSetUi = false;
    }
}

void MainWindow::on_listWidget_collectAnim_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)
{
    //TODO: 或许需要另外保存当前界面的数据
    if(current != nullptr){
        setCollectAnimUi(current->text());
    }
}

//生成模板并更新状态配置的数据
void MainWindow::on_pushButton_genTemp_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->count() > 0) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    for(int i=0;i<elem->maxLayer.toInt();i++){
        ui->listWidget_status->addItem(QString::number(i));
        ElemPropertyData::StatusConfig status(QString::number(i));
        elem->statusConfig.push_back(status);
    }
}

//添加状态，若已经生成最大层数全部状态则按钮无效
void MainWindow::on_pushButton_addStatus_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QString statusName;
    for(int i=0;i<elem->maxLayer.toInt();i++){
        if(elem->getStatusValIndex(QString::number(i)) == -1){
            statusName = QString::number(i);
            break;
        }
    }
    if(!statusName.isEmpty()){
        ui->listWidget_status->addItem(statusName);
        ElemPropertyData::StatusConfig status(statusName);
        elem->statusConfig.push_back(status);
    }
}

//TODO: 删除状态值对应的数据
void MainWindow::on_pushButton_delStatus_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除状态","确定要删除此状态吗？");
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    if(reply == QMessageBox::Yes){
        for(int i=0;i<elem->statusConfig.size();i++){
            if(elem->statusConfig[i].statusValue == ui->listWidget_status->currentItem()->text()){
                elem->statusConfig.remove(i);
                break;
            }
        }
        delete ui->listWidget_status->takeItem(ui->listWidget_status->currentRow());
    }
}

//修改状态值，检查修改后的状态值是否合法，并转移数据
void MainWindow::on_listWidget_status_itemDoubleClicked(QListWidgetItem *item)
{
    ChangeNameDialog newName;
    newName.setModal(true);
    newName.exec();
    QString name = newName.getNewName();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    if(!name.isEmpty()){
        //TODO: 检查状态值合法性并转移数据
        bool isNum;double tmp = name.toDouble(&isNum);
        int maxlayer = ui->lineEdit_maxlayer->text().toInt();
        int statusNum = name.toInt();
        if(!isNum ||statusNum < 0 || statusNum >= maxlayer){
            QMessageBox::critical(this,"错误","状态值必须是大于等于0且小于最大层数的数字");
            return;
        }
        if(elem->getStatusValIndex(name) == -1){
            QMessageBox::critical(this,"警告","该状态值已存在");
            return;
        }
        int index = elem->getStatusValIndex(item->text());
        elem->statusConfig[index].statusValue = name;
        item->setText(name);
    }
}


void MainWindow::on_pushButton_addContainer_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    QString poolName = "pool";
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int id = 1;
    while(1){
        if(elem->getPoolIndex(poolName) == -1){
            break;
        }
        poolName = "pool" + QString::number(id++);
    }
    ui->listWidget_pool->addItem(new QListWidgetItem(poolName));
    ElemPropertyData::ContainerConfig container(poolName);
    elem->container.push_back(container);
    //子元素下拉列表添加可选项
    int rowNum = ui->tableWidget_childElem->rowCount();
    for(int i=0;i<rowNum;i++){
        QComboBox *containers = qobject_cast<QComboBox*>(ui->tableWidget_childElem->cellWidget(i,1));
        containers->addItem(poolName);
    }
}


void MainWindow::on_pushButton_delContainer_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() == nullptr) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除容器","确定要删除此容器吗？");
    if(reply == QMessageBox::Yes){
        QString delPoolName = ui->listWidget_pool->currentItem()->text();
        int index = ui->listWidget_pool->currentRow();
        elem->container.remove(index);
        delete ui->listWidget_pool->takeItem(ui->listWidget_pool->currentRow());
        //子元素下拉列表删除可选项
        int rowNum = ui->tableWidget_childElem->rowCount();
        for(int i=0;i<rowNum;i++){
            QComboBox *containers = qobject_cast<QComboBox*>(ui->tableWidget_childElem->cellWidget(i,1));
            if(elem->childElem[i].container == delPoolName) containers->setCurrentIndex(0);
            containers->removeItem(containers->findText(delPoolName));
        }
    }
}


void MainWindow::on_listWidget_pool_itemDoubleClicked(QListWidgetItem *item)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    ChangeNameDialog newName;
    newName.setModal(true);
    newName.exec();
    QString name = newName.getNewName();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    if(!name.isEmpty()){
        //TODO: 检查新名字唯一性
        if(elem->getPoolIndex(name) != -1){
            QMessageBox::critical(this,"警告","该容器名已存在！");
            return;
        }
        int index = elem->getPoolIndex(item->text());
        //子元素下拉列表可选项改名
        int rowNum = ui->tableWidget_childElem->rowCount();
        for(int i=0;i<rowNum;i++){
            QComboBox *containers = qobject_cast<QComboBox*>(ui->tableWidget_childElem->cellWidget(i,1));
            if(elem->childElem[i].container == elem->container[index].poolName) containers->setCurrentIndex(0);
            containers->removeItem(containers->findText(elem->container[index].poolName));
            containers->addItem(name);
        }
        elem->container[index].poolName = name;
        item->setText(name);
    }
}


void MainWindow::on_listWidget_pool_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)
{
    //TODO:保存切换前界面数据
    if(current != nullptr){
        setPoolUi(current->text());
    }
}

void MainWindow::on_pushButton_addKey_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() == nullptr) return;
    int rowNum = ui->tableWidget_containerPool->rowCount();
    ui->tableWidget_containerPool->insertRow(rowNum);
    QString keyName = "0";
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int id = 1;
    while(1){
        if(elem->isSingleContainerKey(ui->listWidget_pool->currentItem()->text(),keyName)){
            break;
        }
        keyName = QString::number(id++);
    }
    ui->tableWidget_containerPool->setItem(rowNum,0,new QTableWidgetItem(keyName));
    QTableWidgetItem* res = new QTableWidgetItem("双击添加资源文件");
    // 此单元格不可编辑
    res->setFlags(res->flags() & ~Qt::ItemIsEditable);
    ui->tableWidget_containerPool->setItem(rowNum,1,res);
    for(int i=2;i<=5;i++){
        ui->tableWidget_containerPool->setCellWidget(rowNum,i,createBox("",{}));
    }
    ui->tableWidget_containerPool->setItem(rowNum,3,new QTableWidgetItem("0"));
    int index = ui->listWidget_pool->currentRow();
    ElemPropertyData::ContainTable containTable(keyName);
    elem->container[index].table.push_back(containTable);
}


void MainWindow::on_pushButton_delKey_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() == nullptr || ui->tableWidget_containerPool->currentRow() == -1) return;
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除键值","确定要删除此键值吗？");
    if(reply == QMessageBox::Yes){
        int curRow = ui->tableWidget_containerPool->currentRow();
        QString containerName = ui->tableWidget_containerPool->item(curRow,0)->text();
        ElemPropertyData* elem =elements[ui->listWidget_elem->currentItem()->text()];
        int index = ui->listWidget_pool->currentRow();
        QVector<ElemPropertyData::ContainTable> &containerTable = elem->container[index].table;
        containerTable.remove(curRow);
        ui->tableWidget_containerPool->removeRow(curRow);
    }
}

void MainWindow::setPoolUi(QString poolName)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    isSetUi = true;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    ElemPropertyData::ContainerConfig poolData = elem->container[elem->getPoolIndex(poolName)];
    int contIndex = ui->comboBox_container->findText(poolData.type);
    if(contIndex == -1) contIndex=0;
    ui->comboBox_container->setCurrentIndex(contIndex);
    int rowNum = ui->tableWidget_containerPool->rowCount();
    for(int i=0;i<rowNum;i++){
        ui->tableWidget_containerPool->removeRow(0);
    }
    for(const auto &i:poolData.table){
        int rowNum = ui->tableWidget_containerPool->rowCount();
        ui->tableWidget_containerPool->insertRow(rowNum);
        ui->tableWidget_containerPool->setItem(rowNum,0,new QTableWidgetItem(i.key));
        QTableWidgetItem* res = new QTableWidgetItem(getFileName(i.res));
        // 此单元格不可编辑
        res->setFlags(res->flags() & ~Qt::ItemIsEditable);
        ui->tableWidget_containerPool->setItem(rowNum,1,res);
        ui->tableWidget_containerPool->setCellWidget(rowNum,2,createTimelineBox(i.initTimeline,i.res,TimelineType::Pool));
        ui->tableWidget_containerPool->setCellWidget(rowNum,3,createTimelineBox(i.clickTimeline,i.res,TimelineType::Pool));
        ui->tableWidget_containerPool->setCellWidget(rowNum,4,createTimelineBox(i.effectTimeline,i.res,TimelineType::Pool));
        ui->tableWidget_containerPool->setCellWidget(rowNum,5,createTimelineBox(i.vanishTimeline,i.res,TimelineType::Pool));
        ui->tableWidget_containerPool->setItem(rowNum,6,new QTableWidgetItem(i.zOrder));
    }
    isSetUi = false;
}

void MainWindow::on_tableWidget_containerPool_cellDoubleClicked(int row, int column)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() == nullptr) return;
    //容器表格内容修改flag
    poolTableItemChanged = true;
    if(column == 1){
        ResFileDialog res;
        res.setModal(true);
        res.exec();
        QString fileName = res.getResName();
        if(!fileName.isEmpty()){
            ui->tableWidget_containerPool->setItem(row,column,new QTableWidgetItem(getFileName(fileName)));
            ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
            int index = ui->listWidget_pool->currentRow();
            elem->container[index].table[row].res = fileName;
            //加载时间线下拉列表
            for(int i=2;i<=5;i++){
                QComboBox* timeline = createTimelineBox("",fileName,TimelineType::Pool);
                ui->tableWidget_containerPool->setCellWidget(row,i,timeline);
            }
        }
    }
}


void MainWindow::on_tableWidget_containerPool_itemChanged(QTableWidgetItem *item)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() == nullptr) return;
    if(!poolTableItemChanged) return;
    poolTableItemChanged = false;
    int column = item->column();
    int row = item->row();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_pool->currentRow();
    QVector<ElemPropertyData::ContainTable> &containerVec = elem->container[index].table;
    if(column == 0){
        bool isNum;double tmp = item->text().toDouble(&isNum);
        if(item->text().toInt() < 0 || !isNum){
            QMessageBox::critical(this,"错误","键值必须是大于等于0的数字");
            item->setText(containerVec[row].key);
            return;
        }
        if(!elem->isSingleContainerKey(ui->listWidget_pool->currentItem()->text(),item->text())){
            QMessageBox::critical(this,"警告","该键值已存在！");
            item->setText(containerVec[row].key);
            return;
        }
        containerVec[row].key = item->text();
    }
    //检查zOrder合法性
    else if(column == 6){
        QString zOrder = item->text();
        bool isNum;double tmp = zOrder.toDouble(&isNum);
        if(item->text().toInt() < 0 || !isNum){
            QMessageBox::critical(this,"错误","消失zOrder值必须是大于等于0的数字");
            item->setText(containerVec[row].zOrder);
            return;
        }
        containerVec[row].zOrder = zOrder;
    }
}

void MainWindow::on_pushButton_addChildElem_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    int rowNum = ui->tableWidget_childElem->rowCount();
    ui->tableWidget_childElem->insertRow(rowNum);
    QString childElemName = "item";
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int id = 1;
    while(1){
        if(elem->isSingleChildElemName(childElemName)){
            break;
        }
        childElemName = "item" + QString::number(id++);
    }
    ui->tableWidget_childElem->setItem(rowNum,0,new QTableWidgetItem(childElemName));
    ui->tableWidget_childElem->setCellWidget(rowNum,1,createPoolBox("尚未选择"));
    elem->childElem.push_back(ElemPropertyData::ChildElem(childElemName));
}

void MainWindow::on_pushButton_delChildElem_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->tableWidget_childElem->currentRow() == -1) return;
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除子元素","确定要删除此子元素吗？");
    if(reply == QMessageBox::Yes){
        int curRow = ui->tableWidget_childElem->currentRow();
        QString childElemName = ui->tableWidget_childElem->item(curRow,0)->text();
        QVector<ElemPropertyData::ChildElem> &childElemVec = elements[ui->listWidget_elem->currentItem()->text()]->childElem;
        childElemVec.remove(curRow);
        ui->tableWidget_childElem->removeRow(curRow);
    }
}


void MainWindow::on_tableWidget_childElem_itemChanged(QTableWidgetItem *item)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    if(!childElemTableItemChanged) return;
    childElemTableItemChanged = false;
    int column = item->column();
    int row = item->row();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QVector<ElemPropertyData::ChildElem> &childElemVec = elem->childElem;
    if(column == 0){
        if(!elem->isSingleChildElemName(item->text())){
            QMessageBox::critical(this,"警告","该子元素名已存在！");
            item->setText(childElemVec[row].name);
            return;
        }
        childElemVec[row].name = item->text();
    }
    //TODO: comboBox值修改后的保存
}


void MainWindow::on_tableWidget_childElem_cellDoubleClicked(int row, int column)
{
    if(ui->listWidget_elem->currentItem() == nullptr) return;
    //子元素表格双击改名置flag为true
    childElemTableItemChanged = true;
}

void MainWindow::on_checkBox_multiHit_stateChanged(int arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    if(arg1){
        elem->statusConfig[index].multiHit = true;
    }
    else{
        elem->statusConfig[index].multiHit = false;
    }
}


void MainWindow::on_checkBox_dropable_stateChanged(int arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    if(arg1){
        elem->statusConfig[index].dropable = true;
    }
    else{
        elem->statusConfig[index].dropable = false;
    }
}


void MainWindow::on_checkBox_needCollect_stateChanged(int arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    if(arg1){
        elem->statusConfig[index].needCollect = true;
        ui->lineEdit_collectionType->setReadOnly(false);
    }
    else{
        elem->statusConfig[index].needCollect = false;
        ui->lineEdit_collectionType->setReadOnly(true);
    }
}


void MainWindow::on_lineEdit_collectionType_editingFinished()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    ElemPropertyData::StatusConfig &data = elem->statusConfig[index];
    data.collTargetType = ui->lineEdit_collectionType->text();
    std::cout<<"收集的目标类型"<<qPrintable(data.collTargetType)<<std::endl;
}



void MainWindow::on_pushButton_addEvent_clicked()
{
    if(ui->listWidget_elem->currentItem()==nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    int rowNum = ui->tableWidget_event->rowCount();
    ui->tableWidget_event->insertRow(rowNum);
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    ElemPropertyData::EventConfig event;
    int index = ui->listWidget_status->currentRow();
    elem->statusConfig[index].eventConfig.push_back(event);
    ui->tableWidget_event->setCellWidget(rowNum,0,createEventBox("尚未选择"));
    ui->tableWidget_event->setCellWidget(rowNum,1,createCheckBox(false));
    ui->tableWidget_event->setCellWidget(rowNum,3,createEffectBox("尚未选择"));
    ui->tableWidget_event->setCellWidget(rowNum,4,createCheckBox(false));
    ui->tableWidget_event->setCellWidget(rowNum,5,createTriggerAction("尚未选择"));
    ui->tableWidget_event->setCellWidget(rowNum,6,createSetButton());
}


void MainWindow::on_listWidget_status_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)
{
    if(ui->listWidget_elem->currentItem() == nullptr || current == nullptr) return;
    isSetUi = true;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = elem->getStatusValIndex(current->text());
    ElemPropertyData::StatusConfig statusData = elem->statusConfig[index];
    int comboIndex;
    //初始化动画
    comboIndex = ui->comboBox_initAnim->findText(statusData.initAnim);
    if(comboIndex == -1) comboIndex = 0;
    ui->comboBox_initAnim->setCurrentIndex(comboIndex);
    //点击动画
    comboIndex = ui->comboBox_clickAnim->findText(statusData.clickAnim);
    if(comboIndex == -1) comboIndex = 0;
    ui->comboBox_clickAnim->setCurrentIndex(comboIndex);
    //收集动画
    comboIndex = ui->comboBox_collectAnimation->findText(statusData.collAnim);
    if(comboIndex == -1) comboIndex = 0;
    ui->comboBox_collectAnimation->setCurrentIndex(comboIndex);
    //多重打击
    if(statusData.multiHit) ui->checkBox_multiHit->setCheckState(Qt::Checked);
    else ui->checkBox_multiHit->setCheckState(Qt::Unchecked);
    //可掉落
    if(statusData.dropable) ui->checkBox_multiHit->setCheckState(Qt::Checked);
    else ui->checkBox_dropable->setCheckState(Qt::Unchecked);
    //是否需要收集
    ui->lineEdit_collectionType->clear();
    if(statusData.needCollect){
        ui->checkBox_needCollect->setCheckState(Qt::Checked);
        ui->lineEdit_collectionType->setReadOnly(false);
        std::cout<<"收集的目标类型"<<qPrintable(statusData.collTargetType)<<std::endl;
        ui->lineEdit_collectionType->setText(statusData.collTargetType);
    }
    else{
        ui->checkBox_needCollect->setCheckState(Qt::Unchecked);
        ui->lineEdit_collectionType->setReadOnly(true);
    }
    //事件配置
    int rowNum = ui->tableWidget_event->rowCount();
    for(int i=0;i<rowNum;i++){
        ui->tableWidget_event->removeRow(0);
    }
    for(const auto &i:statusData.eventConfig){
        rowNum = ui->tableWidget_event->rowCount();
        ui->tableWidget_event->insertRow(rowNum);
        //事件名称
        ui->tableWidget_event->setCellWidget(rowNum,0,createEventBox(i.name));
        std::cout<<"重置状态配置ui：事件名称："<<qPrintable(i.name)<<std::endl;
        //是否需要颜色一致
        ui->tableWidget_event->setCellWidget(rowNum,1,createCheckBox(i.consisColor));
        //tableWidget_event
        ui->tableWidget_event->setItem(rowNum,2,new QTableWidgetItem(i.changeMagnitude));
        //特效
        ui->tableWidget_event->setCellWidget(rowNum,3,createEffectBox(i.specialEffect));
        //根据格子数量消除
        ui->tableWidget_event->setCellWidget(rowNum,4,createCheckBox(i.elimATLattices));
        //触发动作
        ui->tableWidget_event->setCellWidget(rowNum,5,createTriggerAction(i.triggerAction));
        //触发动作设置
        ui->tableWidget_event->setCellWidget(rowNum,6,createSetButton());
    }
    isSetUi = false;
}

void MainWindow::on_tableWidget_event_cellDoubleClicked(int row, int column)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    if(column == 2) eventTableItemChanged = true;
}

//状态变化幅度合法性检查及数据保存
void MainWindow::on_tableWidget_event_itemChanged(QTableWidgetItem *item)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    if(!eventTableItemChanged) return;
    eventTableItemChanged = false;
    int column = item->column();
    int row = item->row();
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    QVector<ElemPropertyData::EventConfig> &eventVec = elem->statusConfig[index].eventConfig;
    if(column == 2){
        bool ok;double a = item->text().toDouble(&ok);
        int val = item->text().toInt();
        if(!ok || val<0){
            QMessageBox::critical(this,"警告","状态变化幅度是大于0的数字");
            ui->tableWidget_event->item(row,2)->setText(QString::number(eventVec[row].changeMagnitude));
            return;
        }
        std::cout<<"状态变化幅度发生改变，新值为:"<<val<<std::endl;
        eventVec[row].changeMagnitude = val;
    }
}


void MainWindow::on_comboBox_initAnim_currentTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr || isSetUi) return;
    std::cout<<"初始化动画："<<qPrintable(arg1)<<std::endl;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    elem->statusConfig[index].initAnim = arg1;
}


void MainWindow::on_comboBox_clickAnim_currentTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    elem->statusConfig[index].clickAnim = arg1;
}


void MainWindow::on_comboBox_collectAnimation_currentTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int index = ui->listWidget_status->currentRow();
    elem->statusConfig[index].collAnim = arg1;
}

///模板更新后更新与模板配置相关的界面显示
void MainWindow::updateTempRelatedUi()
{
    isSetUi = true;
    //收集动画
    ui->comboBox_animationType->clear();
    ui->comboBox_animationType->addItem("尚未选择");
    for(const auto &i:jsonTemp->templateMap["collAnimTemp"]) ui->comboBox_animationType->addItem(i.name);
    //状态配置
    int rowNum = ui->tableWidget_event->rowCount();
    for(int i=0;i<rowNum;i++){
        //事件名称配置
        ui->tableWidget_event->setCellWidget(i,0,createEventBox("尚未选择"));
        ui->tableWidget_event->setCellWidget(i,5,createTriggerAction("尚未选择"));
    }
    //容器池
    ui->comboBox_container->clear();
    ui->comboBox_container->addItem("尚未选择");
    for(const auto &i:jsonTemp->templateMap["poolTemp"]) ui->comboBox_container->addItem(i.name);
    int animIndex = 0,poolIndex = 0;

    //若当前界面选择的选项没有被改变，仍然保持当前选项
    if(ui->listWidget_elem->currentItem() != nullptr){
        ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
        //收集动画
        if(ui->listWidget_collectAnim->currentItem() != nullptr) {
            int index = ui->listWidget_collectAnim->currentRow();
            std::cout<<"当前选择的收集动画类型："<<qPrintable(elem->collAnim[index].type)<<std::endl;
            animIndex = ui->comboBox_animationType->findText(elem->collAnim[index].type);
            if(animIndex == -1){
                animIndex = 0;
                elem->collAnim[ui->listWidget_collectAnim->currentRow()].type = "尚未选择";
            }
            setCollAnimWidget();
        }
        //容器池
        if(ui->listWidget_pool->currentItem() != nullptr){
            int index = ui->listWidget_pool->currentRow();
            std::cout<<"当前选择的容器类型："<<qPrintable(elem->container[index].type)<<std::endl;
            poolIndex = ui->comboBox_container->findText(elem->container[index].type);
            if(poolIndex == -1) poolIndex = 0;
        }
        //事件配置
        if(ui->listWidget_status->currentItem() != nullptr){
            int index = ui->listWidget_status->currentRow();
            int rowNum = ui->tableWidget_event->rowCount();
            for(int i=0;i<rowNum;i++){
                //事件配置
                QComboBox* nameBox = dynamic_cast<QComboBox*>(ui->tableWidget_event->cellWidget(i,0));
                QComboBox* actionBox = dynamic_cast<QComboBox*>(ui->tableWidget_event->cellWidget(i,5));
                int eindex = nameBox->findText(elem->statusConfig[index].eventConfig[i].name);
                if(eindex != -1) nameBox->setCurrentIndex(eindex);
                std::cout<<"当前触发动作："<<qPrintable(elem->statusConfig[index].eventConfig[i].triggerAction)<<std::endl;
                int aindex = actionBox->findText(elem->statusConfig[index].eventConfig[i].triggerAction);
                if(aindex != -1) actionBox->setCurrentIndex(aindex);
            }
        }
    }
    ui->comboBox_animationType->setCurrentIndex(animIndex);
    ui->comboBox_container->setCurrentIndex(poolIndex);
    isSetUi = false;
}

void MainWindow::on_reloadTempFile_triggered()
{
    ReadJsonSrc* tmp = jsonTemp;
    jsonTemp = new ReadJsonSrc(":/file/file/template.json");
    delete tmp;
    updateTempRelatedUi();
}


void MainWindow::on_comboBox_container_currentTextChanged(const QString &arg1)
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_pool->currentItem() ==  nullptr || isSetUi) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    int poolIndex = ui->listWidget_pool->currentRow();
    elem->container[poolIndex].type = arg1;
    std::cout<<"容器池第"<<poolIndex<<"行容器类型改变："<<qPrintable(arg1)<<std::endl;
}

///删除事件
void MainWindow::on_pushButton_delEvent_clicked()
{
    if(ui->listWidget_elem->currentItem() == nullptr || ui->listWidget_status->currentItem() == nullptr) return;
    if(ui->tableWidget_event->currentRow() == -1) return;
    ElemPropertyData* elem = elements[ui->listWidget_elem->currentItem()->text()];
    QMessageBox::StandardButton reply = QMessageBox::question(this,"删除事件","确定要删除此事件吗？");
    if(reply == QMessageBox::Yes){
        int curRow = ui->tableWidget_event->currentRow();
        QVector<ElemPropertyData::EventConfig> &eventTable = elem->statusConfig[ui->listWidget_status->currentRow()].eventConfig;
        eventTable.remove(curRow);
        ui->tableWidget_event->removeRow(curRow);
    }
}


void MainWindow::on_tabWidget_currentChanged(int index)
{
    if(index==1 && ui->listWidget_collectAnim->currentItem()!=nullptr){
        setCollAnimWidget();
    }
}