ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj

@@ -202,7 +202,6 @@
     <QtMoc Include="src\Editor\EditorWidgetComponent\ColorPicker.h" />
     <QtMoc Include="src\Editor\RightBar\EditorSettingWidget.h" />
     <QtMoc Include="src\Editor\EditorWidgetComponent\FillStyleWidget.h" />
-    <ClInclude Include="src\ColorHelper.hpp" />
     <ClInclude Include="src\Editor\LayerWrapper.h" />
     <ClInclude Include="src\Editor\util\EncodeUtil.hpp" />
     <ClInclude Include="src\Editor\util\JsonUtil.hpp" />

ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters

@@ -519,9 +519,6 @@
     <ClInclude Include="src\Editor\LayerWrapper.h">
       <Filter>Header Files\Editor\Layer</Filter>
     </ClInclude>
-    <ClInclude Include="src\ColorHelper.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <QtRcc Include="res\MainWindow.qrc">

ArchitectureColoredPainting/src/ColorHelper.hpp

@@ -1,49 +0,0 @@
-#pragma once
-#include <lib/qtmaterialstyle.h>
-#include <lib/qtmaterialtheme.h>
-#include <QColorDialog>
-
-class ColorHelper
-{
-	QtMaterialTheme theme;
-	QColor primary1;
-public:
-
-	void setPrimary1(const QColor& color)
-	{
-		theme.setColor("primary1", color);
-		primary1 = color;
-	}
-
-	[[nodiscard]] QColor getPrimary1() const
-	{
-		return primary1;
-	}
-
-	ColorHelper()
-	{
-		setPrimary1(QColor::fromRgb(0, 90, 158));
-		QtMaterialStyle::instance().setTheme(&theme);
-	}
-
-	static ColorHelper& instance()
-	{
-		static ColorHelper instance;
-		return instance;
-	}
-
-	static QColor execColorDialog(
-		const QColor& initial = instance().getPrimary1(), 
-		QWidget* parent = nullptr, 
-		const QString& title = ""
-	) {
-		auto dialog = QColorDialog(initial, parent);
-		if (!title.isEmpty())
-		{
-			dialog.setWindowTitle(title);
-		}
-		dialog.adjustSize();
-		dialog.exec();
-		return dialog.selectedColor();
-	}
-};

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/ColorPicker.cpp

@@ -1,6 +1,5 @@
 #include "ColorPicker.h"
 #include <QColorDialog>
