添加了CustomRule管理机制

TranslateUI/TranslateBasic.cpp

@@ -66,19 +66,38 @@ QHash<QString, std::shared_ptr<ExtractUnit>> TranslateBasic::extractUnitList() c
 	return _extractor_types;
 }
 
-void TranslateBasic::setCustomRule(const QString& name, std::shared_ptr<ExtractUnit> inst)
+void TranslateBasic::setCustomRule(const QString& name, std::shared_ptr<extract::BytesAsRuleSet> inst)
 {
-	this->_extractor_types[name] = inst;
+	auto exist = std::count_if(
+		this->_custom_rule_types.begin(), this->_custom_rule_types.end(),
+		[=](std::shared_ptr<extract::BytesAsRuleSet> v) {
+			return v->name() == name;
+		});
+	assert("RuleName²»ÄÜÖظ´" && !exist);
+
+	inst->setCustomName(name);
+	this->_custom_rule_types << inst;
 }
 
 void TranslateBasic::removeCustomRule(const QString& name)
 {
-	_extractor_types.remove(name);
+	for (auto idxp = 0; idxp< this->_custom_rule_types.size(); idxp++) {
+		auto rule = this->_custom_rule_types.at(idxp);
+		if (rule->customName() == name) {
+			this->_custom_rule_types.removeAt(idxp--);
+			return;
+		}
+	}
+
+	assert("Ö¸¶¨RuleName²»ºÏ·¨" && 0);
 }
 
-QHash<QString, std::shared_ptr<RuleMatch>> TranslateBasic::customRules() const
+QHash<QString, std::shared_ptr<extract::BytesAsRuleSet>> TranslateBasic::customRules() const
 {
-	return this->_custom_rule_types;
+	QHash<QString, std::shared_ptr<extract::BytesAsRuleSet>> value_set;
+	for (auto instv : this->_custom_rule_types)
+		value_set[instv->customName()] = instv;
+	return value_set;
 }
 
 QHash<QString, std::shared_ptr<SizeProvider>> TranslateBasic::sizeProviderList() const
@@ -223,7 +242,7 @@ bool FieldManagerLayer::bindCurrent(const QString& unique_key)
 QHash<QString, DataType> FieldManagerLayer::prevFields() const
 {
 	QHash<QString, DataType> fields;
-	for(auto pair : __Private::_fields_map)
+	for (auto pair : __Private::_fields_map)
 		fields[pair.first] = pair.second;
 
 	return fields;

TranslateUI/TranslateBasic.h

@@ -3,6 +3,7 @@
 #include "extract_basic.h"
 #include "convert_basic.h"
 #include <QVariant>
+#include <QList>
 
 /// <summary>
 /// 范围字段获取上下文
@@ -112,7 +113,7 @@ private:
 	QHash<QString, std::shared_ptr<RuleMatch>> _rule_match_types;
 	std::shared_ptr<RuleMatch> _default_rule_match = nullptr;
 
-	QHash<QString, std::shared_ptr<RuleMatch>> _custom_rule_types;
+	QList<std::shared_ptr<extract::BytesAsRuleSet>> _custom_rule_types;
 
 public:
 	TranslateBasic();
@@ -125,9 +126,9 @@ public:
 	std::shared_ptr<ExtractUnit> defaultExtractUnit() const;
 	QHash<QString, std::shared_ptr<ExtractUnit>> extractUnitList() const;
 
-	void setCustomRule(const QString& name, std::shared_ptr<ExtractUnit> inst);
+	void setCustomRule(const QString& name, std::shared_ptr<extract::BytesAsRuleSet> inst);
 	void removeCustomRule(const QString& name);
-	QHash<QString, std::shared_ptr<RuleMatch>> customRules() const;
+	QHash<QString, std::shared_ptr<extract::BytesAsRuleSet>> customRules() const;
 };
 
 /// <summary>

TranslateUI/TranslateUI.cpp

@@ -1,10 +1,145 @@
 #include "TranslateUI.h"
+#include <QSplitter>
+#include <QTreeView>
+#include <QTabWidget>
+#include <QMenu>
+#include <QInputDialog>
 
