diff options
Diffstat (limited to 'utils/regtools/qeditor/regedit.cpp')
| -rw-r--r-- | utils/regtools/qeditor/regedit.cpp | 1324 |
1 files changed, 1324 insertions, 0 deletions
diff --git a/utils/regtools/qeditor/regedit.cpp b/utils/regtools/qeditor/regedit.cpp new file mode 100644 index 0000000000..5e498ce496 --- /dev/null +++ b/utils/regtools/qeditor/regedit.cpp @@ -0,0 +1,1324 @@ +#include "regedit.h" +#include <QFileDialog> +#include <QDebug> +#include <QHeaderView> +#include <QMessageBox> +#include <QInputDialog> + +/** + * EmptyEditPanel + */ +EmptyEditPanel::EmptyEditPanel(QWidget *parent) + :QWidget(parent) +{ +} + +/** + * SocEditPanel + */ +SocEditPanel::SocEditPanel(SocRef ref, QWidget *parent) + :QWidget(parent), m_ref(ref) +{ + m_name_group = new QGroupBox("Name", this); + m_name_edit = new QLineEdit(this); + m_name_edit->setText(QString::fromStdString(ref.GetSoc().name)); + QVBoxLayout *name_group_layout = new QVBoxLayout; + name_group_layout->addWidget(m_name_edit); + m_name_group->setLayout(name_group_layout); + + m_desc_group = new QGroupBox("Description", this); + QHBoxLayout *group_layout = new QHBoxLayout; + m_desc_edit = new MyTextEditor(this); + m_desc_edit->SetTextHtml(QString::fromStdString(ref.GetSoc().desc)); + group_layout->addWidget(m_desc_edit); + m_desc_group->setLayout(group_layout); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addWidget(m_name_group); + layout->addWidget(m_desc_group); + layout->addStretch(1); + + connect(m_name_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnNameEdited(const QString&))); + connect(m_desc_edit, SIGNAL(OnTextChanged()), this, SLOT(OnTextEdited())); + + setLayout(layout); +} + +void SocEditPanel::OnNameEdited(const QString& text) +{ + m_ref.GetSoc().name = text.toStdString(); + emit OnModified(m_name_edit->isModified()); +} + +void SocEditPanel::OnTextEdited() +{ + m_ref.GetSoc().desc = m_desc_edit->GetTextHtml().toStdString(); + emit OnModified(m_desc_edit->IsModified()); +} + +/** + * DevEditPanel + */ +DevEditPanel::DevEditPanel(SocDevRef ref, QWidget *parent) + :QWidget(parent), m_ref(ref) +{ + m_name_group = new QGroupBox("Name", this); + m_name_edit = new QLineEdit(this); + m_name_edit->setText(QString::fromStdString(ref.GetDev().name)); + QVBoxLayout *name_group_layout = new QVBoxLayout; + name_group_layout->addWidget(m_name_edit); + m_name_group->setLayout(name_group_layout); + + m_long_name_group = new QGroupBox("Long Name", this); + m_long_name_edit = new QLineEdit(this); + m_long_name_edit->setText(QString::fromStdString(ref.GetDev().long_name)); + QVBoxLayout *long_name_group_layout = new QVBoxLayout; + long_name_group_layout->addWidget(m_long_name_edit); + m_long_name_group->setLayout(long_name_group_layout); + + m_version_group = new QGroupBox("Version", this); + m_version_edit = new QLineEdit(this); + m_version_edit->setText(QString::fromStdString(ref.GetDev().version)); + QVBoxLayout *version_group_layout = new QVBoxLayout; + version_group_layout->addWidget(m_version_edit); + m_version_group->setLayout(version_group_layout); + + QVBoxLayout *name_ver_layout = new QVBoxLayout; + name_ver_layout->addWidget(m_name_group); + name_ver_layout->addWidget(m_long_name_group); + name_ver_layout->addWidget(m_version_group); + name_ver_layout->addStretch(); + + m_instances_table = new QTableWidget(this); + m_instances_table->setRowCount(ref.GetDev().addr.size() + 1); + m_instances_table->setColumnCount(3); + for(size_t row = 0; row < ref.GetDev().addr.size(); row++) + FillRow(row, ref.GetDev().addr[row]); + CreateNewRow(ref.GetDev().addr.size()); + m_instances_table->setHorizontalHeaderItem(0, new QTableWidgetItem("")); + m_instances_table->setHorizontalHeaderItem(1, new QTableWidgetItem("Name")); + m_instances_table->setHorizontalHeaderItem(2, new QTableWidgetItem("Address")); + m_instances_table->verticalHeader()->setVisible(false); + m_instances_table->resizeColumnsToContents(); + m_instances_table->horizontalHeader()->setStretchLastSection(true); + m_instances_table->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); + m_instances_group = new QGroupBox("Instances", this); + QHBoxLayout *instances_group_layout = new QHBoxLayout; + instances_group_layout->addWidget(m_instances_table); + m_instances_group->setLayout(instances_group_layout); + + QHBoxLayout *top_layout = new QHBoxLayout; + top_layout->addWidget(m_instances_group); + top_layout->addLayout(name_ver_layout); + top_layout->addStretch(); + + m_desc_group = new QGroupBox("Description", this); + QHBoxLayout *group_layout = new QHBoxLayout; + m_desc_edit = new MyTextEditor(this); + m_desc_edit->SetTextHtml(QString::fromStdString(ref.GetDev().desc)); + group_layout->addWidget(m_desc_edit); + m_desc_group->setLayout(group_layout); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addLayout(top_layout, 0); + layout->addWidget(m_desc_group, 1); + + setLayout(layout); + + SocFieldItemDelegate *m_table_delegate = new SocFieldItemDelegate(this); + QItemEditorFactory *m_table_edit_factory = new QItemEditorFactory(); + SocFieldEditorCreator *m_table_edit_creator = new SocFieldEditorCreator(); + m_table_edit_factory->registerEditor(QVariant::UInt, m_table_edit_creator); + m_table_delegate->setItemEditorFactory(m_table_edit_factory); + m_instances_table->setItemDelegate(m_table_delegate); + + connect(m_instances_table, SIGNAL(cellActivated(int,int)), this, SLOT(OnInstActivated(int,int))); + connect(m_instances_table, SIGNAL(cellChanged(int,int)), this, SLOT(OnInstChanged(int,int))); + connect(m_name_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnNameEdited(const QString&))); + connect(m_long_name_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnLongNameEdited(const QString&))); + connect(m_version_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnVersionEdited(const QString&))); + connect(m_desc_edit, SIGNAL(OnTextChanged()), this, SLOT(OnDescEdited())); +} + +void DevEditPanel::OnNameEdited(const QString& text) +{ + m_ref.GetDev().name = text.toStdString(); + emit OnModified(m_name_edit->isModified()); +} + +void DevEditPanel::OnLongNameEdited(const QString& text) +{ + m_ref.GetDev().long_name = text.toStdString(); + emit OnModified(m_long_name_edit->isModified()); +} + +void DevEditPanel::OnVersionEdited(const QString& text) +{ + m_ref.GetDev().version = text.toStdString(); + emit OnModified(m_version_edit->isModified()); +} + +void DevEditPanel::OnDescEdited() +{ + m_ref.GetDev().desc = m_desc_edit->GetTextHtml().toStdString(); + emit OnModified(m_desc_edit->IsModified()); +} + +void DevEditPanel::CreateNewRow(int row) +{ + QTableWidgetItem *item = new QTableWidgetItem(QIcon::fromTheme("list-add"), "", DevInstNewType); + item->setToolTip("New?"); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, DevInstIconColumn, item); + item = new QTableWidgetItem("New instance..."); + QFont font = item->font(); + font.setItalic(true); + item->setFont(font); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, DevInstNameColumn, item); + item = new QTableWidgetItem(""); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, DevInstAddrColumn, item); +} + +void DevEditPanel::FillRow(int row, const soc_dev_addr_t& addr) +{ + QTableWidgetItem *item = new QTableWidgetItem(QString::fromStdString(addr.name)); + item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + m_instances_table->setItem(row, DevInstNameColumn, item); + item = new QTableWidgetItem(); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + item->setData(Qt::DisplayRole, QVariant(addr.addr)); + m_instances_table->setItem(row, DevInstAddrColumn, item); + item = new QTableWidgetItem(QIcon::fromTheme("list-remove"), "", DevInstDeleteType); + item->setToolTip("Remove?"); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, DevInstIconColumn, item); +} + +void DevEditPanel::OnInstActivated(int row, int column) +{ + if(column != 0) + return; + int type = m_instances_table->item(row, column)->type(); + if(type == DevInstDeleteType) + { + m_ref.GetDev().addr.erase(m_ref.GetDev().addr.begin() + row); + m_instances_table->removeRow(row); + } + else if(type == DevInstNewType) + { + m_instances_table->insertRow(row); + soc_dev_addr_t addr; + addr.name = QString("UNNAMED_%1").arg(row).toStdString(); + addr.addr = 0; + m_ref.GetDev().addr.push_back(addr); + FillRow(row, addr); + } +} + +void DevEditPanel::OnInstChanged(int row, int column) +{ + /* ignore extra row for addition */ + if(row >= (int)m_ref.GetDev().addr.size()) + return; + QTableWidgetItem *item = m_instances_table->item(row, column); + if(column == DevInstNameColumn) + { + m_ref.GetDev().addr[row].name = item->text().toStdString(); + emit OnModified(true); + } + else if(column == DevInstAddrColumn) + { + m_ref.GetDev().addr[row].addr = item->data(Qt::DisplayRole).toUInt(); + emit OnModified(true); + } +} + +/** + * RegEditPanel + */ + +RegEditPanel::RegEditPanel(SocRegRef ref, QWidget *parent) + :QWidget(parent), m_ref(ref), m_reg_font(font()) +{ + m_reg_font.setWeight(100); + m_reg_font.setKerning(false); + + m_name_group = new QGroupBox("Name", this); + m_name_edit = new QLineEdit(this); + m_name_edit->setText(QString::fromStdString(ref.GetReg().name)); + QVBoxLayout *name_group_layout = new QVBoxLayout; + name_group_layout->addWidget(m_name_edit); + m_name_group->setLayout(name_group_layout); + + m_instances_table = new QTableWidget(this); + m_instances_table->setRowCount(ref.GetReg().addr.size() + 1); + m_instances_table->setColumnCount(RegInstNrColumns); + for(size_t row = 0; row < ref.GetReg().addr.size(); row++) + FillRow(row, ref.GetReg().addr[row]); + CreateNewAddrRow(ref.GetReg().addr.size()); + m_instances_table->setHorizontalHeaderItem(RegInstIconColumn, new QTableWidgetItem("")); + m_instances_table->setHorizontalHeaderItem(RegInstNameColumn, new QTableWidgetItem("Name")); + m_instances_table->setHorizontalHeaderItem(RegInstAddrColumn, new QTableWidgetItem("Address")); + m_instances_table->verticalHeader()->setVisible(false); + m_instances_table->resizeColumnsToContents(); + m_instances_table->horizontalHeader()->setStretchLastSection(true); + m_instances_table->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); + m_instances_group = new QGroupBox("Instances", this); + QHBoxLayout *instances_group_layout = new QHBoxLayout; + instances_group_layout->addWidget(m_instances_table); + m_instances_group->setLayout(instances_group_layout); + + m_desc_group = new QGroupBox("Description", this); + QHBoxLayout *group_layout = new QHBoxLayout; + m_desc_edit = new MyTextEditor(this); + m_desc_edit->SetTextHtml(QString::fromStdString(ref.GetReg().desc)); + group_layout->addWidget(m_desc_edit); + m_desc_group->setLayout(group_layout); + + bool has_sct = m_ref.GetReg().flags & REG_HAS_SCT; + m_sct_check = new QCheckBox("Set/Clear/Toggle", this); + m_sct_check->setCheckState(has_sct ? Qt::Checked : Qt::Unchecked); + QHBoxLayout *flags_layout = new QHBoxLayout; + flags_layout->addWidget(m_sct_check); + flags_layout->addStretch(); + m_flags_group = new QGroupBox("Flags", this); + m_flags_group->setLayout(flags_layout); + + m_formula_combo = new QComboBox(this); + m_formula_combo->addItem("None", QVariant(REG_FORMULA_NONE)); + m_formula_combo->addItem("String", QVariant(REG_FORMULA_STRING)); + m_formula_combo->setCurrentIndex(m_formula_combo->findData(QVariant(m_ref.GetReg().formula.type))); + m_formula_type_label = new QLabel("Type:", this); + QHBoxLayout *formula_top_layout = new QHBoxLayout; + formula_top_layout->addWidget(m_formula_type_label); + formula_top_layout->addWidget(m_formula_combo); + m_formula_string_edit = new QLineEdit(QString::fromStdString(ref.GetReg().formula.string), this); + QVBoxLayout *formula_layout = new QVBoxLayout; + formula_layout->addLayout(formula_top_layout); + formula_layout->addWidget(m_formula_string_edit); + m_formula_string_gen = new QPushButton("Generate", this); + formula_layout->addWidget(m_formula_string_gen); + m_formula_group = new QGroupBox("Formula", this); + m_formula_group->setLayout(formula_layout); + + QVBoxLayout *name_layout = new QVBoxLayout; + name_layout->addWidget(m_name_group); + name_layout->addWidget(m_flags_group); + name_layout->addWidget(m_formula_group); + name_layout->addStretch(); + + QHBoxLayout *top_layout = new QHBoxLayout; + top_layout->addWidget(m_instances_group); + top_layout->addLayout(name_layout); + top_layout->addWidget(m_desc_group, 1); + + m_sexy_display = new RegSexyDisplay(m_ref, this); + m_sexy_display->setFont(m_reg_font); + + m_field_table = new QTableWidget; + m_field_table->setRowCount(m_ref.GetReg().field.size()); + m_field_table->setColumnCount(4); + for(size_t row = 0; row < m_ref.GetReg().field.size(); row++) + { + const soc_reg_field_t& field = m_ref.GetReg().field[row]; + QString bits_str; + if(field.first_bit == field.last_bit) + bits_str.sprintf("%d", field.first_bit); + else + bits_str.sprintf("%d:%d", field.last_bit, field.first_bit); + QTableWidgetItem *item = new QTableWidgetItem(bits_str); + item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_field_table->setItem(row, 1, item); + item = new QTableWidgetItem(QString(field.name.c_str())); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_field_table->setItem(row, 2, item); + item = new QTableWidgetItem(QString(field.desc.c_str())); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_field_table->setItem(row, 3, item); + UpdateWarning(row); + } + m_field_table->setHorizontalHeaderItem(0, new QTableWidgetItem("")); + m_field_table->setHorizontalHeaderItem(1, new QTableWidgetItem("Bits")); + m_field_table->setHorizontalHeaderItem(2, new QTableWidgetItem("Name")); + m_field_table->setHorizontalHeaderItem(3, new QTableWidgetItem("Description")); + m_field_table->verticalHeader()->setVisible(false); + m_field_table->resizeColumnsToContents(); + m_field_table->horizontalHeader()->setStretchLastSection(true); + QHBoxLayout *field_layout = new QHBoxLayout; + field_layout->addWidget(m_field_table); + m_field_group = new QGroupBox("Flags", this); + m_field_group->setLayout(field_layout); + + QVBoxLayout *layout = new QVBoxLayout; + layout->addLayout(top_layout, 0); + layout->addWidget(m_sexy_display, 0); + layout->addWidget(m_field_group); + + UpdateFormula(); + + setLayout(layout); + + SocFieldItemDelegate *m_table_delegate = new SocFieldItemDelegate(this); + QItemEditorFactory *m_table_edit_factory = new QItemEditorFactory(); + SocFieldEditorCreator *m_table_edit_creator = new SocFieldEditorCreator(); + m_table_edit_factory->registerEditor(QVariant::UInt, m_table_edit_creator); + m_table_delegate->setItemEditorFactory(m_table_edit_factory); + m_instances_table->setItemDelegate(m_table_delegate); + + connect(m_instances_table, SIGNAL(cellActivated(int,int)), this, SLOT(OnInstActivated(int,int))); + connect(m_instances_table, SIGNAL(cellChanged(int,int)), this, SLOT(OnInstChanged(int,int))); + connect(m_name_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnNameEdited(const QString&))); + connect(m_desc_edit, SIGNAL(OnTextChanged()), this, SLOT(OnDescEdited())); + connect(m_sct_check, SIGNAL(stateChanged(int)), this, SLOT(OnSctEdited(int))); + connect(m_formula_combo, SIGNAL(currentIndexChanged(int)), this, SLOT(OnFormulaChanged(int))); + connect(m_formula_string_edit, SIGNAL(textChanged(const QString&)), this, + SLOT(OnFormulaStringChanged(const QString&))); + connect(m_formula_string_gen, SIGNAL(clicked(bool)), this, SLOT(OnFormulaGenerate(bool))); +} + +void RegEditPanel::UpdateWarning(int row) +{ + Q_UNUSED(row); +} + +void RegEditPanel::OnFormulaStringChanged(const QString& text) +{ + m_ref.GetReg().formula.string = text.toStdString(); + emit OnModified(true); +} + +void RegEditPanel::OnFormulaGenerate(bool checked) +{ + Q_UNUSED(checked); + bool ok; + int count = QInputDialog::getInt(this, "Instance generator", "Number of instances", + 0, 0, 100, 1, &ok); + if(!ok) + return; + std::string name(m_ref.GetReg().name); + size_t pos = name.find('n'); + if(pos == std::string::npos) + { + name.push_back('n'); + pos = name.size() - 1; + } + std::map< std::string, soc_word_t > map; + std::vector< std::pair< std::string, soc_word_t > > list; + std::string formula = m_ref.GetReg().formula.string; + for(int n = 0; n < count; n++) + { + map["n"] = n; + std::string err; + soc_word_t res; + if(!soc_desc_evaluate_formula(formula, map, res, err)) + { + qDebug() << "Cannot evaluator " << QString::fromStdString(formula) + << "for n=" << n << ": " << QString::fromStdString(err); + return; + } + std::string regname = name; + std::string strn = QString("%1").arg(n).toStdString(); + regname.replace(pos, 1, strn); + list.push_back(std::make_pair(regname, res)); + } + // everything went good, commit result + while(m_instances_table->rowCount() > 1) + m_instances_table->removeRow(0); + m_ref.GetReg().addr.resize(list.size()); + for(size_t i = 0; i < list.size(); i++) + { + m_instances_table->insertRow(i); + m_ref.GetReg().addr[i].name = list[i].first; + m_ref.GetReg().addr[i].addr = list[i].second; + FillRow(i, m_ref.GetReg().addr[i]); + } +} + +void RegEditPanel::OnFormulaChanged(int index) +{ + if(index == -1) + return; + m_ref.GetReg().formula.type = static_cast< soc_reg_formula_type_t >(m_formula_combo->itemData(index).toInt()); + UpdateFormula(); + emit OnModified(true); +} + +void RegEditPanel::UpdateFormula() +{ + m_formula_string_edit->hide(); + m_formula_string_gen->hide(); + switch(m_ref.GetReg().formula.type) + { + case REG_FORMULA_STRING: + m_formula_string_edit->show(); + m_formula_string_gen->show(); + break; + case REG_FORMULA_NONE: + default: + break; + } +} + +void RegEditPanel::OnSctEdited(int state) +{ + if(state == Qt::Checked) + m_ref.GetReg().flags |= REG_HAS_SCT; + else + m_ref.GetReg().flags &= ~REG_HAS_SCT; + emit OnModified(true); +} + +void RegEditPanel::FillRow(int row, const soc_reg_addr_t& addr) +{ + QTableWidgetItem *item = new QTableWidgetItem(QString::fromStdString(addr.name)); + item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + m_instances_table->setItem(row, RegInstNameColumn, item); + item = new QTableWidgetItem(); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + item->setData(Qt::DisplayRole, QVariant(addr.addr)); + m_instances_table->setItem(row, RegInstAddrColumn, item); + item = new QTableWidgetItem(QIcon::fromTheme("list-remove"), "", RegInstDeleteType); + item->setToolTip("Remove?"); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, RegInstIconColumn, item); +} + +void RegEditPanel::CreateNewAddrRow(int row) +{ + QTableWidgetItem *item = new QTableWidgetItem(QIcon::fromTheme("list-add"), "", RegInstNewType); + item->setToolTip("New?"); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, RegInstIconColumn, item); + item = new QTableWidgetItem("New instance..."); + QFont font = item->font(); + font.setItalic(true); + item->setFont(font); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, RegInstNameColumn, item); + item = new QTableWidgetItem(""); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_instances_table->setItem(row, RegInstAddrColumn, item); +} + +void RegEditPanel::OnNameEdited(const QString& text) +{ + m_ref.GetReg().name = text.toStdString(); + emit OnModified(m_name_edit->isModified()); +} + +void RegEditPanel::OnDescEdited() +{ + m_ref.GetReg().desc = m_desc_edit->GetTextHtml().toStdString(); + emit OnModified(m_desc_edit->IsModified()); +} + +void RegEditPanel::OnInstActivated(int row, int column) +{ + if(column != 0) + return; + int type = m_instances_table->item(row, column)->type(); + if(type == RegInstDeleteType) + { + m_ref.GetReg().addr.erase(m_ref.GetReg().addr.begin() + row); + m_instances_table->removeRow(row); + } + else if(type == RegInstNewType) + { + m_instances_table->insertRow(row); + soc_reg_addr_t addr; + addr.name = QString("UNNAMED_%1").arg(row).toStdString(); + addr.addr = 0; + m_ref.GetReg().addr.push_back(addr); + FillRow(row, addr); + } +} + +void RegEditPanel::OnInstChanged(int row, int column) +{ + /* ignore extra row for addition */ + if(row >= (int)m_ref.GetReg().addr.size()) + return; + QTableWidgetItem *item = m_instances_table->item(row, column); + if(column == RegInstNameColumn) + { + m_ref.GetReg().addr[row].name = item->text().toStdString(); + emit OnModified(true); + } + else if(column == RegInstAddrColumn) + { + m_ref.GetReg().addr[row].addr = item->data(Qt::DisplayRole).toUInt(); + emit OnModified(true); + } +} + +/** + * FieldEditPanel + */ +FieldEditPanel::FieldEditPanel(SocFieldRef ref, QWidget *parent) + :QWidget(parent), m_ref(ref) +{ + m_name_group = new QGroupBox("Name", this); + m_name_edit = new QLineEdit(this); + m_name_edit->setText(QString::fromStdString(ref.GetField().name)); + QVBoxLayout *name_group_layout = new QVBoxLayout; + name_group_layout->addWidget(m_name_edit); + m_name_group->setLayout(name_group_layout); + + m_bitrange_group = new QGroupBox("Bit Range", this); + m_bitrange_edit = new QLineEdit(this); + const soc_reg_field_t& field = ref.GetField(); + QString bits_str; + if(field.first_bit == field.last_bit) + bits_str.sprintf("%d", field.first_bit); + else + bits_str.sprintf("%d:%d", field.last_bit, field.first_bit); + m_bitrange_edit->setText(bits_str); + m_bitrange_edit->setValidator(new SocBitRangeValidator(m_bitrange_edit)); + QVBoxLayout *bitrange_group_layout = new QVBoxLayout; + bitrange_group_layout->addWidget(m_bitrange_edit); + m_bitrange_group->setLayout(bitrange_group_layout); + + m_desc_group = new QGroupBox("Description", this); + QHBoxLayout *group_layout = new QHBoxLayout; + m_desc_edit = new MyTextEditor(this); + m_desc_edit->SetTextHtml(QString::fromStdString(ref.GetField().desc)); + group_layout->addWidget(m_desc_edit); + m_desc_group->setLayout(group_layout); + + m_value_group = new QGroupBox("Values", this); + QHBoxLayout *value_layout = new QHBoxLayout; + m_value_table = new QTableWidget(this); + m_value_table->setRowCount(ref.GetField().value.size() + 1); + m_value_table->setColumnCount(FieldValueNrColumns); + for(size_t row = 0; row < ref.GetField().value.size(); row++) + FillRow(row, ref.GetField().value[row]); + CreateNewRow(ref.GetField().value.size()); + m_value_table->setHorizontalHeaderItem(FieldValueIconColumn, new QTableWidgetItem("")); + m_value_table->setHorizontalHeaderItem(FieldValueNameColumn, new QTableWidgetItem("Name")); + m_value_table->setHorizontalHeaderItem(FieldValueValueColumn, new QTableWidgetItem("Value")); + m_value_table->setHorizontalHeaderItem(FieldValueDescColumn, new QTableWidgetItem("Description")); + m_value_table->verticalHeader()->setVisible(false); + m_value_table->horizontalHeader()->setStretchLastSection(true); + value_layout->addWidget(m_value_table); + m_value_group->setLayout(value_layout); + + QHBoxLayout *line_layout = new QHBoxLayout; + line_layout->addWidget(m_name_group); + line_layout->addWidget(m_bitrange_group); + line_layout->addStretch(); + + QVBoxLayout *left_layout = new QVBoxLayout; + left_layout->addLayout(line_layout); + left_layout->addWidget(m_desc_group); + left_layout->addWidget(m_value_group, 1); + + UpdateDelegates(); + + connect(m_name_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnNameEdited(const QString&))); + connect(m_desc_edit, SIGNAL(OnTextChanged()), this, SLOT(OnDescEdited())); + connect(m_value_table, SIGNAL(cellActivated(int,int)), this, SLOT(OnValueActivated(int,int))); + connect(m_value_table, SIGNAL(cellChanged(int,int)), this, SLOT(OnValueChanged(int,int))); + connect(m_bitrange_edit, SIGNAL(textChanged(const QString&)), this, SLOT(OnBitRangeEdited(const QString&))); + + setLayout(left_layout); +} + +void FieldEditPanel::UpdateDelegates() +{ + SocFieldItemDelegate *m_table_delegate = new SocFieldItemDelegate(m_ref.GetField(), this); + QItemEditorFactory *m_table_edit_factory = new QItemEditorFactory(); + SocFieldEditorCreator *m_table_edit_creator = new SocFieldEditorCreator(m_ref.GetField()); + m_table_edit_factory->registerEditor(QVariant::UInt, m_table_edit_creator); + m_table_delegate->setItemEditorFactory(m_table_edit_factory); + m_value_table->setItemDelegate(m_table_delegate); + m_value_table->resizeColumnsToContents(); +} + +void FieldEditPanel::UpdateWarning(int row) +{ + soc_word_t val = m_ref.GetField().value[row].value; + soc_word_t max = m_ref.GetField().bitmask() >> m_ref.GetField().first_bit; + QTableWidgetItem *item = m_value_table->item(row, FieldValueValueColumn); + if(val > max) + { + item->setIcon(QIcon::fromTheme("dialog-warning")); + item->setToolTip("Value is too big for the field"); + } + else + { + item->setIcon(QIcon()); + item->setToolTip(""); + } +} + +void FieldEditPanel::FillRow(int row, const soc_reg_field_value_t& val) +{ + QTableWidgetItem *item = new QTableWidgetItem(QString::fromStdString(val.name)); + item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + m_value_table->setItem(row, FieldValueNameColumn, item); + item = new QTableWidgetItem(); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + item->setData(Qt::DisplayRole, QVariant(val.value)); + m_value_table->setItem(row, FieldValueValueColumn, item); + item = new QTableWidgetItem(QString::fromStdString(val.desc)); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable); + m_value_table->setItem(row, FieldValueDescColumn, item); + item = new QTableWidgetItem(QIcon::fromTheme("list-remove"), "", FieldValueDeleteType); + item->setToolTip("Remove?"); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_value_table->setItem(row, FieldValueIconColumn, item); + UpdateWarning(row); +} + +void FieldEditPanel::CreateNewRow(int row) +{ + QTableWidgetItem *item = new QTableWidgetItem(QIcon::fromTheme("list-add"), "", FieldValueNewType); + item->setToolTip("New?"); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_value_table->setItem(row, FieldValueIconColumn, item); + item = new QTableWidgetItem("New value..."); + QFont font = item->font(); + font.setItalic(true); + item->setFont(font); + item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); + m_value_table->setItem(row, FieldValueNameColumn, item); +} + +void FieldEditPanel::OnBitRangeEdited(const QString& input) +{ + const SocBitRangeValidator *validator = + dynamic_cast< const SocBitRangeValidator *>(m_bitrange_edit->validator()); + int first, last; + QValidator::State state = validator->parse(input, last, first); + if(state != QValidator::Acceptable) + return; + m_ref.GetField().first_bit = first; + m_ref.GetField().last_bit = last; + // update all warning signs + for(size_t row = 0; row < m_ref.GetField().value.size(); row++) + UpdateWarning(row); + // also updates delegates because they now have the wrong view of the field + UpdateDelegates(); + emit OnModified(true); +} + +void FieldEditPanel::OnNameEdited(const QString& text) +{ + m_ref.GetField().name = text.toStdString(); + emit OnModified(m_name_edit->isModified()); +} + +void FieldEditPanel::OnDescEdited() +{ + m_ref.GetField().desc = m_desc_edit->GetTextHtml().toStdString(); + emit OnModified(m_desc_edit->IsModified()); +} + +void FieldEditPanel::OnValueActivated(int row, int column) +{ + if(column != 0) + return; + int type = m_value_table->item(row, column)->type(); + if(type == FieldValueDeleteType) + { + m_ref.GetField().value.erase(m_ref.GetField().value.begin() + row); + m_value_table->removeRow(row); + } + else if(type == FieldValueNewType) + { + m_value_table->insertRow(row); + soc_reg_field_value_t val; + val.name = QString("UNNAMED_%1").arg(row).toStdString(); + val.value = 0; + m_ref.GetField().value.push_back(val); + FillRow(row, val); + } +} + +void FieldEditPanel::OnValueChanged(int row, int column) +{ + /* ignore extra row for addition */ + if(row >= (int)m_ref.GetField().value.size()) + return; + QTableWidgetItem *item = m_value_table->item(row, column); + if(column == FieldValueNameColumn) + m_ref.GetField().value[row].name = item->text().toStdString(); + else if(column == FieldValueValueColumn) + { + soc_word_t& fval = m_ref.GetField().value[row].value; + soc_word_t new_val = item->data(Qt::DisplayRole).toUInt(); + /* avoid infinite recursion by calling UpdateWarning() when + * only the icon changes which would trigger this callback again */ + if(fval != new_val) + { + fval = new_val; + UpdateWarning(row); + } + } + else if(column == FieldValueDescColumn) + m_ref.GetField().value[row].desc = item->text().toStdString(); + emit OnModified(true); +} + +namespace +{ + +enum +{ + SocTreeSocType = QTreeWidgetItem::UserType, + SocTreeDevType, + SocTreeRegType, + SocTreeFieldType, + SocTreeNewDevType, + SocTreeNewRegType, + SocTreeNewFieldType, +}; + +/** + * SocTreeItem + */ + +class SocTreeItem : public QTreeWidgetItem +{ +public: + SocTreeItem(const QString& string, const SocRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeSocType), m_ref(ref) {} + + const SocRef& GetRef() { return m_ref; } +private: + SocRef m_ref; +}; + +/** + * NewDevTreeItem + */ + +class NewDevTreeItem : public QTreeWidgetItem +{ +public: + NewDevTreeItem(const QString& string, const SocRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeNewDevType), m_ref(ref) {} + + const SocRef& GetRef() { return m_ref; } +private: + SocRef m_ref; +}; + +/** + * DevTreeItem + */ + +class DevTreeItem : public QTreeWidgetItem +{ +public: + DevTreeItem(const QString& string, const SocDevRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeDevType), m_ref(ref) {} + + const SocDevRef& GetRef() { return m_ref; } +private: + SocDevRef m_ref; +}; + +/** + * NewRegTreeItem + */ + +class NewRegTreeItem : public QTreeWidgetItem +{ +public: + NewRegTreeItem(const QString& string, const SocDevRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeNewRegType), m_ref(ref) {} + + const SocDevRef& GetRef() { return m_ref; } +private: + SocDevRef m_ref; +}; + +/** + * RegTreeItem + */ + +class RegTreeItem : public QTreeWidgetItem +{ +public: + RegTreeItem(const QString& string, const SocRegRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeRegType), m_ref(ref) {} + + const SocRegRef& GetRef() { return m_ref; } +private: + SocRegRef m_ref; +}; + +/** + * NewFieldTreeItem + */ + +class NewFieldTreeItem : public QTreeWidgetItem +{ +public: + NewFieldTreeItem(const QString& string, const SocRegRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeNewFieldType), m_ref(ref) {} + + const SocRegRef& GetRef() { return m_ref; } +private: + SocRegRef m_ref; +}; + +/** + * FieldTreeItem + */ + +class FieldTreeItem : public QTreeWidgetItem +{ +public: + FieldTreeItem(const QString& string, const SocFieldRef& ref) + :QTreeWidgetItem(QStringList(string), SocTreeFieldType), m_ref(ref) {} + + const SocFieldRef& GetRef() { return m_ref; } +private: + SocFieldRef m_ref; +}; + +} + +/** + * RegEdit + */ +RegEdit::RegEdit(Backend *backend, QWidget *parent) + :QWidget(parent), m_backend(backend) +{ + QVBoxLayout *m_vert_layout = new QVBoxLayout(); + m_file_group = new QGroupBox("File selection", this); + QHBoxLayout *m_file_group_layout = new QHBoxLayout(); + m_file_edit = new QLineEdit(this); + m_file_edit->setReadOnly(true); + m_file_open = new QToolButton(this); + m_file_open->setText("Open"); + m_file_open->setIcon(QIcon::fromTheme("document-open")); + m_file_open->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); + QMenu *file_open_menu = new QMenu(this); + QAction *new_act = file_open_menu->addAction(QIcon::fromTheme("document-new"), "New..."); + m_file_open->setMenu(file_open_menu); + + m_file_save = new QToolButton(this); + m_file_save->setText("Save"); + m_file_save->setIcon(QIcon::fromTheme("document-save")); + m_file_save->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); + QMenu *file_save_menu = new QMenu(this); + QAction *saveas_act = file_save_menu->addAction(QIcon::fromTheme("document-save-as"), "Save as..."); + m_file_save->setMenu(file_save_menu); + m_file_group_layout->addWidget(m_file_open); + m_file_group_layout->addWidget(m_file_save); + m_file_group_layout->addWidget(m_file_edit); + + m_splitter = new QSplitter(this); + m_soc_tree = new QTreeWidget(this); + m_soc_tree->setColumnCount(1); + m_soc_tree->setHeaderLabel(QString("Name")); + m_splitter->addWidget(m_soc_tree); + m_splitter->setStretchFactor(0, 0); + + m_file_group->setLayout(m_file_group_layout); + m_vert_layout->addWidget(m_file_group); + m_vert_layout->addWidget(m_splitter, 1); + + setLayout(m_vert_layout); + + SetModified(false, false); + m_right_panel = 0; + SetPanel(new EmptyEditPanel(this)); + + connect(m_file_open, SIGNAL(clicked()), this, SLOT(OnOpen())); + connect(m_file_save, SIGNAL(clicked()), this, SLOT(OnSave())); + connect(new_act, SIGNAL(triggered()), this, SLOT(OnNew())); + connect(saveas_act, SIGNAL(triggered()), this, SLOT(OnSaveAs())); + connect(m_soc_tree, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)), + this, SLOT(OnSocItemChanged(QTreeWidgetItem*, QTreeWidgetItem*))); + connect(m_soc_tree, SIGNAL(itemActivated(QTreeWidgetItem*, int)), + this, SLOT(OnSocItemActivated(QTreeWidgetItem*, int))); +} + +RegEdit::~RegEdit() +{ +} + +void RegEdit::OnSave() +{ + SaveSoc(); +} + +void RegEdit::OnSaveAs() +{ + SaveSocAs(); +} + +bool RegEdit::CloseSoc() +{ + if(!m_modified) + return true; + QMessageBox msgBox; + msgBox.setText("The description has been modified."); + msgBox.setInformativeText("Do you want to save your changes?"); + msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel); + msgBox.setDefaultButton(QMessageBox::Save); + int ret = msgBox.exec(); + if(ret == QMessageBox::Discard) + return true; + if(ret == QMessageBox::Cancel) + return false; + return SaveSoc(); +} + +bool RegEdit::SaveSoc() +{ + if(m_file_edit->text().size() == 0) + return SaveSocAs(); + else + return SaveSocFile(m_file_edit->text()); +} + +bool RegEdit::GetFilename(QString& filename, bool save) +{ + QFileDialog *fd = new QFileDialog(this); + if(save) + fd->setAcceptMode(QFileDialog::AcceptSave); + fd->setFilter("Description files (*.xml);;All files (*)"); + fd->setDirectory(Settings::Get()->value("loaddescdir", QDir::currentPath()).toString()); + if(fd->exec()) + { + QStringList filenames = fd->selectedFiles(); + filename = filenames[0]; + Settings::Get()->setValue("loaddescdir", fd->directory().absolutePath()); + return true; + } + else + return false; +} + +bool RegEdit::SaveSocAs() +{ + QString filename; + if(!GetFilename(filename, true)) + return false; + m_file_edit->setText(filename); + return SaveSocFile(filename); +} + +void RegEdit::OnOpen() +{ + if(!CloseSoc()) + return; + QString filename; + if(!GetFilename(filename, false)) + return; + LoadSocFile(filename); +} + +void RegEdit::OnNew() +{ + if(!CloseSoc()) + return; + m_cur_socfile = SocFile(); + m_file_edit->setText(""); + SetModified(false, false); + UpdateSocFile(); +} + +bool RegEdit::SaveSocFile(const QString& filename) +{ + soc_desc_normalize(m_cur_socfile.GetSoc()); + if(!soc_desc_produce_xml(filename.toStdString(), m_cur_socfile.GetSoc())) + { + QMessageBox::warning(this, "The description was not saved", + "There was an error when saving the file"); + return false; + } + m_soc_tree->clear(); + FillSocTree(); + SetModified(false, false); + return true; +} + +void RegEdit::LoadSocFile(const QString& filename) +{ + m_cur_socfile = SocFile(filename); + if(!m_cur_socfile.IsValid()) + { + QMessageBox::warning(this, "The description was not loaded", + "There was an error when loading the file"); + return; + } + m_file_edit->setText(filename); + SetModified(false, false); + UpdateSocFile(); +} + +void RegEdit::CreateNewFieldItem(QTreeWidgetItem *_parent) +{ + RegTreeItem *parent = dynamic_cast< RegTreeItem* >(_parent); + NewFieldTreeItem *newdev_item = new NewFieldTreeItem("New field...", parent->GetRef()); + MakeItalic(newdev_item, true); + newdev_item->setIcon(0, QIcon::fromTheme("list-add")); + parent->addChild(newdev_item); +} + +void RegEdit::FillRegTreeItem(QTreeWidgetItem *_item) +{ + RegTreeItem *item = dynamic_cast< RegTreeItem* >(_item); + const soc_reg_t& reg = item->GetRef().GetReg(); + for(size_t i = 0; i < reg.field.size(); i++) + { + const soc_reg_field_t& field = reg.field[i]; + FieldTreeItem *field_item = new FieldTreeItem(QString::fromStdString(field.name), + SocFieldRef(item->GetRef(), i)); + FixupEmptyItem(field_item); + item->addChild(field_item); + } + CreateNewFieldItem(item); +} + +void RegEdit::CreateNewRegisterItem(QTreeWidgetItem *_parent) +{ + DevTreeItem *parent = dynamic_cast< DevTreeItem* >(_parent); + NewRegTreeItem *newdev_item = new NewRegTreeItem("New register...", parent->GetRef()); + MakeItalic(newdev_item, true); + newdev_item->setIcon(0, QIcon::fromTheme("list-add")); + parent->addChild(newdev_item); +} + +void RegEdit::FillDevTreeItem(QTreeWidgetItem *_item) +{ + DevTreeItem *item = dynamic_cast< DevTreeItem* >(_item); + const soc_dev_t& dev = item->GetRef().GetDev(); + for(size_t i = 0; i < dev.reg.size(); i++) + { + const soc_reg_t& reg = dev.reg[i]; + RegTreeItem *reg_item = new RegTreeItem(QString::fromStdString(reg.name), + SocRegRef(item->GetRef(), i, -1)); + FixupEmptyItem(reg_item); + FillRegTreeItem(reg_item); + item->addChild(reg_item); + } + CreateNewRegisterItem(item); +} + +void RegEdit::CreateNewDeviceItem(QTreeWidgetItem *_parent) +{ + SocTreeItem *parent = dynamic_cast< SocTreeItem* >(_parent); + NewDevTreeItem *newdev_item = new NewDevTreeItem("New device...", parent->GetRef()); + MakeItalic(newdev_item, true); + newdev_item->setIcon(0, QIcon::fromTheme("list-add")); + parent->addChild(newdev_item); +} + +void RegEdit::FillSocTreeItem(QTreeWidgetItem *_item) +{ + SocTreeItem *item = dynamic_cast< SocTreeItem* >(_item); + const soc_t& soc = item->GetRef().GetSoc(); + for(size_t i = 0; i < soc.dev.size(); i++) + { + const soc_dev_t& reg = soc.dev[i]; + DevTreeItem *dev_item = new DevTreeItem(QString::fromStdString(reg.name), + SocDevRef(item->GetRef(), i, -1)); + FixupEmptyItem(dev_item); + FillDevTreeItem(dev_item); + item->addChild(dev_item); + } + CreateNewDeviceItem(item); +} + +void RegEdit::FillSocTree() +{ + SocRef ref = m_cur_socfile.GetSocRef(); + SocTreeItem *soc_item = new SocTreeItem( + QString::fromStdString(ref.GetSoc().name), ref); + FixupEmptyItem(soc_item); + FillSocTreeItem(soc_item); + m_soc_tree->addTopLevelItem(soc_item); + soc_item->setExpanded(true); +} + +void RegEdit::MakeItalic(QTreeWidgetItem *item, bool it) +{ + QFont font = item->font(0); + font.setItalic(it); + item->setFont(0, font); +} + +void RegEdit::FixupEmptyItem(QTreeWidgetItem *item) +{ + if(item->text(0).size() == 0) + { + item->setIcon(0, QIcon::fromTheme("dialog-error")); + MakeItalic(item, true); + item->setText(0, "Unnamed"); + } + else + { + item->setIcon(0, QIcon::fromTheme("cpu")); + MakeItalic(item, false); + } +} + +void RegEdit::UpdateSocFile() +{ + m_soc_tree->clear(); + FillSocTree(); + SetPanel(new EmptyEditPanel(this)); +} + +void RegEdit::SetPanel(QWidget *panel) +{ + delete m_right_panel; + m_right_panel = panel; + connect(m_right_panel, SIGNAL(OnModified(bool)), this, SLOT(OnSocModified(bool))); + m_splitter->addWidget(m_right_panel); + m_splitter->setStretchFactor(1, 2); +} + +void RegEdit::SetModified(bool add, bool mod) +{ + m_modified = add ? (m_modified || mod) : mod; + emit OnModified(mod); +} + +void RegEdit::OnSocModified(bool modified) +{ + // we might need to update the name in the tree + UpdateName(m_soc_tree->currentItem()); + if(modified) + SetModified(true, true); +} + +void RegEdit::DisplaySoc(SocRef ref) +{ + SetPanel(new SocEditPanel(ref, this)); +} + +void RegEdit::DisplayDev(SocDevRef ref) +{ + SetPanel(new DevEditPanel(ref, this)); +} + +void RegEdit::DisplayReg(SocRegRef ref) +{ + SetPanel(new RegEditPanel(ref, this)); +} + +void RegEdit::DisplayField(SocFieldRef ref) +{ + SetPanel(new FieldEditPanel(ref, this)); +} + +void RegEdit::UpdateName(QTreeWidgetItem *current) +{ + if(current == 0) + return; + if(current->type() == SocTreeSocType) + { + SocTreeItem *item = dynamic_cast< SocTreeItem * >(current); + item->setText(0, QString::fromStdString(item->GetRef().GetSoc().name)); + } + else if(current->type() == SocTreeDevType) + { + DevTreeItem *item = dynamic_cast< DevTreeItem * >(current); + item->setText(0, QString::fromStdString(item->GetRef().GetDev().name)); + } + else if(current->type() == SocTreeRegType) + { + RegTreeItem *item = dynamic_cast< RegTreeItem * >(current); + item->setText(0, QString::fromStdString(item->GetRef().GetReg().name)); + } + else if(current->type() == SocTreeFieldType) + { + FieldTreeItem *item = dynamic_cast< FieldTreeItem * >(current); + item->setText(0, QString::fromStdString(item->GetRef().GetField().name)); + } + FixupEmptyItem(current); +} + +void RegEdit::OnSocItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous) +{ + Q_UNUSED(previous); + if(current == 0) + return; + if(current->type() == SocTreeSocType) + { + SocTreeItem *item = dynamic_cast< SocTreeItem * >(current); + DisplaySoc(item->GetRef()); + } + else if(current->type() == SocTreeDevType) + { + DevTreeItem *item = dynamic_cast< DevTreeItem * >(current); + DisplayDev(item->GetRef()); + } + else if(current->type() == SocTreeRegType) + { + RegTreeItem *item = dynamic_cast< RegTreeItem * >(current); + DisplayReg(item->GetRef()); + } + else if(current->type() == SocTreeFieldType) + { + FieldTreeItem *item = dynamic_cast< FieldTreeItem * >(current); + DisplayField(item->GetRef()); + } +} + +void RegEdit::OnSocItemActivated(QTreeWidgetItem *current, int column) +{ + Q_UNUSED(column); + if(current == 0) + return; + if(current->type() == SocTreeNewDevType) + AddDevice(current); + else if(current->type() == SocTreeNewRegType) + AddRegister(current); + else if(current->type() == SocTreeNewFieldType) + AddField(current); +} + +void RegEdit::AddDevice(QTreeWidgetItem *_item) +{ + NewDevTreeItem *item = dynamic_cast< NewDevTreeItem * >(_item); + item->GetRef().GetSoc().dev.push_back(soc_dev_t()); + DevTreeItem *dev_item = new DevTreeItem("", + SocDevRef(item->GetRef(), item->GetRef().GetSoc().dev.size() - 1, -1)); + FixupEmptyItem(dev_item); + item->parent()->insertChild(item->parent()->indexOfChild(item), dev_item); + CreateNewRegisterItem(dev_item); + m_soc_tree->setCurrentItem(dev_item); +} + +void RegEdit::AddRegister(QTreeWidgetItem *_item) +{ + NewRegTreeItem *item = dynamic_cast< NewRegTreeItem * >(_item); + item->GetRef().GetDev().reg.push_back(soc_reg_t()); + RegTreeItem *reg_item = new RegTreeItem("", + SocRegRef(item->GetRef(), item->GetRef().GetDev().reg.size() - 1, -1)); + FixupEmptyItem(reg_item); + item->parent()->insertChild(item->parent()->indexOfChild(item), reg_item); + CreateNewFieldItem(reg_item); + m_soc_tree->setCurrentItem(reg_item); +} + +void RegEdit::AddField(QTreeWidgetItem *_item) +{ + NewFieldTreeItem *item = dynamic_cast< NewFieldTreeItem * >(_item); + item->GetRef().GetReg().field.push_back(soc_reg_field_t()); + FieldTreeItem *field_item = new FieldTreeItem("", + SocFieldRef(item->GetRef(), item->GetRef().GetReg().field.size() - 1)); + FixupEmptyItem(field_item); + item->parent()->insertChild(item->parent()->indexOfChild(item), field_item); + m_soc_tree->setCurrentItem(field_item); +} + +bool RegEdit::Quit() +{ + return CloseSoc(); +}
\ No newline at end of file |