-#include <QDebug>
 
 QString getStyleSheet(const QColor& color)
 {
@@ -27,8 +26,9 @@ QColor ColorPicker::getColor() const
 
 void ColorPicker::onClicked()
 {
-	//const QColor newColor = QColorDialog::getColor(this->color, this);
+	QColorDialog dialog(this->color, this);
-	const QColor newColor = ColorHelper::execColorDialog(this->color, this);
+	dialog.exec();
+	QColor newColor = dialog.selectedColor();
 	if (newColor.isValid() && this->color != newColor)
 	{
 		this->color = newColor;

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/ColorPicker.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "../ColorHelper.hpp"
 #include <QPushButton>
 class ColorPicker : public QPushButton
 {
@@ -7,7 +6,7 @@ class ColorPicker : public QPushButton
 private:
 	QColor color;
 public:
-	ColorPicker(const QColor& color = ColorHelper::instance().getPrimary1(), QWidget* parent = nullptr);
+	ColorPicker(const QColor& color = QColor::fromRgb(0, 0, 0), QWidget* parent = nullptr);
 	QColor getColor() const;
 public slots:
 	void onClicked();

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/FillStyleWidget.cpp

@@ -4,7 +4,7 @@
 #include <QLabel>
 #include <qtmaterialtextfield.h>
 
-FillStyleWidget::FillStyleWidget(std::shared_ptr<MaterialStyleFill> fill, QWidget* parent)
+FillStyleWidget::FillStyleWidget(std::shared_ptr<Renderer::MaterialStyleFill> fill, QWidget* parent)
 : QWidget(parent), fill(fill)
 {
     auto* layout = new QGridLayout(this);

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/LayerStyleDialog.cpp

@@ -1,25 +1,28 @@
 #include "LayerStyleDialog.h"
 #include <QComboBox>
 #include <QDialogButtonBox>
+#include <QHBoxLayout>
 #include <QGridLayout>
 
 LayerStyleDialog::LayerStyleDialog(
 	LayerStyleContainer& styles, 
-	const std::shared_ptr<LayerStyle>& existedStyle, 
+	std::shared_ptr<LayerStyle> existedStyle, 
 	QWidget* parent
 ) : QDialog(parent), styles(&styles)
 {
-	dialogLayout = new QGridLayout;
+	auto* dialogLayout = new QVBoxLayout(this);
 	dialogLayout->setAlignment(Qt::AlignmentFlag::AlignHCenter);
 	this->setLayout(dialogLayout);
 
 	if (existedStyle)
 	{
 		this->modifyingStyle = existedStyle->clone();
-		
+
+		this->styleContainer = nullptr;
 		this->styleWidget = modifyingStyle->getInputWidget();
 		this->styleWidget->setParent(this);
-		dialogLayout->addWidget(styleWidget, 1, 0);
+		dialogLayout->addWidget(styleWidget);
+		// do something
 	}
 	else
 	{
@@ -31,12 +34,13 @@ LayerStyleDialog::LayerStyleDialog(
 			typeSelector->addItems(unusedStyleNames);
 			this->modifyingStyle = std::move(styles.makeUnusedStyle(unusedStyleNames[0]));
 
-			dialogLayout->addWidget(typeSelector, 0, 0);
+			dialogLayout->addWidget(typeSelector);
-
+			this->styleContainer = new QGridLayout(this);
+			dialogLayout->addLayout(styleContainer);
 
 			this->styleWidget = this->modifyingStyle->getInputWidget();
 			this->styleWidget->setParent(this);
-			this->dialogLayout->addWidget(styleWidget, 1, 0);
+			this->styleContainer->addWidget(styleWidget);
 			connect(typeSelector, &QComboBox::currentTextChanged,
 				this, &LayerStyleDialog::onStyleTypeSelectorChanged);
 		}
@@ -44,8 +48,7 @@ LayerStyleDialog::LayerStyleDialog(
 	auto* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
 	connect(buttonBox, &QDialogButtonBox::accepted, this, &LayerStyleDialog::accept);
 	connect(buttonBox, &QDialogButtonBox::rejected, this, &LayerStyleDialog::reject);
-	dialogLayout->addWidget(buttonBox, 2, 0);
+	dialogLayout->addWidget(buttonBox);
-	this->adjustSize();
 }
 
 void LayerStyleDialog::accept()
@@ -58,14 +61,14 @@ void LayerStyleDialog::onStyleTypeSelectorChanged(const QString& current)
 {
 	if (this->styleWidget)
 	{
-		this->dialogLayout->removeWidget(this->styleWidget);
+		this->styleContainer->removeWidget(this->styleWidget);
 		this->styleWidget->setParent(nullptr);
 		delete styleWidget;
 	}
 	this->modifyingStyle = std::move(styles->makeUnusedStyle(current));
 	this->styleWidget = this->modifyingStyle->getInputWidget();
 	this->styleWidget->setParent(this);
-	this->dialogLayout->addWidget(styleWidget, 1, 0);
+	this->styleContainer->addWidget(styleWidget, 0, 0, 1, 1);
 	this->styleWidget->adjustSize();
 	this->adjustSize();
 }

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/LayerStyleDialog.h

@@ -8,13 +8,13 @@ class LayerStyleDialog : public QDialog
 	Q_OBJECT
 private:
 	QWidget* styleWidget;
-	QGridLayout* dialogLayout;
+	QGridLayout* styleContainer;
 	LayerStyleContainer* styles;
 	std::unique_ptr<LayerStyle> modifyingStyle;
 public:
 	LayerStyleDialog(
 		LayerStyleContainer& styles,
-		const std::shared_ptr<LayerStyle>& existedStyle = nullptr,
+		std::shared_ptr<LayerStyle> existedStyle = nullptr,
 		QWidget* parent = nullptr
 	);
 	std::shared_ptr<LayerStyle> layerStyle;

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/StrokeStyleWidget.cpp

@@ -1,8 +1,8 @@
 #include "StrokeStyleWidget.h"
 #include "ColorPicker.h"
-#include "../ColorHelper.hpp"
 #include <qtmaterialraisedbutton.h>
 #include <limits>
+#include <lib/qtmaterialstyle.h>
 
 constexpr int COLUMN_WIDTH = 0;
 constexpr int COLUMN_COLOR = 1;
@@ -105,8 +105,8 @@ void StrokeStyleWidget::initTable(std::shared_ptr<Renderer::StrokeRadialGradient
 		row++;
 	}
 	// ÐÂÔö°´Å¥
-	auto* addButton = new QtMaterialRaisedButton("+", strokeTable);
+	QtMaterialRaisedButton* addButton = new QtMaterialRaisedButton("+", strokeTable);
-	addButton->setBackgroundColor(ColorHelper::instance().getPrimary1());
+	addButton->setBackgroundColor(QtMaterialStyle::instance().themeColor("primary1"));
 	strokeTable->setSpan(row, 0, 1, 5);
 	strokeTable->setCellWidget(row, 0, addButton);
 	strokeTable->setMinimumHeight(strokeTable->rowHeight(row) * 5);
@@ -114,18 +114,18 @@ void StrokeStyleWidget::initTable(std::shared_ptr<Renderer::StrokeRadialGradient
 	addButton->setFixedHeight(strokeTable->rowHeight(row));
 	connect(addButton, &QtMaterialRaisedButton::clicked, [this]() {
 		handlingRowInsert = true;
-		auto materialMap = &radialStroke(this->stroke)->materialMap;
+		auto materialMap = &(radialStroke(this->stroke)->materialMap);
-		float newWidth;
+		float newWidth = 0;
-		if (materialMap->empty())
+		if (materialMap->size() == 0)
 		{
 			newWidth = 0.1;
 		}
 		else
 		{
-			const auto lastPair = materialMap->rbegin();
+			auto lastPair = materialMap->rbegin();
 			newWidth = lastPair->first + 0.01;
 		}
-		const Renderer::Material newMaterial(ColorHelper::instance().getPrimary1());
+		Renderer::Material newMaterial(QColor::fromRgb(0, 0, 0));
 		(*materialMap)[newWidth] = newMaterial;
 		int newRow = this->strokeTable->rowCount() - 1;
 		this->strokeTable->insertRow(newRow);
@@ -143,7 +143,7 @@ void StrokeStyleWidget::setTableRow(int row, float width, Renderer::Material& ma
 	widthItem->setData(Qt::EditRole, width);
 	strokeTable->setItem(row, COLUMN_WIDTH, widthItem);
 
-	QColor* colorPtr = &material.color;
+	QColor* colorPtr = &(material.color);
 	auto* colorItem = new QTableWidgetItem;
 	colorItem->setData(Qt::DisplayRole, *colorPtr);
 	strokeTable->setItem(row, COLUMN_COLOR, colorItem);
@@ -163,7 +163,7 @@ void StrokeStyleWidget::setTableRow(int row, float width, Renderer::Material& ma
 	strokeTable->setItem(row, COLUMN_ROUGHNESS, roughnessItem);
 
 	auto* removeButton = new QtMaterialRaisedButton("-", strokeTable);
-	removeButton->setBackgroundColor(ColorHelper::instance().getPrimary1());
+	removeButton->setBackgroundColor(QtMaterialStyle::instance().themeColor("primary1"));
 	removeButton->setFixedSize(20, 20);
 	strokeTable->setCellWidget(row, COLUMN_OPERATIONS, removeButton);
 	connect(removeButton, &QtMaterialRaisedButton::clicked, [this, row]() {

ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/StrokeStyleWidget.h

@@ -23,8 +23,8 @@ private:
 	void setTableRow(int row, float width, Renderer::Material& material);
 
 public:
-	StrokeStyleWidget(std::shared_ptr<MaterialStyleStroke> stroke, QWidget* parent = nullptr);
+	StrokeStyleWidget(std::shared_ptr<Renderer::MaterialStyleStroke> stroke, QWidget* parent = nullptr);
-	std::shared_ptr<MaterialStyleStroke> stroke;
+	std::shared_ptr<Renderer::MaterialStyleStroke> stroke;
 
 protected slots:
 	void onCurrentItemChanged(QTableWidgetItem* current, QTableWidgetItem* previous);

ArchitectureColoredPainting/src/Editor/EditorWidgetItem.cpp

@@ -19,15 +19,6 @@ EditorWidgetItem::EditorWidgetItem(QString filePath,QWidget *parent) : QWidget(p
     elementInfoDisplayWidget->enableEdit();
     qDebug() << layerInfoDisplayWidget;
     qDebug() << elementInfoDisplayWidget;
-    auto centralRefresh = [this]() {
-        layerInfoDisplayWidget->refresh();
-		elementInfoDisplayWidget->refresh();
-        treeWidget->refresh();
-		previewWindow->refresh();
-    };
-	connect(layerInfoDisplayWidget, &InfoDisplayWidget::triggerCentralRefresh, centralRefresh);
-	connect(elementInfoDisplayWidget, &ElementPoolWidget::triggerCentralRefresh, centralRefresh);
-	connect(treeWidget, &LayerTreeWidget::triggerCentralRefresh, centralRefresh);
 	connect(editorSettingWidget, &EditorSettingWidget::backgroundColorChanged, this, &EditorWidgetItem::handleBackgroundColorChange);
 	connect(editorSettingWidget, &EditorSettingWidget::projectNameChanged, this, &EditorWidgetItem::handleProjectNameChange);
     connect(previewWindow, &PreviewWindow::refreshElementPreviewByIndex, elementInfoDisplayWidget, &ElementPoolWidget::refreshPictureByIndex);

ArchitectureColoredPainting/src/Editor/ElementPoolWidget.cpp

@@ -67,6 +67,7 @@ void ElementPoolWidget::setElementManager(ElementManager* element)
 
 void ElementPoolWidget::refresh() {
 	this->setElementList(this->elementManager->elements);
+	emit refreshLayerTree();
 	// update();
 }
 
@@ -112,14 +113,13 @@ void ElementPoolWidget::popMenu(const QPoint& pos)
 				if (bOk && !sName.isEmpty())
 				{
 					currentElement->name = sName;
-					emit triggerCentralRefresh();
+					refresh();
 				}
 			});
 		menu->addAction(QString::fromLocal8Bit("ɾ³ý"), this, [this, currentElement]() {
 				this->elementManager->removeElement(currentElement);
-				emit triggerCentralRefresh();
+				refresh();
 			});
-		menu->actions().last()->setDisabled(currentElement->referencedCount > 0);
 	}
 	else
 	{
@@ -129,7 +129,7 @@ void ElementPoolWidget::popMenu(const QPoint& pos)
 				QString fileName = fileInfo.fileName();
 				qDebug() << fileName << " " << filePath;
 				this->elementManager->createSimpleElement(fileName, filePath);
-				emit triggerCentralRefresh();
+				refresh();
 			});
 	}
 	menu->popup(mapToGlobal(pos));

ArchitectureColoredPainting/src/Editor/ElementPoolWidget.h

@@ -26,7 +26,6 @@ public:
 signals:
 	void elementSelected(GraphicElement* element);
 	void refreshLayerTree();
-	void triggerCentralRefresh();
 
 public slots:
 	int pictureItemClicked(QListWidgetItem* item);

ArchitectureColoredPainting/src/Editor/GraphicElement.h

@@ -20,7 +20,6 @@ class ComposedPainterPath;
 class GraphicElement
 {
 public:
-    size_t referencedCount = 0;
 	Renderer::ElementRenderer *renderer;
     QString name = "";
     int index;

ArchitectureColoredPainting/src/Editor/LayerStyle.cpp

@@ -2,7 +2,6 @@
 #include "./EditorWidgetComponent/StrokeStyleWidget.h"
 #include "./EditorWidgetComponent/FillStyleWidget.h"
 #include "./util/EncodeUtil.hpp"
-#include "../ColorHelper.hpp"
 #include <qtmaterialcheckbox.h>
 #include <QHBoxLayout>
 #include <QPushButton>
@@ -207,11 +206,11 @@ bool LayerStyleContainer::dropStyle(const QString& styleName)
 
 float LayerStyleContainer::boundingBoxAffectValue() const {
     float maxLineWidth = 0;
-    const auto strokeStyle = styles.find(StrokeElementLayerStyle::displayName());
+    const auto strokeStyle = styles.at(StrokeElementLayerStyle::displayName());
-    if (strokeStyle != styles.end())
+    if (strokeStyle != nullptr)
     {
         if (const auto strokeElementLayerStyle =
-            std::dynamic_pointer_cast<StrokeElementLayerStyle>(strokeStyle->second);
+				std::dynamic_pointer_cast<StrokeElementLayerStyle>(strokeStyle);
             strokeElementLayerStyle != nullptr)
         {
             const auto& leftStyleStroke = strokeElementLayerStyle->strokePair.first;
@@ -335,7 +334,7 @@ FillElementLayerStyle::FillElementLayerStyle(const PMaterialStyleFill& fillMater
 	if (!fillMaterialStyle)
 	{
         this->fillMaterialStyle = std::make_shared<MaterialStyleFill>(
-				std::make_shared<Renderer::FillPlain>(ColorHelper::instance().getPrimary1())
+				std::make_shared<Renderer::FillPlain>(Renderer::Material(QColor::fromRgb(0, 0, 0)))
             );
 	}
 }

ArchitectureColoredPainting/src/Editor/LayerWrapper.cpp

@@ -79,14 +79,6 @@ LeafLayerWrapper::LeafLayerWrapper(QJsonObject json, ElementManager* elementMana
     styles(LayerStyleContainer::fromJson(wrappedElement->isClosed(), json.value("styles").toArray()))
 {
     qDebug() << json.value("name").toString() << "    " << this;
-    if(wrappedElement != nullptr)
-        wrappedElement->referencedCount++;
-}
-
-LeafLayerWrapper::~LeafLayerWrapper()
-{
-    if (wrappedElement != nullptr)
-        wrappedElement->referencedCount--;
 }
 
 void LayerWrapper::SimpleProperty::apply(PixelPath&cache)
@@ -376,56 +368,4 @@ void FolderLayerWrapper::refreshTreeItem()
         this->qTreeWidgetItem->setText(1, "<< " + ele->name);
         this->qTreeWidgetItem->setTextColor(1, Qt::darkGreen);
     }
-	if (this->referencedCount() > 0)
-	{
-		this->qTreeWidgetItem->setToolTip(0,QString::fromLocal8Bit("子树被引用计数：") + QString::number(this->referencedCount(true)) + "\n"
-                                          + QString::fromLocal8Bit("当前节点被引用计数：") + QString::number(this->getReferencedBy() != -1));
-	}
-	else
-	{
-        this->qTreeWidgetItem->setToolTip(0, "");
-	}
 }
-
-size_t LayerWrapper::referencedCount(bool excludeSelf) const
-{
-	return 0;
-}
-
-size_t FolderLayerWrapper::referencedCount(bool excludeSelf) const
-{
-	size_t count = 0;
-	for (auto& child : children)
-		count += child->referencedCount();
-	if (!excludeSelf && this->getReferencedBy() != -1)
-		count++;
-	return count;
-}
-
-bool LayerWrapper::deleteable(bool excludeSubTree) const
-{
-	return true;
-}
-
-bool FolderLayerWrapper::deleteable(bool excludeSubTree) const
-{
-    if (excludeSubTree)
-        return this->getReferencedBy() == -1;
-	else
-		return this->referencedCount() == 0;
-}
-
-bool LayerWrapper::referencingGroupElement() const
-{
-	return false;
-}
-
-bool LeafLayerWrapper::referencingGroupElement() const
-{
-	return typeid(*wrappedElement) == typeid(GroupElement);
-}
-
-bool LayerWrapper::canApplyStyles() const
-{
-	return typeid(*this) == typeid(LeafLayerWrapper) && !referencingGroupElement();
-}

ArchitectureColoredPainting/src/Editor/LayerWrapper.h

@@ -71,10 +71,6 @@ class LayerWrapper
 	virtual void collectUpReachable(std::set<LayerWrapper*>& reachable);
 	virtual void collectDownReachable(std::set<LayerWrapper*>& reachable);
     virtual void refreshTreeItem();
-	virtual size_t referencedCount(bool excludeSelf = false) const;
-    virtual bool deleteable(bool excludeSubTree = false) const;
-    virtual bool referencingGroupElement() const;
-    bool canApplyStyles() const;
 };
 
 class FolderLayerWrapper : public LayerWrapper
@@ -100,8 +96,6 @@ class FolderLayerWrapper : public LayerWrapper
 	void paint(QPainter* painter, QTransform transform = QTransform(), bool ignoreSelected = false) override;
     void collectDownReachable(std::set<LayerWrapper*>& reachable) override;
     void refreshTreeItem() override;
-    size_t referencedCount(bool excludeSelf = false) const override;
-    bool deleteable(bool excludeSubTree = false) const override;
 };
 
 class LeafLayerWrapper : public LayerWrapper
@@ -111,7 +105,7 @@ class LeafLayerWrapper : public LayerWrapper
     LayerStyleContainer styles;
 
   public:
-	  ~LeafLayerWrapper();
+	  ~LeafLayerWrapper() = default;
     void refresh(LayerWrapper* layer = nullptr) override;
     LeafLayerWrapper(QJsonObject json, ElementManager *elementManager, FolderLayerWrapper*parent);
     QJsonObject toJson() const override;
@@ -119,7 +113,6 @@ class LeafLayerWrapper : public LayerWrapper
     void collectDownReachable(std::set<LayerWrapper*>& reachable) override;
     QTreeWidgetItem* getQTreeItem() override;
     void refreshTreeItem() override;
-    bool referencingGroupElement() const override;
 };
 
 Q_DECLARE_METATYPE(LayerWrapper *)

ArchitectureColoredPainting/src/Editor/RightBar/EditorSettingWidget.cpp

@@ -1,6 +1,6 @@
 #include "EditorSettingWidget.h"
-#include "../ColorHelper.hpp"
 #include <QPushButton>
+#include <QColorDialog>
 #include <QInputDialog>
 
 EditorSettingWidget::EditorSettingWidget(QWidget* parent)
@@ -8,7 +8,7 @@ EditorSettingWidget::EditorSettingWidget(QWidget* parent)
 {
 	ui.setupUi(this);
 	connect(ui.backgroundColorButton, &QPushButton::clicked, this, [this]() {
-			QColor color = ColorHelper::execColorDialog(Qt::white, this, QString::fromLocal8Bit("Ñ¡Ôñ±³¾°ÑÕÉ«"));
+			QColor color = QColorDialog::getColor(Qt::white, this, QString::fromLocal8Bit("Ñ¡Ôñ±³¾°ÑÕÉ«"));
 			if (color.isValid())
 			{
 				emit backgroundColorChanged(color);

ArchitectureColoredPainting/src/Editor/RightBar/InfoDisplayWidget.cpp

@@ -45,27 +45,32 @@ void InfoDisplayWidget::generateLayerForm()
         rotation->setValidator(new QIntValidator(-10000, 10000, this));
         connect(rotation, &QLineEdit::textChanged, [=](QString content) {
             this->displayLayer->property.rotation = content.toDouble();
-            emit triggerCentralRefresh();
+            emit requireRefreshElementWidget();
+            emit requireRefreshPreview();
         });
         offsetX->setValidator(new QIntValidator(-10000, 10000, this));
         connect(offsetX, &QLineEdit::textChanged, [=](QString content) {
             this->displayLayer->property.offset = {content.toDouble(), this->displayLayer->property.offset.y()};
-            emit triggerCentralRefresh();
+            emit requireRefreshElementWidget();
+            emit requireRefreshPreview();
         });
         offsetY->setValidator(new QIntValidator(-10000, 10000, this));
         connect(offsetY, &QLineEdit::textChanged, [=](QString content) {
             this->displayLayer->property.offset = {this->displayLayer->property.offset.x(), content.toDouble()};
-            emit triggerCentralRefresh();
+            emit requireRefreshElementWidget();
+            emit requireRefreshPreview();
         });
         scaleX->setValidator(new QDoubleValidator(-1000, 1000, 4, this));
         connect(scaleX, &QLineEdit::textChanged, [=](QString content) {
             this->displayLayer->property.scale = {content.toDouble(), this->displayLayer->property.scale.y()};
-            emit triggerCentralRefresh();
+            emit requireRefreshElementWidget();
+            emit requireRefreshPreview();
         });
         scaleY->setValidator(new QDoubleValidator(-1000, 1000, 4, this));
         connect(scaleY, &QLineEdit::textChanged, [=](QString content) {
             this->displayLayer->property.scale = {this->displayLayer->property.scale.x(), content.toDouble()};
-            emit triggerCentralRefresh();
+            emit requireRefreshElementWidget();
+            emit requireRefreshPreview();
         });
 
         layout->addRow("layer name:", name);
@@ -103,7 +108,10 @@ void InfoDisplayWidget::generateLayerForm()
                     {
                         leafP->styles.useStyle(dialog->layerStyle);
                         leafP->styles.computeNewHash();
-                        emit triggerCentralRefresh();
+
+                        emit requireRefreshPreview();
+                        emit requireSelfRefresh();
+                        emit requireRefreshElementWidget();
                     }
                     });
             }
@@ -145,7 +153,10 @@ void InfoDisplayWidget::generateLayerForm()
                         {
                             styleIterator->second = dialog->layerStyle;
                             styles->computeNewHash();
-                            emit triggerCentralRefresh();
+
+                            emit requireRefreshPreview();
+                            emit requireSelfRefresh();
+                            emit requireRefreshElementWidget();
                         }
                     });
 
@@ -154,7 +165,10 @@ void InfoDisplayWidget::generateLayerForm()
                     {
                         styles->dropStyle(styleIterator->first);
                     	styles->computeNewHash();
-                        emit triggerCentralRefresh();
+
+                        emit requireRefreshPreview();
+                        emit requireSelfRefresh();
+                        emit requireRefreshElementWidget();
                     });
 
                 QWidget* styleDisplayWidget = styleIterator->second->getListDisplayWidget();
@@ -176,12 +190,6 @@ void InfoDisplayWidget::generateLayerForm()
 }
 
 void InfoDisplayWidget::triggerSelfRefresh() 
-{
-    if (this->displayLayer != nullptr)
-        this->generateLayerForm();
-}
-
-void InfoDisplayWidget::refresh()
 {
     if (this->displayLayer != nullptr)
         this->generateLayerForm();

ArchitectureColoredPainting/src/Editor/RightBar/InfoDisplayWidget.h

@@ -16,13 +16,11 @@ class InfoDisplayWidget : public QWidget
   public:
     void setLayer(LayerWrapper *layer);
     void generateLayerForm();
-    void refresh();
     
   public slots:
     void triggerSelfRefresh();
 
-signals:
+  signals:
-    void triggerCentralRefresh();
     void requireRefreshPreview();
 	void requireSelfRefresh();
     void requireRefreshElementWidget();

ArchitectureColoredPainting/src/Editor/RightBar/LayerTreeWidget.cpp

@@ -24,7 +24,7 @@ LayerTreeWidget::LayerTreeWidget(QWidget *parent)
         else {
             emit displayLayerChange(nullptr);
         }
-        emit triggerCentralRefresh();
+        emit requireRefreshPreview();
     });
     // connect(this, &QTreeWidget::itemDoubleClicked, this, &LayerTreeWidget::onItemDoubleClicked);
 }
@@ -62,7 +62,9 @@ void LayerTreeWidget::popMenu(const QPoint &pos)
 					    folderLayer->addChild(std::shared_ptr<LayerWrapper>(newLayer));
 						folderLayer->qTreeWidgetItem->addChild(newLayer->getQTreeItem());
                         qDebug() << jsonObj<<"----------------------";
-                        emit triggerCentralRefresh();
+                        this->refresh();
+                        emit requireRefreshPreview(); 
+                        emit requireRefreshElementWidget();
                         });
                     dialog->exec();
                     });
@@ -72,20 +74,20 @@ void LayerTreeWidget::popMenu(const QPoint &pos)
                     auto layer = this->selectedItem->data(0, Qt::UserRole).value<LayerWrapper*>();
                     layer->del();
                     layer->getParent()->removeChild(layer);
-                    emit triggerCentralRefresh();
+                    this->refresh();
+                    emit requireRefreshPreview();
+                    emit requireRefreshElementWidget();
                     });