-TranslateUI::TranslateUI(QWidget *parent)
-    : QMainWindow(parent)
+TranslateUI::TranslateUI(QWidget* parent)
+	: QMainWindow(parent),
+	_tab_widget(new QTabWidget(this)),
+	_ruleset_navi(new QTreeView(this)),
+	_solution_model(new QStandardItemModel(this))
 {
+	_core._translate_core = std::make_shared<TranslateBasic>();
+	_core._view_mgr = new ViewManager(_core._translate_core, this);
+
+
+
+	auto splitter = new QSplitter(Qt::Horizontal, this);
+	this->setCentralWidget(splitter);
+	splitter->addWidget(_ruleset_navi);
+	_ruleset_navi->setModel(_solution_model);
+	_ruleset_navi->setHeaderHidden(true);
+	_ruleset_navi->setContextMenuPolicy(Qt::CustomContextMenu);
+	connect(_ruleset_navi, &QWidget::customContextMenuRequested, [=](const QPoint& pos) {
+		QMenu m;
+		m.addAction(u8"添加Rule", this, &TranslateUI::addCustomRule);
+		m.addAction(u8"打开ExtractView", this, &TranslateUI::openExtractView);
+		m.exec(this->mapToGlobal(pos));
+		});
+
+
+
+
+	splitter->addWidget(_tab_widget);
+	_tab_widget->setTabsClosable(true);
+	connect(_tab_widget, &QTabWidget::tabCloseRequested, _core._view_mgr, &ViewManager::closeAt);
+	connect(_core._view_mgr, &ViewManager::appendRequest, _tab_widget, QOverload<QWidget*, const QString&>::of(&QTabWidget::addTab));
+	connect(_core._view_mgr, &ViewManager::removeRequest, _tab_widget, &QTabWidget::removeTab);
+	connect(_core._view_mgr, &ViewManager::activeRequest, _tab_widget, &QTabWidget::setTabText);
+
+	this->present_solution_customs(_core._translate_core, _solution_model);
 }
 
 TranslateUI::~TranslateUI()
-{}
+{
+}
 
+#include <QMessageBox>
+void TranslateUI::addCustomRule()
+{
+	auto name = QInputDialog::getText(this, u8"输入Rule名称", "Rule:");
+	if (name == "")
+		return;
+
+	auto names = this->_core._translate_core->customRules().keys();
+	if (names.contains(name)) {
+		QMessageBox::critical(this, "输入校验", "RuleName不能重复");
+		return;
+	}
+
+	auto new_rule = std::make_shared<extract::BytesAsRuleSet>();
+	new_rule->setCustomName(name);
+	_core._translate_core->setCustomRule(name, new_rule);
+
+	this->present_solution_customs(_core._translate_core, _solution_model);
+}
+
+void TranslateUI::openExtractView()
+{
+	auto index = this->_ruleset_navi->currentIndex();
+	if (!index.isValid())
+		return;
+
+	auto name = this->_solution_model->data(index, Qt::DisplayRole).toString();
+	this->_core._view_mgr->open(name, ViewType::ExtractConfiguration, this);
+}
+
+void TranslateUI::present_solution_customs(std::shared_ptr<TranslateBasic> ins, QStandardItemModel* model) const
+{
+	model->removeRows(0, model->rowCount());
+
+	auto ruleset = ins->customRules();
+	for (auto rule_name : ruleset.keys()) {
+		model->appendRow(new QStandardItem(rule_name));
+	}
+}
+
+#include "StructuralRuleView.h"
+
+ViewManager::ViewManager(std::shared_ptr<TranslateBasic> base, QObject* p /*= nullptr*/)
+	:QObject(p), _translate_core(base)
+{
+
+}
+
+void ViewManager::open(const QString& rule_name, ViewType v_type, QWidget* p)
+{
+	for (auto vidx = 0; vidx < content_pages.size(); vidx++) {
+		auto v = content_pages.at(vidx);
+		if (std::get<0>(v)->name() == rule_name && std::get<2>(v) == v_type) {
+			emit this->activeRequest(vidx, rule_name);
+			return;
+		}
+	}
+	assert("指定rule_name必须合法" && _translate_core->customRules().contains(rule_name));
+
+	auto appoint = _translate_core->customRules()[rule_name];
+	auto present = new StructuralRuleView(appoint, p);
+	content_pages << std::make_tuple(appoint, present, v_type);
+	emit this->appendRequest(present, rule_name);
+}
+
+void ViewManager::closeAt(int index)
+{
+	assert("index必须有效" && (index < content_pages.size()));
+	emit this->removeRequest(index);
+
+	auto current = this->content_pages.at(index);
+	std::get<1>(current)->deleteLater();
+	content_pages.removeAt(index);
+}
+
+void ViewManager::active(const QString& rule_name, ViewType v_type)
+{
+	for (auto vidx = 0; vidx < content_pages.size(); vidx++) {
+		auto v = content_pages.at(vidx);
+		if (std::get<0>(v)->name() == rule_name && std::get<2>(v) == v_type) {
+			emit this->activeRequest(vidx, rule_name);
+			return;
+		}
+	}
+
+	assert("RuleName和V_Type组合必须有效" && 0);
+}
+
+void ViewManager::purge(const QString& rule_name)
+{
+	for (auto vidx = 0; vidx < content_pages.size(); vidx++) {
+		auto v = content_pages.at(vidx);
+		if (std::get<0>(v)->name() == rule_name) {
+			this->closeAt(vidx--);
+		}
+	}
+}

