codeboss
/
QBinaryTranslate
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update:添加unit、添加field基础逻辑

This commit is contained in:
codeboss 2025-08-19 22:46:49 +08:00
parent 0d2a32faea
commit ac9b0f4e2c
7 changed files with 153 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
TranslateUI/ExtractRuleView.cpp
View File

@ -20,7 +20,7 @@ using namespace extract;
ExtractRuleView::ExtractRuleView(std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::AsRuleSet> inst_r, QWidget* p /*= nullptr*/)
: QWidget(p), _rule_base(inst_r), _base_bind(base),
: QWidget(p), _current_rule(inst_r), _basic_bind(base),
_member_units(new QTableView(this)),
_member_model(new QStandardItemModel(this)),
_configs_stack(new QStackedWidget(this))
@ -42,11 +42,14 @@ ExtractRuleView::ExtractRuleView(std::shared_ptr<TranslateBasic> base,
auto union_configs = new UnionBasedConfiguration(base, this);
_configs_stack->addWidget(union_configs);
connect(single_configs, &SingleBasedConfiguration::reloadRequest, this, &ExtractRuleView::reload);
connect(list_configs, &ListBasedConfiguration::reloadRequest, this, &ExtractRuleView::reload);
connect(union_configs, &UnionBasedConfiguration::reloadRequest, this, &ExtractRuleView::reload);
connect(_member_units, &QTableView::clicked, [=](const QModelIndex& target) {
if (!target.isValid())
return;
auto unit = _rule_base->operator[](target.row());
auto unit = _current_rule->operator[](target.row());
if (unit->baseType() == SingleBasedUnit::topic()) {
_configs_stack->setCurrentIndex(1);
single_configs->currentAccept(unit, target);
@ -54,8 +57,8 @@ ExtractRuleView::ExtractRuleView(std::shared_ptr<TranslateBasic> base,
else if (unit->baseType() == ListBasedUnit::topic()) {
_configs_stack->setCurrentIndex(2);
_current_fields_cache = std::make_shared<FieldManagerLayer>("{self}");
this->_rule_base->registSubField(_current_fields_cache);
auto current_field = this->_rule_base->operator[](target.row());
this->_current_rule->registSubField(_current_fields_cache);
auto current_field = this->_current_rule->operator[](target.row());
_current_fields_cache->bindCurrent(current_field->name());
list_configs->currentAccept(unit, target, _current_fields_cache);
}
@ -69,6 +72,8 @@ ExtractRuleView::ExtractRuleView(std::shared_ptr<TranslateBasic> base,
});
_member_units->setModel(_member_model);
connect(_member_model, &QStandardItemModel::itemChanged, this, &ExtractRuleView::dataChanged);
_member_units->setItemDelegateForColumn(2, new UnitSelectDelegate(_basic_bind));
_member_model->setHorizontalHeaderLabels(QStringList() << "FieldName" << "OffsetSpan" << "UnitType");
_member_units->setContextMenuPolicy(Qt::CustomContextMenu);
connect(_member_units, &QTableView::customContextMenuRequested, [=](const QPoint& pt) {
@ -83,12 +88,12 @@ void ExtractRuleView::reload()
auto cnt = _member_model->rowCount();
_member_model->removeRows(0, cnt);
auto list = _rule_base->fieldNames();
auto list = _current_rule->fieldNames();
for (auto key : list) {
auto field_mbr = _rule_base->operator[](key);
auto field_mbr = _current_rule->operator[](key);
QList<QStandardItem*> row;
row << new QStandardItem(field_mbr->name());
row << new QStandardItem(QString("%1").arg(field_mbr->offsetSpan()));
row << new QStandardItem(QString("%1 bytes").arg(field_mbr->offsetSpan()));
row.last()->setEditable(false);
row << new QStandardItem(field_mbr->baseType());
_member_model->appendRow(row);
@ -96,6 +101,7 @@ void ExtractRuleView::reload()
_member_units->resizeColumnsToContents();
}
#include <QMessageBox>
#include <QInputDialog>
void ExtractRuleView::appendUnit()
{
@ -103,21 +109,66 @@ void ExtractRuleView::appendUnit()
if (name_u == "")
return;
auto inst_u = _base_bind->defaultExtractUnitType()->newDefault();
auto new_unit = std::dynamic_pointer_cast<SingleBasedUnit>(inst_u);
if (this->_current_rule->fieldNames().contains(name_u)) {
QMessageBox::critical(this, "DataValidate", "Field can't repeat");
return;
}
auto unit_template = _basic_bind->defaultExtractUnitType()->newDefault();
auto new_unit = std::dynamic_pointer_cast<SingleBasedUnit>(unit_template);
new_unit->setName(name_u);
auto delt_key = _base_bind->delegateAlias().first();
auto delt_o = _base_bind->operator[](delt_key);
auto delt_u = delt_o->newDefault();
auto delt_key = _basic_bind->customDelegateAlias().first();
auto delt_o = _basic_bind->operator[](delt_key);
QJsonObject content;
delt_o->saveTo(content);
delt_u->loadFrom(_base_bind, content);
auto delt_u = delt_o->newDefault();
delt_u->loadFrom(_basic_bind, content);
new_unit->setDelegate(std::dynamic_pointer_cast<ExtractDelegate>(delt_u));
this->_rule_base->append(new_unit);
this->_current_rule->append(new_unit);
reload();
}
void ExtractRuleView::dataChanged(QStandardItem* item)
{
auto current_unit = this->_current_rule->operator[](item->row());
switch (item->column()) {
case 0: {
auto fields_names = this->_current_rule->fieldNames();
if (fields_names.contains(item->text())) {
QMessageBox::critical(this, "DataValidate", "Field can't repeat");
}
else {
current_unit->setName(item->text());
}
reload();
}break;
case 2: {
auto unit_template = this->_basic_bind->extractUnitTypeMap()[item->text()];
auto unit_ins = std::dynamic_pointer_cast<ExtractUnit>(unit_template->newDefault());
unit_ins->setName(current_unit->name());
if (unit_ins->baseType() == SingleBasedUnit::topic()) {
auto single_ins = std::dynamic_pointer_cast<SingleBasedUnit>(unit_ins);
auto delt_name = _basic_bind->customDelegateAlias().first();
auto delt_base = _basic_bind->operator[](delt_name);
QJsonObject object;
delt_base->saveTo(object);
auto delt_conv = std::dynamic_pointer_cast<ExtractDelegate>(delt_base->newDefault());
delt_conv->loadFrom(_basic_bind, object);
single_ins->setDelegate(std::dynamic_pointer_cast<ExtractDelegate>(delt_conv));
}
}break;
default:
break;
}
}
void ExtractRuleView::showEvent(QShowEvent* e)
{
QWidget::showEvent(e);
@ -176,7 +227,7 @@ ListBasedConfiguration::ListBasedConfiguration(
});
connect(_size_layout_select, QOverload<const QString&>::of(&QComboBox::currentTextChanged),
[=](const QString& size_provider_name) {
auto size_o = _bind_core->sizeProviderMap()[size_provider_name];
auto size_o = _bind_core->sizeProviderTypeMap()[size_provider_name];
auto size_ins = std::dynamic_pointer_cast<SizeProvider>(size_o->newDefault());
this->_bind_u->setSizeProvider(size_ins);
@ -237,12 +288,12 @@ void ListBasedConfiguration::currentAccept(std::shared_ptr<ExtractUnit> inst_u,
QSignalBlocker vx(_delegate_select);
this->_bind_u = std::dynamic_pointer_cast<extract::ListBasedUnit>(inst_u);
_delegate_select->clear();
_delegate_select->addItems(_bind_core->delegateAlias());
_delegate_select->addItems(_bind_core->customDelegateAlias());
_delegate_select->setCurrentText(this->_bind_u->delegateInst()->aliasName());
QSignalBlocker vv(_size_layout_select);
this->_size_layout_select->clear();
this->_size_layout_select->addItems(_bind_core->sizeProviderMap().keys());
this->_size_layout_select->addItems(_bind_core->sizeProviderTypeMap().keys());
this->_size_layout_select->setCurrentText(_bind_u->sizeProvider()->name());
if (this->_size_layout_select->currentText() == ConstNumberProvider::topic()) {
_configs_stack->setCurrentIndex(0);
@ -323,7 +374,7 @@ void SingleBasedConfiguration::currentAccept(std::shared_ptr<ExtractUnit> inst_u
QSignalBlocker v(_delegate_changed);
_delegate_changed->clear();
_delegate_changed->addItems(_bind_core->delegateAlias());
_delegate_changed->addItems(_bind_core->customDelegateAlias());
auto conv = std::dynamic_pointer_cast<SingleBasedUnit>(inst_u);
_delegate_changed->setCurrentText(conv->delegateInst()->aliasName());
@ -343,3 +394,32 @@ void UnionBasedConfiguration::currentAccept(std::shared_ptr<ExtractUnit> inst_u,
{
}
UnitSelectDelegate::UnitSelectDelegate(std::shared_ptr<TranslateBasic> ins)
: _kernel(ins)
{
}
QWidget* UnitSelectDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
return new QComboBox(parent);
}
void UnitSelectDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
{
auto combo = dynamic_cast<QComboBox*>(editor);
combo->addItems(_kernel->extractUnitTypeMap().keys());
combo->setCurrentText(index.data(Qt::DisplayRole).toString());
}
void UnitSelectDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
auto combo = dynamic_cast<QComboBox*>(editor);
model->setData(index, combo->currentText(), Qt::EditRole);
}
void UnitSelectDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
editor->setGeometry(option.rect);
}

27
TranslateUI/ExtractRuleView.h
View File

@ -75,26 +75,41 @@ namespace unit_configurations {
};
}
#include <QStyledItemDelegate>
class UnitSelectDelegate : public QStyledItemDelegate {
private:
std::shared_ptr<TranslateBasic> _kernel;
public:
UnitSelectDelegate(std::shared_ptr<TranslateBasic> ins);
virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
virtual void setEditorData(QWidget* editor, const QModelIndex& index) const override;
virtual void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override;
virtual void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
};
class ExtractRuleView : public QWidget
{
private:
std::shared_ptr<TranslateBasic> _basic_bind;
QTableView* const _member_units;
QStandardItemModel* const _member_model;
QStackedWidget* const _configs_stack;
std::shared_ptr<extract::AsRuleSet> _rule_base;
std::shared_ptr<TranslateBasic> _base_bind;
std::shared_ptr<extract::AsRuleSet> _current_rule;
std::shared_ptr<FieldManagerLayer> _current_fields_cache = nullptr;
public:
ExtractRuleView(
std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::AsRuleSet> inst_r,
QWidget* p = nullptr);
ExtractRuleView(std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::AsRuleSet> inst_r, QWidget* p = nullptr);
void reload();
void appendUnit();
void dataChanged(QStandardItem* item);
protected:
void showEvent(QShowEvent* e) override;
};

20
TranslateUI/TranslateBasic.cpp
View File

@ -49,27 +49,27 @@ TranslateBasic::TranslateBasic()
}
std::shared_ptr<ExtractDelegate> TranslateBasic::defaultExtractDelegateType() const
std::shared_ptr<ExtractDelegate> TranslateBasic::defaultExtractImplType() const
{
return _default_translate_rule;
}
QHash<QString, std::shared_ptr<ExtractDelegate>> TranslateBasic::extractDelegateTypeMap() const
QHash<QString, std::shared_ptr<ExtractDelegate>> TranslateBasic::extractImplTypeMap() const
{
return _basic_extractor_types;
}
std::shared_ptr<SizeProvider> TranslateBasic::defaultSizeProvider() const
std::shared_ptr<SizeProvider> TranslateBasic::defaultSizeProviderType() const
{
return _default_size_provider;
}
std::shared_ptr<RuleMatch> TranslateBasic::defaultRuleMatch() const
std::shared_ptr<RuleMatch> TranslateBasic::defaultRuleMatchType() const
{
return _default_rule_match;
}
void TranslateBasic::addDelegate(std::shared_ptr<ExtractDelegate> inst)
void TranslateBasic::addCustomDelegate(std::shared_ptr<ExtractDelegate> inst)
{
auto repeat_name_count = std::count_if(
this->_custom_rule_types.begin(), this->_custom_rule_types.end(),
@ -91,7 +91,7 @@ void TranslateBasic::addDelegate(std::shared_ptr<ExtractDelegate> inst)
this->_custom_rule_types << inst;
}
void TranslateBasic::removeDelegate(const QString& typeAlias)
void TranslateBasic::removeCustomDelegate(const QString& typeAlias)
{
for (auto idxp = 0; idxp< this->_custom_rule_types.size(); idxp++) {
auto rule = this->_custom_rule_types.at(idxp);
@ -104,7 +104,7 @@ void TranslateBasic::removeDelegate(const QString& typeAlias)
throw new BaseException("指定RuleName不合法");
}
QList<QString> TranslateBasic::delegateAlias() const
QList<QString> TranslateBasic::customDelegateAlias() const
{
QList<QString> values;
std::transform(_custom_rule_types.begin(), _custom_rule_types.end(),
@ -123,7 +123,7 @@ std::shared_ptr<ExtractDelegate> TranslateBasic::operator[](const QString& name)
throw new BaseException(u8"指定Name不存在");
}
void TranslateBasic::replaceDelegate(const QString& name, std::shared_ptr<ExtractDelegate> inst)
void TranslateBasic::replaceCustomDelegate(const QString& name, std::shared_ptr<ExtractDelegate> inst)
{
for (auto idx = 0; _custom_rule_types.size(); ++idx) {
auto rule_inst = _custom_rule_types.at(idx);
@ -136,12 +136,12 @@ void TranslateBasic::replaceDelegate(const QString& name, std::shared_ptr<Extrac
throw new BaseException(u8"指定Name不存在");
}
QHash<QString, std::shared_ptr<SizeProvider>> TranslateBasic::sizeProviderMap() const
QHash<QString, std::shared_ptr<SizeProvider>> TranslateBasic::sizeProviderTypeMap() const
{
return _size_provider_types;
}
QHash<QString, std::shared_ptr<RuleMatch>> TranslateBasic::ruleMatchMap() const
QHash<QString, std::shared_ptr<RuleMatch>> TranslateBasic::ruleMatchTypeMap() const
{
return _rule_match_types;
}

20
TranslateUI/TranslateBasic.h
View File

@ -130,19 +130,19 @@ private:
public:
TranslateBasic();
std::shared_ptr<ExtractDelegate> defaultExtractDelegateType() const;
QHash<QString, std::shared_ptr<ExtractDelegate>> extractDelegateTypeMap() const;
std::shared_ptr<SizeProvider> defaultSizeProvider() const;
QHash<QString, std::shared_ptr<SizeProvider>> sizeProviderMap() const;
std::shared_ptr<RuleMatch> defaultRuleMatch() const;
QHash<QString, std::shared_ptr<RuleMatch>> ruleMatchMap() const;
std::shared_ptr<ExtractDelegate> defaultExtractImplType() const;
QHash<QString, std::shared_ptr<ExtractDelegate>> extractImplTypeMap() const;
std::shared_ptr<SizeProvider> defaultSizeProviderType() const;
QHash<QString, std::shared_ptr<SizeProvider>> sizeProviderTypeMap() const;
std::shared_ptr<RuleMatch> defaultRuleMatchType() const;
QHash<QString, std::shared_ptr<RuleMatch>> ruleMatchTypeMap() const;
std::shared_ptr<ExtractUnit> defaultExtractUnitType() const;
QHash<QString, std::shared_ptr<ExtractUnit>> extractUnitTypeMap() const;
void addDelegate(std::shared_ptr<ExtractDelegate> inst);
void removeDelegate(const QString& alias);
void replaceDelegate(const QString &name, std::shared_ptr<ExtractDelegate> inst);
QList<QString> delegateAlias() const;
void addCustomDelegate(std::shared_ptr<ExtractDelegate> inst);
void removeCustomDelegate(const QString& alias);
void replaceCustomDelegate(const QString &name, std::shared_ptr<ExtractDelegate> inst);
QList<QString> customDelegateAlias() const;
std::shared_ptr<ExtractDelegate> operator[](const QString &name) const;
};

24
TranslateUI/WrapConfigs.cpp
View File

@ -53,7 +53,7 @@ WrapConfigs::WrapConfigs(std::shared_ptr<TranslateBasic> _base, QWidget* p)
if (!idx.isValid())
return;
auto alias_key = _bind_base->delegateAlias()[idx.row()];
auto alias_key = _bind_base->customDelegateAlias()[idx.row()];
auto delt_inst = _bind_base->operator[](alias_key);
switch (delt_inst->outType()) {
case DataType::Flt32:
@ -89,7 +89,7 @@ void WrapConfigs::aliasReload()
auto row_cnt = _alias_model->rowCount();
_alias_model->removeRows(0, row_cnt);
auto alias_keys = _bind_base->delegateAlias();
auto alias_keys = _bind_base->customDelegateAlias();
for (auto key_nm : alias_keys) {
QList<QStandardItem*> row;
@ -125,15 +125,15 @@ void WrapConfigs::aliasAppend()
if (name == "")
return;
auto exists = _bind_base->delegateAlias();
auto exists = _bind_base->customDelegateAlias();
while (exists.contains(name))
name += "#";
auto ins = _bind_base->defaultExtractDelegateType()->newDefault();
auto ins = _bind_base->defaultExtractImplType()->newDefault();
auto nins = std::dynamic_pointer_cast<ExtractDelegate>(ins);
nins->setAlias(name);
_bind_base->addDelegate(nins);
_bind_base->addCustomDelegate(nins);
aliasReload();
}
@ -143,8 +143,8 @@ void WrapConfigs::aliasRemove()
if (!index.isValid())
return;
auto origin_key = _bind_base->delegateAlias()[index.row()];
_bind_base->removeDelegate(origin_key);
auto origin_key = _bind_base->customDelegateAlias()[index.row()];
_bind_base->removeCustomDelegate(origin_key);
aliasReload();
}
@ -154,7 +154,7 @@ void WrapConfigs::dataChanged(QStandardItem* cell)
switch (cell->column()) {
case 0: { // ÐÞ¸Äalias-name
auto cell_name = cell->text();
auto total_alias_set = _bind_base->delegateAlias();
auto total_alias_set = _bind_base->customDelegateAlias();
auto origin_key = total_alias_set.at(cell->row());
auto appoint_unit = _bind_base->operator[](origin_key);
@ -169,14 +169,14 @@ void WrapConfigs::dataChanged(QStandardItem* cell)
appoint_unit->setAlias(cell_name);
}break;
case 1: { // ÐÞ¸Äalias»ù´¡ÀàÐÍ
auto total_alias_set = _bind_base->delegateAlias();
auto total_alias_set = _bind_base->customDelegateAlias();
auto origin_key = total_alias_set.at(cell->row());
auto new_type = cell->text();
auto new_ins = _bind_base->extractDelegateTypeMap()[new_type]->newDefault();
auto new_ins = _bind_base->extractImplTypeMap()[new_type]->newDefault();
auto new_delegate = std::dynamic_pointer_cast<ExtractDelegate>(new_ins);
new_delegate->setAlias(origin_key);
_bind_base->replaceDelegate(origin_key, new_delegate);
_bind_base->replaceCustomDelegate(origin_key, new_delegate);
}break;
default:
break;
@ -197,7 +197,7 @@ QWidget* RuleSelectDelegate::createEditor(QWidget* parent, const QStyleOptionVie
void RuleSelectDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
{
auto rule_names = this->_kernel->extractDelegateTypeMap().keys();
auto rule_names = this->_kernel->extractImplTypeMap().keys();
std::sort(rule_names.begin(), rule_names.end());
auto combo = dynamic_cast<QComboBox*>(editor);

1
TranslateUI/WrapConfigs.h
View File

@ -12,7 +12,6 @@
/// 翻译规则编辑代理
/// </summary>
class RuleSelectDelegate : public QStyledItemDelegate {
Q_OBJECT
private:
std::shared_ptr<TranslateBasic> _kernel;

4
TranslateUI/extract_basic.cpp
View File

@ -643,7 +643,7 @@ void ListBasedUnit::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonOb
OBJECT_PEAK(provider_obj, obj);
OBJECT_PEAK(delegate_obj, obj);
auto ins_size = core->sizeProviderMap()[provider_name]->newDefault();
auto ins_size = core->sizeProviderTypeMap()[provider_name]->newDefault();
ins_size->loadFrom(core, provider_obj);
auto ins_delt = core->operator[](delegate_name)->newDefault();
ins_delt->loadFrom(core, delegate_obj);
@ -771,7 +771,7 @@ void UnionBasedUnit::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonO
QString match_type;
STRING_PEAK(match_type, rule_obj);
auto ninst = core->ruleMatchMap()[match_type]->newDefault();
auto ninst = core->ruleMatchTypeMap()[match_type]->newDefault();
QJsonObject content_obj;
OBJECT_PEAK(content_obj, rule_obj);
ninst->loadFrom(core, content_obj);