-				menu.actions().last()->setEnabled(layer->deleteable());
                 menu.addAction(QString::fromLocal8Bit("重命名"), this, &LayerTreeWidget::onRenameEvent);
                 if(typeid(*layer) == typeid(FolderLayerWrapper))
-                {
                     menu.addAction(QString::fromLocal8Bit("删除（保留子节点）"), this, [this]() {
                         auto layer = this->selectedItem->data(0, Qt::UserRole).value<LayerWrapper*>();
-                    layer->delSelf();
+                        layer->delSelf();
-                    layer->getParent()->removeChild(layer);
+                        layer->getParent()->removeChild(layer);
-                    emit triggerCentralRefresh();
+                        this->refresh();               
+                        emit requireRefreshPreview();
+                        emit requireRefreshElementWidget();
                         });
-					menu.actions().last()->setEnabled(layer->deleteable(true));
-                }
             }
             if (typeid(*layer) == typeid(FolderLayerWrapper) && ((FolderLayerWrapper*)layer)->getReferencedBy() == -1) {
                 menu.addAction(QString::fromLocal8Bit("创建组合元素"), this, [this]() {
@@ -97,7 +99,7 @@ void LayerTreeWidget::popMenu(const QPoint &pos)
                             "", &ok);
                         if (ok && !name.isEmpty()) {
                             elementManager->createGroupElement(name, layer);
-                            emit triggerCentralRefresh();
+                            emit requireRefreshElementWidget();
                         }
                     }
                     });