TranslateUI/TranslateUI.h

@@ -1,15 +1,68 @@
 #pragma once
 
 #include <QtWidgets/QMainWindow>
+#include <QStandardItemModel>
+#include "TranslateBasic.h"
 
-class TranslateUI : public QMainWindow
-{
-    Q_OBJECT
+enum class ViewType {
+	/// <summary>
+	/// ÌáÈ¡ÅäÖÃ
+	/// </summary>
+	ExtractConfiguration,
+	/// <summary>
+	/// УÑéÅäÖÃ
+	/// </summary>
+	ValidateConfiguration,
+};
+class ViewManager : public QObject {
+	Q_OBJECT
+private:
+	std::shared_ptr<TranslateBasic> _translate_core = nullptr;
+	QList<std::tuple<std::shared_ptr<extract::BytesAsRuleSet>, QWidget*, ViewType>> content_pages;
 
 public:
-    TranslateUI(QWidget *parent = nullptr);
-    ~TranslateUI();
+	ViewManager(std::shared_ptr<TranslateBasic> base, QObject* p = nullptr);
+
+public slots:
+	void open(const QString& rule_name, ViewType v_type, QWidget* p = nullptr);
+	void closeAt(int index);
+	void active(const QString& rule_name, ViewType v_type);
+	void purge(const QString& rule_name);
+
+
+signals:
+	void appendRequest(QWidget* view, const QString& title);
+	void removeRequest(int index);
+	void activeRequest(int index, const QString& new_title);
 
-private:
+};
+
+#include <QTreeView>
+class TranslateUI : public QMainWindow
+{
+	Q_OBJECT
+private:
+	QTabWidget *const _tab_widget;
+	QTreeView* const _ruleset_navi;
+	QStandardItemModel* _solution_model = nullptr;
+
+public:
+	struct __Private {
+		std::shared_ptr<TranslateBasic> _translate_core = nullptr;
+
+		ViewManager* _view_mgr = nullptr;
+	} _core;
+
+public:
+	TranslateUI(QWidget* parent = nullptr);
+	~TranslateUI();
+
+	void addCustomRule();
+	void openExtractView();
+
+	void removeCustomRule(const QString &name);
+
+	void present_solution_customs(
+		std::shared_ptr<TranslateBasic> ins, QStandardItemModel* model) const;
 };
 

TranslateUI/extract_basic.cpp

@@ -697,3 +697,13 @@ std::shared_ptr<ExtractUnit> BytesAsRuleSet::__Private::operator[](const QString
 
 	return std::shared_ptr<ExtractUnit>();
 }
+
+void BytesAsRuleSet::setCustomName(const QString& name)
+{
+	_rules._name_store = name;
+}
+
+QString BytesAsRuleSet::customName() const
+{
+	return _rules._name_store;
+}

TranslateUI/extract_basic.h

@@ -255,6 +255,7 @@ namespace extract {
 	public:
 		struct __Private {
 			int _byte_offset = 0, _byte_count = 1;
+			QString _name_store;
 			QList<std::pair<QString, std::shared_ptr<ExtractUnit>>> _sub_rules;
 
 			QList<QString> fieldNames() const;
@@ -267,6 +268,9 @@ namespace extract {
 			__Private& append(const QString& nm, std::shared_ptr<ExtractUnit> u);
 		}_rules;
 
+		void setCustomName(const QString& name);
+		QString customName() const;
+
 	public:
 		QString name() const override;
 		void registSubField(std::shared_ptr<ScopeFieldsSetter> inst) override;
@@ -276,7 +280,6 @@ namespace extract {
 		int countWithin() const override;
 		std::shared_ptr<Serializable> newDefault() const override;
 
-
 		void parse(const QByteArray& bytes, std::shared_ptr<DataAccessContext> out) const override;
 
 		void loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonObject& obj) override;

TranslateUI/main.cpp

@@ -10,8 +10,7 @@ int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
 
-    auto vx = std::make_shared< extract::BytesAsRuleSet>();
-    StructuralRuleView v(vx);
+    TranslateUI v;
     v.show();
 
     return app.exec();