ArchitectureColoredPainting/src/Editor/RightBar/LayerTreeWidget.h

@@ -21,7 +21,6 @@ class LayerTreeWidget : public QTreeWidget
     // void onItemDoubleClicked(QTreeWidgetItem *item, int column = 0);
 
 signals:
-    void triggerCentralRefresh();
     void displayLayerChange(LayerWrapper *);
     void requireRefreshPreview();
 	void requireRefreshElementWidget();

ArchitectureColoredPainting/src/Editor/util/PaintingUtil.cpp

@@ -5,7 +5,7 @@
 #include <queue>
 
 using Renderer::Painting;
-using Renderer::BaseElement;
+using Renderer::Element;
 using Renderer::ElementTransform;
 using glm::bvec2;
 using std::max;
@@ -17,124 +17,161 @@ using std::queue;
 const double PaintingUtil::pi = acos(-1);
 
 struct LayerNode {
-	LayerWrapper* nowLayer;
+    LayerWrapper* nowLayer;
-	QTransform transfrom;
+    QTransform transfrom;
+    bvec2 flip;
 };
 
 QJsonObject PaintingUtil::readJsonFile(QString jsonFilePath) {
-	QFile jsonFile(jsonFilePath);
+    QFile jsonFile(jsonFilePath);
-	qDebug() << jsonFilePath;
+    jsonFile.open(QFile::ReadOnly);
-	jsonFile.open(QFile::ReadOnly);
+    QByteArray fileContent = jsonFile.readAll().trimmed();
-	QByteArray fileContent = jsonFile.readAll().trimmed();
+    jsonFile.close();
-	jsonFile.close();
+    QJsonParseError jError;
-	QJsonParseError jError;
+    QJsonDocument jsonDoc(QJsonDocument::fromJson(fileContent, &jError));
-	QJsonDocument jsonDoc(QJsonDocument::fromJson(fileContent, &jError));
+    return jsonDoc.object();
-	return jsonDoc.object();
 }
 
 Painting PaintingUtil::transfromToPainting(QString jsonFilePath) {
-	Painting painting;
+    Painting painting;
-	glm::bvec2 flip(0, 0);
+    glm::bvec2 flip(0, 0);
-	QJsonObject jsonObj = readJsonFile(jsonFilePath);
+    QJsonObject jsonObj = readJsonFile(jsonFilePath);
-	qDebug() << jsonObj;
+    qDebug() << jsonObj;
-	shared_ptr<ElementManager> elementManager = make_shared<ElementManager>(jsonObj, Renderer::ElementRenderer::instance());
+    shared_ptr<ElementManager> elementManager = make_shared<ElementManager>(jsonObj, Renderer::ElementRenderer::instance());
-	shared_ptr<LayerManager> layerManager = make_shared<LayerManager>(jsonObj, elementManager.get());
+    shared_ptr<LayerManager> layerManager = make_shared<LayerManager>(jsonObj, elementManager.get());
-	//qDebug() << elementManager->toJson();
+    //qDebug() << elementManager->toJson();
-	//qDebug() << layerManager->toJson();
+    //qDebug() << layerManager->toJson();
 	//qDebug() << ((SimpleElement*)((LeafLayerWrapper*)((FolderLayerWrapper*)((FolderLayerWrapper*)layerManager->getRoot())->children[0].get())->children[0].get())->wrappedElement)->painterPath;
-	//qDebug() << ((LeafLayerWrapper*)((FolderLayerWrapper*)((FolderLayerWrapper*)layerManager->getRoot())->children[0].get())->children[0].get())->getCache().painterPath;
+    //qDebug() << ((LeafLayerWrapper*)((FolderLayerWrapper*)((FolderLayerWrapper*)layerManager->getRoot())->children[0].get())->children[0].get())->getCache().painterPath;
-	//qDebug() << elementManager->toJson();
+    queue<LayerNode> layerQueue;
-	//qDebug() << layerManager->toJson(); 
+    LayerWrapper* root = layerManager->getRoot();
-	//qDebug() << ((SimpleElement*)((LeafLayerWrapper*)((FolderLayerWrapper*)((FolderLayerWrapper*)layerManager->getRoot())->children[0].get())->children[0].get())->wrappedElement)->painterPath;
+    root->getCache();
-	//qDebug() << ((LeafLayerWrapper*)((FolderLayerWrapper*)((FolderLayerWrapper*)layerManager->getRoot())->children[0].get())->children[0].get())->getCache().painterPath;
+    layerQueue.push({ root, root->property.transform, flip });
-	queue<LayerNode> layerQueue;
+    while (!layerQueue.empty()) {
-	LayerWrapper* root = layerManager->getRoot();
+        auto layerNode = layerQueue.front(); 
-	root->getCache();
+        layerQueue.pop();
-	//double maxLineWidth = getMaxLineWidth(root);
+        FolderLayerWrapper* nowLayer = handleLayerWrapper(layerNode.nowLayer, layerNode.transfrom, layerNode.flip, painting);
-	layerQueue.push({ root, root->property.transform });
+        if (nowLayer != nullptr) {
-	while (!layerQueue.empty()) {
+            for (auto sonLayer : nowLayer->children) {
-		auto layerNode = layerQueue.front();
+                layerQueue.push({ sonLayer.get(), layerNode.transfrom, layerNode.flip});
-		layerQueue.pop();
+            }
-		FolderLayerWrapper* nowLayer = handleLayerWrapper(layerNode.nowLayer, layerNode.transfrom, painting);
+        }
-		if (nowLayer != nullptr) {
+    }
-			for (auto sonLayer : nowLayer->children) {
+   
-				layerQueue.push({ sonLayer.get(), layerNode.transfrom });
+    return painting;
-			}
-		}
-	}
-
-	return painting;
 }
 
-FolderLayerWrapper* PaintingUtil::handleLayerWrapper(LayerWrapper* nowLayer, QTransform& transform, Painting& painting) {
+FolderLayerWrapper* PaintingUtil::handleLayerWrapper(LayerWrapper* nowLayer, QTransform& transform, bvec2& flip, Painting& painting) {
-	LeafLayerWrapper* leafLayer = dynamic_cast<LeafLayerWrapper*>(nowLayer);
+    LeafLayerWrapper* leafLayer = dynamic_cast<LeafLayerWrapper*>(nowLayer);
+    flip ^= bvec2(nowLayer->property.flipHorizontally, nowLayer->property.flipVertically);
 
-	transform = nowLayer->property.transform * transform;
+    transform = nowLayer->property.transform * transform;
 
-	if (leafLayer != nullptr) {
+    if (leafLayer != nullptr) {
 
-		GroupElement* wrapperElement = dynamic_cast<GroupElement*>(leafLayer->wrappedElement);
+        GroupElement* wrapperElement = dynamic_cast<GroupElement*>(leafLayer->wrappedElement);
-		if (wrapperElement != nullptr) {
+        if (wrapperElement != nullptr) {
-			transform = wrapperElement->sourceLayer->property.transform * transform;
+            transform = wrapperElement->sourceLayer->property.transform * transform;
-			return wrapperElement->sourceLayer;
+            return wrapperElement->sourceLayer;
-		}
+        }
 
-		PixelPath pixelPath = nowLayer->getCache();
+        PixelPath pixelPath = nowLayer->getCache();
-		QPainterPath painterPath = pixelPath.getPainterPath();
+        QPainterPath painterPath = pixelPath.getPainterPath();
-		QRectF bound = painterPath.boundingRect();
+        QRectF bound = painterPath.boundingRect();
-		//qDebug() << leafLayer<<"------" << painterPath;
+        //qDebug() << leafLayer<<"------" << painterPath;
-		//qDebug() << transform;
+        //qDebug() << transform;
-		// transform to initial painterPath
+        Element element;
-		// transfrom to -1£¬ 1
+        ElementTransform elementTrans;
-		QTransform trans;
+        element.ratio = bound.width() / bound.height();
-		double maxLen = std::max(bound.width(), bound.height());
+        // transform to initial painterPath
-		qDebug() << maxLen << bound;
+        // transfrom to -1£¬ 1
-		trans.scale(1 / maxLen, 1 / maxLen);
+        QTransform trans;
-		trans.translate(-bound.center().x(), -bound.center().y());
+        trans.scale(1 / bound.width(), 1 / bound.height());
+        trans.translate(-bound.center().x(), -bound.center().y());
+        
+        qDebug() << trans.map(painterPath);
+        element.contour = std::make_shared<vector<vector<Renderer::Point> >>(PainterPathUtil::transformToLines(trans.map(painterPath)));
+        QSize screenSize = QSize(1024, 1024);
+        element.style = std::make_shared<Renderer::ElementStyleStrokeDemo>(0.06);
+         
+        
+        painterPath = transform.map(painterPath);
+        qDebug() << painterPath;
+        bound = painterPath.boundingRect();
+        qDebug() << bound;
 
-		painterPath = trans.map(painterPath);
+        // TODO ¸ÄÓþØÕó
-		shared_ptr<vector<vector<Renderer::Point> >> contour = std::make_shared<vector<vector<Renderer::Point> >>(PainterPathUtil::transformToLines(painterPath));
-		QSize screenSize = QSize(1024, 1024);
 
-		ElementTransform elementTransform;
+      /*  elementTrans.center = glm::vec2(
-		transform = trans.inverted() * transform * QTransform::fromScale(2. / screenSize.width(), 2. / screenSize.height()) * QTransform::fromTranslate(-1, -1) * QTransform::fromScale(1, -1);
+            (2 * bound.center().x() - screenSize.width()) / screenSize.width(),
-
+            (2 * bound.center().y() - screenSize.height()) / screenSize.height()
-		auto baseStyles = leafLayer->styles.toBaseStyles();
+        );
-		Renderer::BaseElement element;
+        qDebug() << elementTrans.center.x << elementTrans.center.y;
-		element.contour = contour;
+        decomposeTransform(transform, elementTrans.rotation, elementTrans.scale);
-		for (auto baseStyle : baseStyles) {
+        elementTrans.scale = glm::vec2(
-			double lineWidth = 0;
+            bound.width() * 2 / screenSize.width(),
-			if (baseStyle.material->type() == Renderer::MaterialStyleType::kStroke) {
+            bound.height() * 2 / screenSize.height()
-				auto material = dynamic_cast<MaterialStyleStroke*>(baseStyle.material.get());
+        );
-				material->halfWidth = material->halfWidth / maxLen;
+        elementTrans.flip = glm::bvec2(
-				lineWidth = material->halfWidth;
+            nowLayer->property.flipHorizontally,
-				qDebug() << material->halfWidth;
+            nowLayer->property.flipVertically
-			}
+        );
-			QRectF rect = painterPath.boundingRect();
+        qDebug() << elementTrans.scale.x << elementTrans.scale.y;
-			rect.setX(-lineWidth + rect.x());
+        painting.addElement(element, elementTrans);*/
-			rect.setY(-lineWidth + rect.y());
+        return nullptr;
-			rect.setWidth(lineWidth * 2 + rect.width());
+    }
-			rect.setHeight(lineWidth * 2 + rect.height());
+    
-			QPainterPath path;
+    FolderLayerWrapper* folderLayer = dynamic_cast<FolderLayerWrapper*>(nowLayer);
-			path.addRect(rect);
+    return folderLayer;
-			rect = transform.map(path).boundingRect();
+}
-			elementTransform.bound = glm::vec4(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
+void PaintingUtil::decomposeTransform(QTransform trans, float& angle, glm::vec2& scale) {
-			qDebug() << elementTransform.bound.x << elementTransform.bound.y << elementTransform.bound.z << elementTransform.bound.z;
+    //qDebug() << trans;
-			transform = transform.inverted();
+    trans.setMatrix(
-			elementTransform.transform = glm::mat3x2(
+        trans.m11(), trans.m12(), trans.m13(),
-				transform.m11(), transform.m12(), transform.m21(),
+        trans.m21(), trans.m22(), trans.m23(),
-				transform.m22(), transform.m31(), transform.m32()
+        0, 0, 1);
-			);
+    //qDebug() << trans.dx() << trans.dy();
-			qDebug() << transform;
+    int count = 0;
-			elementTransform.zIndex = 0;
+    double norm = 0, n = 0;
-
+    QTransform R = trans, Rit, Rnext;
-			element.style = baseStyle.material;
+    do {
-			painting.addElement(element, elementTransform);
+        ++count;
-		}
+        Rit = R.transposed().inverted();
-
+        Rnext.setMatrix(
-		return nullptr;
+            (R.m11() + Rit.m11()) / 2,
-	}
+            (R.m12() + Rit.m12()) / 2,
-
+            (R.m13() + Rit.m13()) / 2,
-	FolderLayerWrapper* folderLayer = dynamic_cast<FolderLayerWrapper*>(nowLayer);
+            (R.m21() + Rit.m21()) / 2,
-	return folderLayer;
+            (R.m22() + Rit.m22()) / 2,
+            (R.m23() + Rit.m23()) / 2,
+            (R.m31() + Rit.m31()) / 2,
+            (R.m32() + Rit.m32()) / 2,
+            (R.m33() + Rit.m33()) / 2
+        );
+        norm = 0;
+        norm = max(norm,
+            fabs(R.m11() - Rnext.m11())
+            + fabs(R.m12() - Rnext.m12())
+                + fabs(R.m13() - Rnext.m13()));
+        norm = max(norm,
+            fabs(R.m21() - Rnext.m21())
+            + fabs(R.m22() - Rnext.m22())
+                + fabs(R.m23() - Rnext.m23()));
+        norm = max(norm,
+            fabs(R.m31() - Rnext.m31())
+            + fabs(R.m32() - Rnext.m32())
+                + fabs(R.m33() - Rnext.m33()));
+        R = Rnext;
+    } while (count < 100 && norm > 0.0001);
+    double cosValue = max(-1.0, min(R.m11(), 1.0));    
+    double sinValue = max(-1.0, min(R.m12(), 1.0));
+    angle = acos(cosValue) * 180 / pi;
+    if (sinValue < 0) {
+        angle = 360 - angle;
+    }
+    qDebug() << angle;
+    //R = R.inverted() * trans;
+    //scale = glm::vec2(R.m11(), R.m22());
+    //qDebug() << scale.x << scale.y;
+    return;
 }

ArchitectureColoredPainting/src/Editor/util/PaintingUtil.h

@@ -7,9 +7,10 @@ class PaintingUtil
 private:
 	static const double pi;
 	static QJsonObject readJsonFile(QString jsonFilePath);
-	static FolderLayerWrapper* handleLayerWrapper(LayerWrapper* nowLayer, QTransform& transform, Renderer::Painting& painting);
+	static FolderLayerWrapper* handleLayerWrapper(LayerWrapper* nowLayer, QTransform& transform, glm::bvec2& flip, Renderer::Painting& painting);
-	//static double getMaxLineWidth(LayerWrapper* root);
+public:	
-public:
 	static Renderer::Painting transfromToPainting(QString jsonFilePath);
+	static void decomposeTransform(QTransform trans, float& angle, glm::vec2& scale);
+	
 };
 

ArchitectureColoredPainting/src/FluentMenu.cpp

@@ -21,9 +21,4 @@ void ::FluentMenu::paintEvent(QPaintEvent* event)
 		painter.drawRoundedRect(QRectF(shadowRadius - i, shadowRadius - i, width() - (shadowRadius - i) * 2, height() - (shadowRadius - i) * 2), borderRadius + i, borderRadius + i);
 	}
 	QMenu::paintEvent(event);
-}
+}
-
-QAction* FluentMenu::exec(const QPoint& pos, QAction* at)
-{
-	return QMenu::exec(parentWidget()->mapToGlobal(parentWidget()->mapFromGlobal(pos) + QPoint(-shadowRadius, -shadowRadius)), at);
-}

ArchitectureColoredPainting/src/FluentMenu.h

@@ -7,7 +7,6 @@ class FluentMenu : public QMenu
 public:
 	explicit FluentMenu(QWidget* parent = nullptr);
 	void paintEvent(QPaintEvent* event) override;
-	QAction* exec(const QPoint& pos, QAction* at = nullptr);
 	int shadowRadius = 16;
 	int borderRadius = 6;
 	int itemBorderRadius = 4;

ArchitectureColoredPainting/src/Renderer/Model.cpp

@@ -244,9 +244,8 @@ GLuint Renderer::Model::loadPainting(std::string path)
 		return iter->second;
 
 	Painting painting;
-	path = "../test.json";
 	if (auto file = QFileInfo(QString(path.c_str())); file.isFile())
-		painting = PaintingUtil::transfromToPainting(file.filePath());
+		painting = PaintingUtil::transfromToPainting(file.path());
 	else
 	{
 		qDebug() << path.c_str() << "Not Found, Using Default Painting";

ArchitectureColoredPainting/src/Renderer/Painting/BvhTree.cpp

@@ -20,12 +20,12 @@ QVector4D BvhTree::Union(QVector4D a, QVector4D b) {
 
 QVector4D BvhTree::merge(BvhPtr lp, BvhPtr rp) {
 	QVector4D a = lp->bound, b = rp->bound;
-	/*if (lp->isLeaf) {
+	if (lp->isLeaf) {
 		a = BvhTreeData::boundWithRotation(a, lp->getRightSon());
 	}
 	if (rp->isLeaf) {
 		b = BvhTreeData::boundWithRotation(b, rp->getRightSon());
-	}*/
+	}
 	return Union(a, b);
 }
 

ArchitectureColoredPainting/src/Renderer/RendererWidget.cpp

@@ -29,7 +29,7 @@ Renderer::RendererWidget::RendererWidget(QWidget* parent)
 		ui.openButton->setChecked(false);
 	});
 	QObject::connect(ui.openButton, &QPushButton::clicked, [&, menu]() {
-		menu->exec(ui.openButton->mapToGlobal(QPoint(0, ui.openButton->height())));
+		menu->exec(ui.openButton->mapToGlobal(QPoint(-menu->shadowRadius, ui.openButton->height() - menu->shadowRadius)));
 	});
 
 	QObject::connect(ui.horizontalSlider, &QSlider::valueChanged,

ArchitectureColoredPainting/src/main.cpp

@@ -1,11 +1,11 @@
 #include "MainWindow.h"
-#include "ColorHelper.hpp"
 #include <QGuiApplication>
 #include <QtWidgets/QApplication>
 #include <FramelessHelper/Core/private/framelessconfig_p.h>
 #include <iostream>
 #include <format>
 #include "consoleapi2.h"
+#include <lib/qtmaterialstyle.h>
 
 extern "C"
 {
@@ -51,7 +51,9 @@ int main(int argc, char* argv[])
 	QApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
 	QApplication a(argc, argv);
 	Q_INIT_RESOURCE(resources);
-	ColorHelper::instance();
+	QtMaterialTheme theme;
+	theme.setColor("primary1", QColor(0, 90, 158));
+	QtMaterialStyle::instance().setTheme(&theme);
 	//FramelessHelper::Core::setApplicationOSThemeAware();
 	FramelessConfig::instance()->set(Global::Option::ForceNonNativeBackgroundBlur);
 	//FramelessConfig::instance()->set(Global::Option::EnableBlurBehindWindow);

test.json

@@ -1,131 +0,0 @@
-{
-    "background-color": "#ffffff",
-    "elements": [
-        {
-            "data": {
-                "include": "../svg/2.svg"
-            },
-            "name": "ababa",
-            "type": "svg-file"
-        },
-        {
-            "data": {
-                "reference-layer": "0.0"
-            },
-            "name": "ababa-group",
-            "type": "group"
-        },
-        {
-            "data": {
-                "include": "../svg/0.svg"
-            },
-            "name": "ababa2",
-            "type": "svg-file"
-        }
-    ],
-    "height": 1080,
-    "project-name": "样例1",
-    "root-layer": {
-        "children": [
-            {
-                "children": [
-                    {
-                        "element": 0,
-                        "is-folder": false,
-                        "name": "Leaf1",
-                        "styles": [
-                            {
-                                "enableEachSideIndependent": false,
-                                "left": "AAAAQAEAIZwAf///qqr//w==",
-                                "right": "AADgQAAACJw=",
-                                "type": "stroke"
-                            }
-                        ],
-                        "transform": {
-                            "offset": {
-                                "x": 0,
-                                "y": 0
-                            },
-                            "rotation": 0,
-                            "scale": {
-                                "x": 1,
-                                "y": 1
-                            }
-                        }
-                    },
-                    {
-                        "element": 0,
-                        "is-folder": false,
-                        "name": "Leaf2",
-                        "styles": [
-                            {
-                                "enableEachSideIndependent": false,
-                                "left": "AAAAQAEAIZwAf////1UA/w==",
-                                "right": "AADgQAAACJw=",
-                                "type": "stroke"
-                            }
-                        ],
-                        "transform": {
-                            "offset": {
-                                "x": 150,
-                                "y": 0
-                            },
-                            "rotation": 0,
-                            "scale": {
-                                "x": 1.5,
-                                "y": 1.5
-                            }
-                        }
-                    }
-                ],
-                "is-folder": true,
-                "name": "GroupFolderExample",
-                "referenced-by": 1,
-                "transform": {
-                    "offset": {
-                        "x": 50,
-                        "y": 50
-                    },
-                    "rotation": 0,
-                    "scale": {
-                        "x": 1,
-                        "y": 1
-                    }
-                }
-            },
-            {
-                "element": 1,
-                "is-folder": false,
-                "name": "ReferencingGroupLayer",
-                "styles": [
-                ],
-                "transform": {
-                    "offset": {
-                        "x": 100,
-                        "y": 0
-                    },
-                    "rotation": 45,
-                    "scale": {
-                        "x": 1,
-                        "y": 1
-                    }
-                }
-            }
-        ],
-        "is-folder": true,
-        "name": "root",
-        "referenced-by": null,
-        "transform": {
-            "offset": {
-                "x": 0,
-                "y": 0
-            },
-            "rotation": 0,
-            "scale": {
-                "x": 1,
-                "y": 1
-            }
-        }
-    },
-    "width": 1080
-}